29 from google.appengine.datastore.entity_pb import EntityProto

    29 from google.appengine.datastore.entity_pb import EntityProto

    30 from google.appengine.datastore.entity_pb import Index

    30 from google.appengine.datastore.entity_pb import Index

    31 from google.appengine.datastore.entity_pb import Property

    31 from google.appengine.datastore.entity_pb import Property

    32 from google.appengine.datastore.entity_pb import Reference

    32 from google.appengine.datastore.entity_pb import Reference

    33 class Transaction(ProtocolBuffer.ProtocolMessage):

    33 class Transaction(ProtocolBuffer.ProtocolMessage):

    34   def __init__(self, contents=None):

    37   def __init__(self, contents=None):

    37     if contents is not None: self.MergeFromString(contents)

    38     if contents is not None: self.MergeFromString(contents)

    38 

    39 

    39   def handle(self): return self.handle_

    40   def handle(self): return self.handle_

    40 

    41 

    41   def set_handle(self, x):

    42   def set_handle(self, x):

   135   }

   136   }

   136 

   137 

   137   def Operator_Name(cls, x): return cls._Operator_NAMES.get(x, "")

   138   def Operator_Name(cls, x): return cls._Operator_NAMES.get(x, "")

   138   Operator_Name = classmethod(Operator_Name)

   139   Operator_Name = classmethod(Operator_Name)

   139 

   140 

   140   def __init__(self, contents=None):

   144   def __init__(self, contents=None):

   142     self.property_ = []

   145     self.property_ = []

   144     if contents is not None: self.MergeFromString(contents)

   146     if contents is not None: self.MergeFromString(contents)

   145 

   147 

   146   def op(self): return self.op_

   148   def op(self): return self.op_

   147 

   149 

   148   def set_op(self, x):

   150   def set_op(self, x):

   196     initialized = 1

   198     initialized = 1

   197     if (not self.has_op_):

   199     if (not self.has_op_):

   198       initialized = 0

   200       initialized = 0

   199       if debug_strs is not None:

   201       if debug_strs is not None:

   200         debug_strs.append('Required field: op not set.')

   202         debug_strs.append('Required field: op not set.')

   203     return initialized

   205     return initialized

   204 

   206 

   205   def ByteSize(self):

   207   def ByteSize(self):

   206     n = 0

   208     n = 0

   207     n += self.lengthVarInt64(self.op_)

   209     n += self.lengthVarInt64(self.op_)

   262   }

   264   }

   263 

   265 

   264   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")

   266   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")

   265   Direction_Name = classmethod(Direction_Name)

   267   Direction_Name = classmethod(Direction_Name)

   266 

   268 

   267   def __init__(self, contents=None):

   274   def __init__(self, contents=None):

   272     if contents is not None: self.MergeFromString(contents)

   275     if contents is not None: self.MergeFromString(contents)

   273 

   276 

   274   def property(self): return self.property_

   277   def property(self): return self.property_

   275 

   278 

   276   def set_property(self, x):

   279   def set_property(self, x):

   373   }

   376   }

   374 

   377 

   375   def Plan_Name(cls, x): return cls._Plan_NAMES.get(x, "")

   378   def Plan_Name(cls, x): return cls._Plan_NAMES.get(x, "")

   376   Plan_Name = classmethod(Plan_Name)

   379   Plan_Name = classmethod(Plan_Name)

   377 

   380 

   378   def __init__(self, contents=None):

   398   def __init__(self, contents=None):

   382     self.filter_ = []

   399     self.filter_ = []

   384     self.order_ = []

   400     self.order_ = []

   388     self.composite_index_ = []

   401     self.composite_index_ = []

   398     self.lazy_init_lock_ = thread.allocate_lock()

   402     self.lazy_init_lock_ = thread.allocate_lock()

   399     if contents is not None: self.MergeFromString(contents)

   403     if contents is not None: self.MergeFromString(contents)

   400 

   404 

   401   def app(self): return self.app_

   405   def app(self): return self.app_

   402 

   406 

   602     if (not self.has_app_):

   606     if (not self.has_app_):

   603       initialized = 0

   607       initialized = 0

   604       if debug_strs is not None:

   608       if debug_strs is not None:

   605         debug_strs.append('Required field: app not set.')

   609         debug_strs.append('Required field: app not set.')

   606     if (self.has_ancestor_ and not self.ancestor_.IsInitialized(debug_strs)): initialized = 0

   610     if (self.has_ancestor_ and not self.ancestor_.IsInitialized(debug_strs)): initialized = 0

   613     return initialized

   617     return initialized

   614 

   618 

   615   def ByteSize(self):

   619   def ByteSize(self):

   616     n = 0

   620     n = 0

   617     n += self.lengthString(len(self.app_))

   621     n += self.lengthString(len(self.app_))

   851   )

   855   )

   852 

   856 

   853   _STYLE = """"""

   857   _STYLE = """"""

   854   _STYLE_CONTENT_TYPE = """"""

   858   _STYLE_CONTENT_TYPE = """"""

   855 class QueryExplanation(ProtocolBuffer.ProtocolMessage):

   859 class QueryExplanation(ProtocolBuffer.ProtocolMessage):

   856   def __init__(self, contents=None):

   867   def __init__(self, contents=None):

   858     self.native_index_ = []

   868     self.native_index_ = []

   864     if contents is not None: self.MergeFromString(contents)

   869     if contents is not None: self.MergeFromString(contents)

   865 

   870 

   866   def native_ancestor(self): return self.native_ancestor_

   871   def native_ancestor(self): return self.native_ancestor_

   867 

   872 

   868   def set_native_ancestor(self, x):

   873   def set_native_ancestor(self, x):

   942   def __ne__(self, other):

   947   def __ne__(self, other):

   943     return not (self == other)

   948     return not (self == other)

   944 

   949 

   945   def IsInitialized(self, debug_strs=None):

   950   def IsInitialized(self, debug_strs=None):

   946     initialized = 1

   951     initialized = 1

   949     return initialized

   954     return initialized

   950 

   955 

   951   def ByteSize(self):

   956   def ByteSize(self):

   952     n = 0

   957     n = 0

   953     if (self.has_native_ancestor_): n += 2

   958     if (self.has_native_ancestor_): n += 2

  1041   )

  1046   )

  1042 

  1047 

  1043   _STYLE = """"""

  1048   _STYLE = """"""

  1044   _STYLE_CONTENT_TYPE = """"""

  1049   _STYLE_CONTENT_TYPE = """"""

  1045 class Cursor(ProtocolBuffer.ProtocolMessage):

  1050 class Cursor(ProtocolBuffer.ProtocolMessage):

  1046   def __init__(self, contents=None):

  1054   def __init__(self, contents=None):

  1049     if contents is not None: self.MergeFromString(contents)

  1055     if contents is not None: self.MergeFromString(contents)

  1050 

  1056 

  1051   def cursor(self): return self.cursor_

  1057   def cursor(self): return self.cursor_

  1052 

  1058 

  1053   def set_cursor(self, x):

  1059   def set_cursor(self, x):

  1143   }

  1149   }

  1144 

  1150 

  1145   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")

  1151   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")

  1146   ErrorCode_Name = classmethod(ErrorCode_Name)

  1152   ErrorCode_Name = classmethod(ErrorCode_Name)

  1147 

  1153 

  1148   def __init__(self, contents=None):

  1155   def __init__(self, contents=None):

  1149     pass

  1156     pass

  1150     if contents is not None: self.MergeFromString(contents)

  1157     if contents is not None: self.MergeFromString(contents)

  1151 

  1158 

  1152 

  1159 

  1198   )

  1205   )

  1199 

  1206 

  1200   _STYLE = """"""

  1207   _STYLE = """"""

  1201   _STYLE_CONTENT_TYPE = """"""

  1208   _STYLE_CONTENT_TYPE = """"""

  1202 class GetRequest(ProtocolBuffer.ProtocolMessage):

  1209 class GetRequest(ProtocolBuffer.ProtocolMessage):

  1203   def __init__(self, contents=None):

  1213   def __init__(self, contents=None):

  1204     self.key_ = []

  1214     self.key_ = []

  1207     self.lazy_init_lock_ = thread.allocate_lock()

  1215     self.lazy_init_lock_ = thread.allocate_lock()

  1208     if contents is not None: self.MergeFromString(contents)

  1216     if contents is not None: self.MergeFromString(contents)

  1209 

  1217 

  1210   def key_size(self): return len(self.key_)

  1218   def key_size(self): return len(self.key_)

  1211   def key_list(self): return self.key_

  1219   def key_list(self): return self.key_

  1261   def __ne__(self, other):

  1269   def __ne__(self, other):

  1262     return not (self == other)

  1270     return not (self == other)

  1263 

  1271 

  1264   def IsInitialized(self, debug_strs=None):

  1272   def IsInitialized(self, debug_strs=None):

  1265     initialized = 1

  1273     initialized = 1

  1268     if (self.has_transaction_ and not self.transaction_.IsInitialized(debug_strs)): initialized = 0

  1276     if (self.has_transaction_ and not self.transaction_.IsInitialized(debug_strs)): initialized = 0

  1269     return initialized

  1277     return initialized

  1270 

  1278 

  1271   def ByteSize(self):

  1279   def ByteSize(self):

  1272     n = 0

  1280     n = 0

  1342   )

  1350   )

  1343 

  1351 

  1344   _STYLE = """"""

  1352   _STYLE = """"""

  1345   _STYLE_CONTENT_TYPE = """"""

  1353   _STYLE_CONTENT_TYPE = """"""

  1346 class GetResponse_Entity(ProtocolBuffer.ProtocolMessage):

  1354 class GetResponse_Entity(ProtocolBuffer.ProtocolMessage):

  1347   def __init__(self, contents=None):

  1358   def __init__(self, contents=None):

  1350     self.lazy_init_lock_ = thread.allocate_lock()

  1359     self.lazy_init_lock_ = thread.allocate_lock()

  1351     if contents is not None: self.MergeFromString(contents)

  1360     if contents is not None: self.MergeFromString(contents)

  1352 

  1361 

  1353   def entity(self):

  1362   def entity(self):

  1354     if self.entity_ is None:

  1363     if self.entity_ is None:

  1424       res+=self.entity_.__str__(prefix + "  ", printElemNumber)

  1433       res+=self.entity_.__str__(prefix + "  ", printElemNumber)

  1425       res+=prefix+">\n"

  1434       res+=prefix+">\n"

  1426     return res

  1435     return res

  1427 

  1436 

  1428 class GetResponse(ProtocolBuffer.ProtocolMessage):

  1437 class GetResponse(ProtocolBuffer.ProtocolMessage):

  1429   def __init__(self, contents=None):

  1439   def __init__(self, contents=None):

  1430     self.entity_ = []

  1440     self.entity_ = []

  1431     if contents is not None: self.MergeFromString(contents)

  1441     if contents is not None: self.MergeFromString(contents)

  1432 

  1442 

  1433   def entity_size(self): return len(self.entity_)

  1443   def entity_size(self): return len(self.entity_)

  1464   def __ne__(self, other):

  1474   def __ne__(self, other):

  1465     return not (self == other)

  1475     return not (self == other)

  1466 

  1476 

  1467   def IsInitialized(self, debug_strs=None):

  1477   def IsInitialized(self, debug_strs=None):

  1468     initialized = 1

  1478     initialized = 1

  1471     return initialized

  1481     return initialized

  1472 

  1482 

  1473   def ByteSize(self):

  1483   def ByteSize(self):

  1474     n = 0

  1484     n = 0

  1475     n += 2 * len(self.entity_)

  1485     n += 2 * len(self.entity_)

  1525   )

  1535   )

  1526 

  1536 

  1527   _STYLE = """"""

  1537   _STYLE = """"""

  1528   _STYLE_CONTENT_TYPE = """"""

  1538   _STYLE_CONTENT_TYPE = """"""

  1529 class PutRequest(ProtocolBuffer.ProtocolMessage):

  1539 class PutRequest(ProtocolBuffer.ProtocolMessage):

  1530   def __init__(self, contents=None):

  1543   def __init__(self, contents=None):

  1531     self.entity_ = []

  1544     self.entity_ = []

  1533     self.composite_index_ = []

  1545     self.composite_index_ = []

  1535     self.lazy_init_lock_ = thread.allocate_lock()

  1546     self.lazy_init_lock_ = thread.allocate_lock()

  1536     if contents is not None: self.MergeFromString(contents)

  1547     if contents is not None: self.MergeFromString(contents)

  1537 

  1548 

  1538   def entity_size(self): return len(self.entity_)

  1549   def entity_size(self): return len(self.entity_)

  1539   def entity_list(self): return self.entity_

  1550   def entity_list(self): return self.entity_

  1609   def __ne__(self, other):

  1620   def __ne__(self, other):

  1610     return not (self == other)

  1621     return not (self == other)

  1611 

  1622 

  1612   def IsInitialized(self, debug_strs=None):

  1623   def IsInitialized(self, debug_strs=None):

  1613     initialized = 1

  1624     initialized = 1

  1616     if (self.has_transaction_ and not self.transaction_.IsInitialized(debug_strs)): initialized = 0

  1627     if (self.has_transaction_ and not self.transaction_.IsInitialized(debug_strs)): initialized = 0

  1619     return initialized

  1630     return initialized

  1620 

  1631 

  1621   def ByteSize(self):

  1632   def ByteSize(self):

  1622     n = 0

  1633     n = 0

  1623     n += 1 * len(self.entity_)

  1634     n += 1 * len(self.entity_)

  1717   )

  1728   )

  1718 

  1729 

  1719   _STYLE = """"""

  1730   _STYLE = """"""

  1720   _STYLE_CONTENT_TYPE = """"""

  1731   _STYLE_CONTENT_TYPE = """"""

  1721 class PutResponse(ProtocolBuffer.ProtocolMessage):

  1732 class PutResponse(ProtocolBuffer.ProtocolMessage):

  1722   def __init__(self, contents=None):

  1734   def __init__(self, contents=None):

  1723     self.key_ = []

  1735     self.key_ = []

  1724     if contents is not None: self.MergeFromString(contents)

  1736     if contents is not None: self.MergeFromString(contents)

  1725 

  1737 

  1726   def key_size(self): return len(self.key_)

  1738   def key_size(self): return len(self.key_)

  1757   def __ne__(self, other):

  1769   def __ne__(self, other):

  1758     return not (self == other)

  1770     return not (self == other)

  1759 

  1771 

  1760   def IsInitialized(self, debug_strs=None):

  1772   def IsInitialized(self, debug_strs=None):

  1761     initialized = 1

  1773     initialized = 1

  1764     return initialized

  1776     return initialized

  1765 

  1777 

  1766   def ByteSize(self):

  1778   def ByteSize(self):

  1767     n = 0

  1779     n = 0

  1768     n += 1 * len(self.key_)

  1780     n += 1 * len(self.key_)

  1817   )

  1829   )

  1818 

  1830 

  1819   _STYLE = """"""

  1831   _STYLE = """"""

  1820   _STYLE_CONTENT_TYPE = """"""

  1832   _STYLE_CONTENT_TYPE = """"""

  1821 class DeleteRequest(ProtocolBuffer.ProtocolMessage):

  1833 class DeleteRequest(ProtocolBuffer.ProtocolMessage):

  1822   def __init__(self, contents=None):

  1837   def __init__(self, contents=None):

  1823     self.key_ = []

  1838     self.key_ = []

  1826     self.lazy_init_lock_ = thread.allocate_lock()

  1839     self.lazy_init_lock_ = thread.allocate_lock()

  1827     if contents is not None: self.MergeFromString(contents)

  1840     if contents is not None: self.MergeFromString(contents)

  1828 

  1841 

  1829   def key_size(self): return len(self.key_)

  1842   def key_size(self): return len(self.key_)

  1830   def key_list(self): return self.key_

  1843   def key_list(self): return self.key_

  1880   def __ne__(self, other):

  1893   def __ne__(self, other):

  1881     return not (self == other)

  1894     return not (self == other)

  1882 

  1895 

  1883   def IsInitialized(self, debug_strs=None):

  1896   def IsInitialized(self, debug_strs=None):

  1884     initialized = 1

  1897     initialized = 1

  1887     if (self.has_transaction_ and not self.transaction_.IsInitialized(debug_strs)): initialized = 0

  1900     if (self.has_transaction_ and not self.transaction_.IsInitialized(debug_strs)): initialized = 0

  1888     return initialized

  1901     return initialized

  1889 

  1902 

  1890   def ByteSize(self):

  1903   def ByteSize(self):

  1891     n = 0

  1904     n = 0

  1973   )

  1986   )

  1974 

  1987 

  1975   _STYLE = """"""

  1988   _STYLE = """"""

  1976   _STYLE_CONTENT_TYPE = """"""

  1989   _STYLE_CONTENT_TYPE = """"""

  1977 class NextRequest(ProtocolBuffer.ProtocolMessage):

  1990 class NextRequest(ProtocolBuffer.ProtocolMessage):

  1978   def __init__(self, contents=None):

  1995   def __init__(self, contents=None):

  1979     self.cursor_ = Cursor()

  1996     self.cursor_ = Cursor()

  1983     if contents is not None: self.MergeFromString(contents)

  1997     if contents is not None: self.MergeFromString(contents)

  1984 

  1998 

  1985   def cursor(self): return self.cursor_

  1999   def cursor(self): return self.cursor_

  1986 

  2000 

  1987   def mutable_cursor(self): self.has_cursor_ = 1; return self.cursor_

  2001   def mutable_cursor(self): self.has_cursor_ = 1; return self.cursor_

  2092   )

  2106   )

  2093 

  2107 

  2094   _STYLE = """"""

  2108   _STYLE = """"""

  2095   _STYLE_CONTENT_TYPE = """"""

  2109   _STYLE_CONTENT_TYPE = """"""

  2096 class QueryResult(ProtocolBuffer.ProtocolMessage):

  2110 class QueryResult(ProtocolBuffer.ProtocolMessage):

  2097   def __init__(self, contents=None):

  2116   def __init__(self, contents=None):

  2099     self.result_ = []

  2117     self.result_ = []

  2103     self.lazy_init_lock_ = thread.allocate_lock()

  2118     self.lazy_init_lock_ = thread.allocate_lock()

  2104     if contents is not None: self.MergeFromString(contents)

  2119     if contents is not None: self.MergeFromString(contents)

  2105 

  2120 

  2106   def cursor(self):

  2121   def cursor(self):

  2107     if self.cursor_ is None:

  2122     if self.cursor_ is None:

  2173     return not (self == other)

  2188     return not (self == other)

  2174 

  2189 

  2175   def IsInitialized(self, debug_strs=None):

  2190   def IsInitialized(self, debug_strs=None):

  2176     initialized = 1

  2191     initialized = 1

  2177     if (self.has_cursor_ and not self.cursor_.IsInitialized(debug_strs)): initialized = 0

  2192     if (self.has_cursor_ and not self.cursor_.IsInitialized(debug_strs)): initialized = 0

  2180     if (not self.has_more_results_):

  2195     if (not self.has_more_results_):

  2181       initialized = 0

  2196       initialized = 0

  2182       if debug_strs is not None:

  2197       if debug_strs is not None:

  2183         debug_strs.append('Required field: more_results not set.')

  2198         debug_strs.append('Required field: more_results not set.')

  2184     return initialized

  2199     return initialized

  2268   )

  2283   )

  2269 

  2284 

  2270   _STYLE = """"""

  2285   _STYLE = """"""

  2271   _STYLE_CONTENT_TYPE = """"""

  2286   _STYLE_CONTENT_TYPE = """"""

  2272 class Schema(ProtocolBuffer.ProtocolMessage):

  2287 class Schema(ProtocolBuffer.ProtocolMessage):

  2273   def __init__(self, contents=None):

  2289   def __init__(self, contents=None):

  2274     self.kind_ = []

  2290     self.kind_ = []

  2275     if contents is not None: self.MergeFromString(contents)

  2291     if contents is not None: self.MergeFromString(contents)

  2276 

  2292 

  2277   def kind_size(self): return len(self.kind_)

  2293   def kind_size(self): return len(self.kind_)

  2308   def __ne__(self, other):

  2324   def __ne__(self, other):

  2309     return not (self == other)

  2325     return not (self == other)

  2310 

  2326 

  2311   def IsInitialized(self, debug_strs=None):

  2327   def IsInitialized(self, debug_strs=None):

  2312     initialized = 1

  2328     initialized = 1

  2315     return initialized

  2331     return initialized

  2316 

  2332 

  2317   def ByteSize(self):

  2333   def ByteSize(self):

  2318     n = 0

  2334     n = 0

  2319     n += 1 * len(self.kind_)

  2335     n += 1 * len(self.kind_)

  2368   )

  2384   )

  2369 

  2385 

  2370   _STYLE = """"""

  2386   _STYLE = """"""

  2371   _STYLE_CONTENT_TYPE = """"""

  2387   _STYLE_CONTENT_TYPE = """"""

  2372 class CompositeIndices(ProtocolBuffer.ProtocolMessage):

  2388 class CompositeIndices(ProtocolBuffer.ProtocolMessage):

  2373   def __init__(self, contents=None):

  2390   def __init__(self, contents=None):

  2374     self.index_ = []

  2391     self.index_ = []

  2375     if contents is not None: self.MergeFromString(contents)

  2392     if contents is not None: self.MergeFromString(contents)

  2376 

  2393 

  2377   def index_size(self): return len(self.index_)

  2394   def index_size(self): return len(self.index_)

  2408   def __ne__(self, other):

  2425   def __ne__(self, other):

  2409     return not (self == other)

  2426     return not (self == other)

  2410 

  2427 

  2411   def IsInitialized(self, debug_strs=None):

  2428   def IsInitialized(self, debug_strs=None):

  2412     initialized = 1

  2429     initialized = 1

  2415     return initialized

  2432     return initialized

  2416 

  2433 

  2417   def ByteSize(self):

  2434   def ByteSize(self):

  2418     n = 0

  2435     n = 0

  2419     n += 1 * len(self.index_)

  2436     n += 1 * len(self.index_)