make version of ts_mon compatible with appengine

appengine/chromium_build_logs/third_party/googleapiclient/schema.py

-# Copyright (C) 2010 Google Inc.
+# Copyright 2014 Google Inc. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ skipping 37 matching lines @@
 
   {
    "nextPageToken": "A String", # Token used to access the
        # next page of this result. Omitted if no further results are available.
    "kind": "A String", # Type of the collection ('calendar#acl').
    "etag": "A String", # ETag of the collection.
   },
 
 The constructor takes a discovery document in which to look up named schema.
 """
+from __future__ import absolute_import
+import six
 
 # TODO(jcgregorio) support format, enum, minimum, maximum
 
 __author__ = 'jcgregorio@google.com (Joe Gregorio)'
 
 import copy
-from oauth2client.anyjson import simplejson
+
+from oauth2client import util
 
 
 class Schemas(object):
   """Schemas for an API."""
 
   def __init__(self, discovery):
     """Constructor.
 
     Args:
       discovery: object, Deserialized discovery document from which we pull
         out the named schema.
     """
     self.schemas = discovery.get('schemas', {})
 
     # Cache of pretty printed schemas.
     self.pretty = {}
 
+  @util.positional(2)
   def _prettyPrintByName(self, name, seen=None, dent=0):
     """Get pretty printed object prototype from the schema name.
 
     Args:
       name: string, Name of schema in the discovery document.
       seen: list of string, Names of schema already seen. Used to handle
         recursive definitions.
 
     Returns:
       string, A string that contains a prototype object with
         comments that conforms to the given schema.
     """
     if seen is None:
       seen = []
 
     if name in seen:
       # Do not fall into an infinite loop over recursive definitions.
       return '# Object with schema name: %s' % name
     seen.append(name)
 
     if name not in self.pretty:
       self.pretty[name] = _SchemaToStruct(self.schemas[name],
-          seen, dent).to_str(self._prettyPrintByName)
+          seen, dent=dent).to_str(self._prettyPrintByName)
 
     seen.pop()
 
     return self.pretty[name]
 
   def prettyPrintByName(self, name):
     """Get pretty printed object prototype from the schema name.
 
     Args:
       name: string, Name of schema in the discovery document.
 
     Returns:
       string, A string that contains a prototype object with
         comments that conforms to the given schema.
     """
     # Return with trailing comma and newline removed.
     return self._prettyPrintByName(name, seen=[], dent=1)[:-2]
 
+  @util.positional(2)
   def _prettyPrintSchema(self, schema, seen=None, dent=0):
     """Get pretty printed object prototype of schema.
 
     Args:
       schema: object, Parsed JSON schema.
       seen: list of string, Names of schema already seen. Used to handle
         recursive definitions.
 
     Returns:
       string, A string that contains a prototype object with
         comments that conforms to the given schema.
     """
     if seen is None:
       seen = []
 
-    return _SchemaToStruct(schema, seen, dent).to_str(self._prettyPrintByName)
+    return _SchemaToStruct(schema, seen, dent=dent).to_str(self._prettyPrintByName)
 
   def prettyPrintSchema(self, schema):
     """Get pretty printed object prototype of schema.
 
     Args:
       schema: object, Parsed JSON schema.
 
     Returns:
       string, A string that contains a prototype object with
         comments that conforms to the given schema.
     """
     # Return with trailing comma and newline removed.
     return self._prettyPrintSchema(schema, dent=1)[:-2]
 
   def get(self, name):
     """Get deserialized JSON schema from the schema name.
 
     Args:
       name: string, Schema name.
     """
     return self.schemas[name]
 
 
 class _SchemaToStruct(object):
   """Convert schema to a prototype object."""
 
+  @util.positional(3)
   def __init__(self, schema, seen, dent=0):
     """Constructor.
 
     Args:
       schema: object, Parsed JSON schema.
       seen: list, List of names of schema already seen while parsing. Used to
         handle recursive definitions.
       dent: int, Initial indentation depth.
     """
     # The result of this parsing kept as list of strings.
@@ skipping 61 matching lines @@
     Args:
       schema: object, Parsed JSON schema file.
 
     Returns:
       Prototype object based on the schema, in Python code with comments.
     """
     stype = schema.get('type')
     if stype == 'object':
       self.emitEnd('{', schema.get('description', ''))
       self.indent()
-      for pname, pschema in schema.get('properties', {}).iteritems():
-        self.emitBegin('"%s": ' % pname)
-        self._to_str_impl(pschema)
+      if 'properties' in schema:
+        for pname, pschema in six.iteritems(schema.get('properties', {})):
+          self.emitBegin('"%s": ' % pname)
+          self._to_str_impl(pschema)
+      elif 'additionalProperties' in schema:
+        self.emitBegin('"a_key": ')
+        self._to_str_impl(schema['additionalProperties'])
       self.undent()
       self.emit('},')
     elif '$ref' in schema:
       schemaName = schema['$ref']
       description = schema.get('description', '')
-      s = self.from_cache(schemaName, self.seen)
+      s = self.from_cache(schemaName, seen=self.seen)
       parts = s.splitlines()
       self.emitEnd(parts[0], description)
       for line in parts[1:]:
         self.emit(line.rstrip())
     elif stype == 'boolean':
       value = schema.get('default', 'True or False')
       self.emitEnd('%s,' % str(value), schema.get('description', ''))
     elif stype == 'string':
       value = schema.get('default', 'A String')
       self.emitEnd('"%s",' % str(value), schema.get('description', ''))
@@ skipping 28 matching lines @@
       from_cache: callable(name, seen), Callable that retrieves an object
          prototype for a schema with the given name. Seen is a list of schema
          names already seen as we recursively descend the schema definition.
 
     Returns:
       Prototype object based on the schema, in Python code with comments.
       The lines of the code will all be properly indented.
     """
     self.from_cache = from_cache
     return self._to_str_impl(self.schema)