python/google/appengine/datastore/datastore_v4_pb.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2007 Google Inc.
   4 #
   5 # Licensed under the Apache License, Version 2.0 (the "License");
   6 # you may not use this file except in compliance with the License.
   7 # You may obtain a copy of the License at
   8 #
   9 #     http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 # Unless required by applicable law or agreed to in writing, software
  12 # distributed under the License is distributed on an "AS IS" BASIS,
  13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #
  17
  18
  19
  20 from google.net.proto import ProtocolBuffer
  21 import array
  22 import base64
  23 import dummy_thread as thread
  24 try:
  25   from google3.net.proto import _net_proto___parse__python
  26 except ImportError:
  27   _net_proto___parse__python = None
  28 import sys
  29 try:
  30   __import__('google.net.rpc.python.rpc_internals_lite')
  31   __import__('google.net.rpc.python.pywraprpc_lite')
  32   rpc_internals = sys.modules.get('google.net.rpc.python.rpc_internals_lite')
  33   pywraprpc = sys.modules.get('google.net.rpc.python.pywraprpc_lite')
  34   _client_stub_base_class = rpc_internals.StubbyRPCBaseStub
  35 except ImportError:
  36   _client_stub_base_class = object
  37 try:
  38   __import__('google.net.rpc.python.rpcserver')
  39   rpcserver = sys.modules.get('google.net.rpc.python.rpcserver')
  40   _server_stub_base_class = rpcserver.BaseRpcServer
  41 except ImportError:
  42   _server_stub_base_class = object
  43
  44 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  45                    unusednames=printElemNumber,debug_strs no-special"""
  46
  47 if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'):
  48   _extension_runtime = True
  49   _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
  50 else:
  51   _extension_runtime = False
  52   _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
  53
  54 from google.appengine.datastore.entity_v4_pb import *
  55 import google.appengine.datastore.entity_v4_pb
  56 class Error(ProtocolBuffer.ProtocolMessage):
  57
  58
  59   BAD_REQUEST  =    1
  60   CONCURRENT_TRANSACTION =    2
  61   INTERNAL_ERROR =    3
  62   NEED_INDEX   =    4
  63   TIMEOUT      =    5
  64   PERMISSION_DENIED =    6
  65   BIGTABLE_ERROR =    7
  66   COMMITTED_BUT_STILL_APPLYING =    8
  67   CAPABILITY_DISABLED =    9
  68   TRY_ALTERNATE_BACKEND =   10
  69   SAFE_TIME_TOO_OLD =   11
  70
  71   _ErrorCode_NAMES = {
  72     1: "BAD_REQUEST",
  73     2: "CONCURRENT_TRANSACTION",
  74     3: "INTERNAL_ERROR",
  75     4: "NEED_INDEX",
  76     5: "TIMEOUT",
  77     6: "PERMISSION_DENIED",
  78     7: "BIGTABLE_ERROR",
  79     8: "COMMITTED_BUT_STILL_APPLYING",
  80     9: "CAPABILITY_DISABLED",
  81     10: "TRY_ALTERNATE_BACKEND",
  82     11: "SAFE_TIME_TOO_OLD",
  83   }
  84
  85   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  86   ErrorCode_Name = classmethod(ErrorCode_Name)
  87
  88
  89   def __init__(self, contents=None):
  90     pass
  91     if contents is not None: self.MergeFromString(contents)
  92
  93
  94   def MergeFrom(self, x):
  95     assert x is not self
  96
  97   if _net_proto___parse__python is not None:
  98     def _CMergeFromString(self, s):
  99       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Error', s)
 100
 101   if _net_proto___parse__python is not None:
 102     def _CEncode(self):
 103       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Error')
 104
 105   if _net_proto___parse__python is not None:
 106     def _CEncodePartial(self):
 107       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Error')
 108
 109   if _net_proto___parse__python is not None:
 110     def _CToASCII(self, output_format):
 111       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Error', output_format)
 112
 113
 114   if _net_proto___parse__python is not None:
 115     def ParseASCII(self, s):
 116       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Error', s)
 117
 118
 119   if _net_proto___parse__python is not None:
 120     def ParseASCIIIgnoreUnknown(self, s):
 121       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Error', s)
 122
 123
 124   def Equals(self, x):
 125     if x is self: return 1
 126     return 1
 127
 128   def IsInitialized(self, debug_strs=None):
 129     initialized = 1
 130     return initialized
 131
 132   def ByteSize(self):
 133     n = 0
 134     return n
 135
 136   def ByteSizePartial(self):
 137     n = 0
 138     return n
 139
 140   def Clear(self):
 141     pass
 142
 143   def OutputUnchecked(self, out):
 144     pass
 145
 146   def OutputPartial(self, out):
 147     pass
 148
 149   def TryMerge(self, d):
 150     while d.avail() > 0:
 151       tt = d.getVarInt32()
 152
 153
 154       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 155       d.skipData(tt)
 156
 157
 158   def __str__(self, prefix="", printElemNumber=0):
 159     res=""
 160     return res
 161
 162
 163   def _BuildTagLookupTable(sparse, maxtag, default=None):
 164     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 165
 166
 167   _TEXT = _BuildTagLookupTable({
 168     0: "ErrorCode",
 169   }, 0)
 170
 171   _TYPES = _BuildTagLookupTable({
 172     0: ProtocolBuffer.Encoder.NUMERIC,
 173   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
 174
 175
 176   _STYLE = """"""
 177   _STYLE_CONTENT_TYPE = """"""
 178   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Error'
 179   _SERIALIZED_DESCRIPTOR = array.array('B')
 180   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("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"))
 181   if _net_proto___parse__python is not None:
 182     _net_proto___parse__python.RegisterType(
 183         _SERIALIZED_DESCRIPTOR.tostring())
 184
 185 class EntityResult(ProtocolBuffer.ProtocolMessage):
 186
 187
 188   FULL         =    1
 189   PROJECTION   =    2
 190   KEY_ONLY     =    3
 191
 192   _ResultType_NAMES = {
 193     1: "FULL",
 194     2: "PROJECTION",
 195     3: "KEY_ONLY",
 196   }
 197
 198   def ResultType_Name(cls, x): return cls._ResultType_NAMES.get(x, "")
 199   ResultType_Name = classmethod(ResultType_Name)
 200
 201   has_entity_ = 0
 202   has_version_ = 0
 203   version_ = 0
 204
 205   def __init__(self, contents=None):
 206     self.entity_ = google.appengine.datastore.entity_v4_pb.Entity()
 207     if contents is not None: self.MergeFromString(contents)
 208
 209   def entity(self): return self.entity_
 210
 211   def mutable_entity(self): self.has_entity_ = 1; return self.entity_
 212
 213   def clear_entity(self):self.has_entity_ = 0; self.entity_.Clear()
 214
 215   def has_entity(self): return self.has_entity_
 216
 217   def version(self): return self.version_
 218
 219   def set_version(self, x):
 220     self.has_version_ = 1
 221     self.version_ = x
 222
 223   def clear_version(self):
 224     if self.has_version_:
 225       self.has_version_ = 0
 226       self.version_ = 0
 227
 228   def has_version(self): return self.has_version_
 229
 230
 231   def MergeFrom(self, x):
 232     assert x is not self
 233     if (x.has_entity()): self.mutable_entity().MergeFrom(x.entity())
 234     if (x.has_version()): self.set_version(x.version())
 235
 236   if _net_proto___parse__python is not None:
 237     def _CMergeFromString(self, s):
 238       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.EntityResult', s)
 239
 240   if _net_proto___parse__python is not None:
 241     def _CEncode(self):
 242       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.EntityResult')
 243
 244   if _net_proto___parse__python is not None:
 245     def _CEncodePartial(self):
 246       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.EntityResult')
 247
 248   if _net_proto___parse__python is not None:
 249     def _CToASCII(self, output_format):
 250       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.EntityResult', output_format)
 251
 252
 253   if _net_proto___parse__python is not None:
 254     def ParseASCII(self, s):
 255       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.EntityResult', s)
 256
 257
 258   if _net_proto___parse__python is not None:
 259     def ParseASCIIIgnoreUnknown(self, s):
 260       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.EntityResult', s)
 261
 262
 263   def Equals(self, x):
 264     if x is self: return 1
 265     if self.has_entity_ != x.has_entity_: return 0
 266     if self.has_entity_ and self.entity_ != x.entity_: return 0
 267     if self.has_version_ != x.has_version_: return 0
 268     if self.has_version_ and self.version_ != x.version_: return 0
 269     return 1
 270
 271   def IsInitialized(self, debug_strs=None):
 272     initialized = 1
 273     if (not self.has_entity_):
 274       initialized = 0
 275       if debug_strs is not None:
 276         debug_strs.append('Required field: entity not set.')
 277     elif not self.entity_.IsInitialized(debug_strs): initialized = 0
 278     return initialized
 279
 280   def ByteSize(self):
 281     n = 0
 282     n += self.lengthString(self.entity_.ByteSize())
 283     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
 284     return n + 1
 285
 286   def ByteSizePartial(self):
 287     n = 0
 288     if (self.has_entity_):
 289       n += 1
 290       n += self.lengthString(self.entity_.ByteSizePartial())
 291     if (self.has_version_): n += 1 + self.lengthVarInt64(self.version_)
 292     return n
 293
 294   def Clear(self):
 295     self.clear_entity()
 296     self.clear_version()
 297
 298   def OutputUnchecked(self, out):
 299     out.putVarInt32(10)
 300     out.putVarInt32(self.entity_.ByteSize())
 301     self.entity_.OutputUnchecked(out)
 302     if (self.has_version_):
 303       out.putVarInt32(16)
 304       out.putVarInt64(self.version_)
 305
 306   def OutputPartial(self, out):
 307     if (self.has_entity_):
 308       out.putVarInt32(10)
 309       out.putVarInt32(self.entity_.ByteSizePartial())
 310       self.entity_.OutputPartial(out)
 311     if (self.has_version_):
 312       out.putVarInt32(16)
 313       out.putVarInt64(self.version_)
 314
 315   def TryMerge(self, d):
 316     while d.avail() > 0:
 317       tt = d.getVarInt32()
 318       if tt == 10:
 319         length = d.getVarInt32()
 320         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 321         d.skip(length)
 322         self.mutable_entity().TryMerge(tmp)
 323         continue
 324       if tt == 16:
 325         self.set_version(d.getVarInt64())
 326         continue
 327
 328
 329       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 330       d.skipData(tt)
 331
 332
 333   def __str__(self, prefix="", printElemNumber=0):
 334     res=""
 335     if self.has_entity_:
 336       res+=prefix+"entity <\n"
 337       res+=self.entity_.__str__(prefix + "  ", printElemNumber)
 338       res+=prefix+">\n"
 339     if self.has_version_: res+=prefix+("version: %s\n" % self.DebugFormatInt64(self.version_))
 340     return res
 341
 342
 343   def _BuildTagLookupTable(sparse, maxtag, default=None):
 344     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 345
 346   kentity = 1
 347   kversion = 2
 348
 349   _TEXT = _BuildTagLookupTable({
 350     0: "ErrorCode",
 351     1: "entity",
 352     2: "version",
 353   }, 2)
 354
 355   _TYPES = _BuildTagLookupTable({
 356     0: ProtocolBuffer.Encoder.NUMERIC,
 357     1: ProtocolBuffer.Encoder.STRING,
 358     2: ProtocolBuffer.Encoder.NUMERIC,
 359   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 360
 361
 362   _STYLE = """"""
 363   _STYLE_CONTENT_TYPE = """"""
 364   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.EntityResult'
 365   _SERIALIZED_DESCRIPTOR = array.array('B')
 366   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVudGl0eVJlc3VsdBMaBmVudGl0eSABKAIwCzgCSh5hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FbnRpdHmjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoHdmVyc2lvbiACKAAwAzgBFHN6ClJlc3VsdFR5cGWLAZIBBEZVTEyYAQGMAYsBkgEKUFJPSkVDVElPTpgBAowBiwGSAQhLRVlfT05MWZgBA4wBdMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
 367   if _net_proto___parse__python is not None:
 368     _net_proto___parse__python.RegisterType(
 369         _SERIALIZED_DESCRIPTOR.tostring())
 370
 371 class Query(ProtocolBuffer.ProtocolMessage):
 372   has_filter_ = 0
 373   filter_ = None
 374   has_start_cursor_ = 0
 375   start_cursor_ = ""
 376   has_end_cursor_ = 0
 377   end_cursor_ = ""
 378   has_offset_ = 0
 379   offset_ = 0
 380   has_limit_ = 0
 381   limit_ = 0
 382
 383   def __init__(self, contents=None):
 384     self.projection_ = []
 385     self.kind_ = []
 386     self.order_ = []
 387     self.group_by_ = []
 388     self.lazy_init_lock_ = thread.allocate_lock()
 389     if contents is not None: self.MergeFromString(contents)
 390
 391   def projection_size(self): return len(self.projection_)
 392   def projection_list(self): return self.projection_
 393
 394   def projection(self, i):
 395     return self.projection_[i]
 396
 397   def mutable_projection(self, i):
 398     return self.projection_[i]
 399
 400   def add_projection(self):
 401     x = PropertyExpression()
 402     self.projection_.append(x)
 403     return x
 404
 405   def clear_projection(self):
 406     self.projection_ = []
 407   def kind_size(self): return len(self.kind_)
 408   def kind_list(self): return self.kind_
 409
 410   def kind(self, i):
 411     return self.kind_[i]
 412
 413   def mutable_kind(self, i):
 414     return self.kind_[i]
 415
 416   def add_kind(self):
 417     x = KindExpression()
 418     self.kind_.append(x)
 419     return x
 420
 421   def clear_kind(self):
 422     self.kind_ = []
 423   def filter(self):
 424     if self.filter_ is None:
 425       self.lazy_init_lock_.acquire()
 426       try:
 427         if self.filter_ is None: self.filter_ = Filter()
 428       finally:
 429         self.lazy_init_lock_.release()
 430     return self.filter_
 431
 432   def mutable_filter(self): self.has_filter_ = 1; return self.filter()
 433
 434   def clear_filter(self):
 435
 436     if self.has_filter_:
 437       self.has_filter_ = 0;
 438       if self.filter_ is not None: self.filter_.Clear()
 439
 440   def has_filter(self): return self.has_filter_
 441
 442   def order_size(self): return len(self.order_)
 443   def order_list(self): return self.order_
 444
 445   def order(self, i):
 446     return self.order_[i]
 447
 448   def mutable_order(self, i):
 449     return self.order_[i]
 450
 451   def add_order(self):
 452     x = PropertyOrder()
 453     self.order_.append(x)
 454     return x
 455
 456   def clear_order(self):
 457     self.order_ = []
 458   def group_by_size(self): return len(self.group_by_)
 459   def group_by_list(self): return self.group_by_
 460
 461   def group_by(self, i):
 462     return self.group_by_[i]
 463
 464   def mutable_group_by(self, i):
 465     return self.group_by_[i]
 466
 467   def add_group_by(self):
 468     x = PropertyReference()
 469     self.group_by_.append(x)
 470     return x
 471
 472   def clear_group_by(self):
 473     self.group_by_ = []
 474   def start_cursor(self): return self.start_cursor_
 475
 476   def set_start_cursor(self, x):
 477     self.has_start_cursor_ = 1
 478     self.start_cursor_ = x
 479
 480   def clear_start_cursor(self):
 481     if self.has_start_cursor_:
 482       self.has_start_cursor_ = 0
 483       self.start_cursor_ = ""
 484
 485   def has_start_cursor(self): return self.has_start_cursor_
 486
 487   def end_cursor(self): return self.end_cursor_
 488
 489   def set_end_cursor(self, x):
 490     self.has_end_cursor_ = 1
 491     self.end_cursor_ = x
 492
 493   def clear_end_cursor(self):
 494     if self.has_end_cursor_:
 495       self.has_end_cursor_ = 0
 496       self.end_cursor_ = ""
 497
 498   def has_end_cursor(self): return self.has_end_cursor_
 499
 500   def offset(self): return self.offset_
 501
 502   def set_offset(self, x):
 503     self.has_offset_ = 1
 504     self.offset_ = x
 505
 506   def clear_offset(self):
 507     if self.has_offset_:
 508       self.has_offset_ = 0
 509       self.offset_ = 0
 510
 511   def has_offset(self): return self.has_offset_
 512
 513   def limit(self): return self.limit_
 514
 515   def set_limit(self, x):
 516     self.has_limit_ = 1
 517     self.limit_ = x
 518
 519   def clear_limit(self):
 520     if self.has_limit_:
 521       self.has_limit_ = 0
 522       self.limit_ = 0
 523
 524   def has_limit(self): return self.has_limit_
 525
 526
 527   def MergeFrom(self, x):
 528     assert x is not self
 529     for i in xrange(x.projection_size()): self.add_projection().CopyFrom(x.projection(i))
 530     for i in xrange(x.kind_size()): self.add_kind().CopyFrom(x.kind(i))
 531     if (x.has_filter()): self.mutable_filter().MergeFrom(x.filter())
 532     for i in xrange(x.order_size()): self.add_order().CopyFrom(x.order(i))
 533     for i in xrange(x.group_by_size()): self.add_group_by().CopyFrom(x.group_by(i))
 534     if (x.has_start_cursor()): self.set_start_cursor(x.start_cursor())
 535     if (x.has_end_cursor()): self.set_end_cursor(x.end_cursor())
 536     if (x.has_offset()): self.set_offset(x.offset())
 537     if (x.has_limit()): self.set_limit(x.limit())
 538
 539   if _net_proto___parse__python is not None:
 540     def _CMergeFromString(self, s):
 541       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Query', s)
 542
 543   if _net_proto___parse__python is not None:
 544     def _CEncode(self):
 545       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Query')
 546
 547   if _net_proto___parse__python is not None:
 548     def _CEncodePartial(self):
 549       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Query')
 550
 551   if _net_proto___parse__python is not None:
 552     def _CToASCII(self, output_format):
 553       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Query', output_format)
 554
 555
 556   if _net_proto___parse__python is not None:
 557     def ParseASCII(self, s):
 558       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Query', s)
 559
 560
 561   if _net_proto___parse__python is not None:
 562     def ParseASCIIIgnoreUnknown(self, s):
 563       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Query', s)
 564
 565
 566   def Equals(self, x):
 567     if x is self: return 1
 568     if len(self.projection_) != len(x.projection_): return 0
 569     for e1, e2 in zip(self.projection_, x.projection_):
 570       if e1 != e2: return 0
 571     if len(self.kind_) != len(x.kind_): return 0
 572     for e1, e2 in zip(self.kind_, x.kind_):
 573       if e1 != e2: return 0
 574     if self.has_filter_ != x.has_filter_: return 0
 575     if self.has_filter_ and self.filter_ != x.filter_: return 0
 576     if len(self.order_) != len(x.order_): return 0
 577     for e1, e2 in zip(self.order_, x.order_):
 578       if e1 != e2: return 0
 579     if len(self.group_by_) != len(x.group_by_): return 0
 580     for e1, e2 in zip(self.group_by_, x.group_by_):
 581       if e1 != e2: return 0
 582     if self.has_start_cursor_ != x.has_start_cursor_: return 0
 583     if self.has_start_cursor_ and self.start_cursor_ != x.start_cursor_: return 0
 584     if self.has_end_cursor_ != x.has_end_cursor_: return 0
 585     if self.has_end_cursor_ and self.end_cursor_ != x.end_cursor_: return 0
 586     if self.has_offset_ != x.has_offset_: return 0
 587     if self.has_offset_ and self.offset_ != x.offset_: return 0
 588     if self.has_limit_ != x.has_limit_: return 0
 589     if self.has_limit_ and self.limit_ != x.limit_: return 0
 590     return 1
 591
 592   def IsInitialized(self, debug_strs=None):
 593     initialized = 1
 594     for p in self.projection_:
 595       if not p.IsInitialized(debug_strs): initialized=0
 596     for p in self.kind_:
 597       if not p.IsInitialized(debug_strs): initialized=0
 598     if (self.has_filter_ and not self.filter_.IsInitialized(debug_strs)): initialized = 0
 599     for p in self.order_:
 600       if not p.IsInitialized(debug_strs): initialized=0
 601     for p in self.group_by_:
 602       if not p.IsInitialized(debug_strs): initialized=0
 603     return initialized
 604
 605   def ByteSize(self):
 606     n = 0
 607     n += 1 * len(self.projection_)
 608     for i in xrange(len(self.projection_)): n += self.lengthString(self.projection_[i].ByteSize())
 609     n += 1 * len(self.kind_)
 610     for i in xrange(len(self.kind_)): n += self.lengthString(self.kind_[i].ByteSize())
 611     if (self.has_filter_): n += 1 + self.lengthString(self.filter_.ByteSize())
 612     n += 1 * len(self.order_)
 613     for i in xrange(len(self.order_)): n += self.lengthString(self.order_[i].ByteSize())
 614     n += 1 * len(self.group_by_)
 615     for i in xrange(len(self.group_by_)): n += self.lengthString(self.group_by_[i].ByteSize())
 616     if (self.has_start_cursor_): n += 1 + self.lengthString(len(self.start_cursor_))
 617     if (self.has_end_cursor_): n += 1 + self.lengthString(len(self.end_cursor_))
 618     if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
 619     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
 620     return n
 621
 622   def ByteSizePartial(self):
 623     n = 0
 624     n += 1 * len(self.projection_)
 625     for i in xrange(len(self.projection_)): n += self.lengthString(self.projection_[i].ByteSizePartial())
 626     n += 1 * len(self.kind_)
 627     for i in xrange(len(self.kind_)): n += self.lengthString(self.kind_[i].ByteSizePartial())
 628     if (self.has_filter_): n += 1 + self.lengthString(self.filter_.ByteSizePartial())
 629     n += 1 * len(self.order_)
 630     for i in xrange(len(self.order_)): n += self.lengthString(self.order_[i].ByteSizePartial())
 631     n += 1 * len(self.group_by_)
 632     for i in xrange(len(self.group_by_)): n += self.lengthString(self.group_by_[i].ByteSizePartial())
 633     if (self.has_start_cursor_): n += 1 + self.lengthString(len(self.start_cursor_))
 634     if (self.has_end_cursor_): n += 1 + self.lengthString(len(self.end_cursor_))
 635     if (self.has_offset_): n += 1 + self.lengthVarInt64(self.offset_)
 636     if (self.has_limit_): n += 1 + self.lengthVarInt64(self.limit_)
 637     return n
 638
 639   def Clear(self):
 640     self.clear_projection()
 641     self.clear_kind()
 642     self.clear_filter()
 643     self.clear_order()
 644     self.clear_group_by()
 645     self.clear_start_cursor()
 646     self.clear_end_cursor()
 647     self.clear_offset()
 648     self.clear_limit()
 649
 650   def OutputUnchecked(self, out):
 651     for i in xrange(len(self.projection_)):
 652       out.putVarInt32(18)
 653       out.putVarInt32(self.projection_[i].ByteSize())
 654       self.projection_[i].OutputUnchecked(out)
 655     for i in xrange(len(self.kind_)):
 656       out.putVarInt32(26)
 657       out.putVarInt32(self.kind_[i].ByteSize())
 658       self.kind_[i].OutputUnchecked(out)
 659     if (self.has_filter_):
 660       out.putVarInt32(34)
 661       out.putVarInt32(self.filter_.ByteSize())
 662       self.filter_.OutputUnchecked(out)
 663     for i in xrange(len(self.order_)):
 664       out.putVarInt32(42)
 665       out.putVarInt32(self.order_[i].ByteSize())
 666       self.order_[i].OutputUnchecked(out)
 667     for i in xrange(len(self.group_by_)):
 668       out.putVarInt32(50)
 669       out.putVarInt32(self.group_by_[i].ByteSize())
 670       self.group_by_[i].OutputUnchecked(out)
 671     if (self.has_start_cursor_):
 672       out.putVarInt32(58)
 673       out.putPrefixedString(self.start_cursor_)
 674     if (self.has_end_cursor_):
 675       out.putVarInt32(66)
 676       out.putPrefixedString(self.end_cursor_)
 677     if (self.has_offset_):
 678       out.putVarInt32(80)
 679       out.putVarInt32(self.offset_)
 680     if (self.has_limit_):
 681       out.putVarInt32(88)
 682       out.putVarInt32(self.limit_)
 683
 684   def OutputPartial(self, out):
 685     for i in xrange(len(self.projection_)):
 686       out.putVarInt32(18)
 687       out.putVarInt32(self.projection_[i].ByteSizePartial())
 688       self.projection_[i].OutputPartial(out)
 689     for i in xrange(len(self.kind_)):
 690       out.putVarInt32(26)
 691       out.putVarInt32(self.kind_[i].ByteSizePartial())
 692       self.kind_[i].OutputPartial(out)
 693     if (self.has_filter_):
 694       out.putVarInt32(34)
 695       out.putVarInt32(self.filter_.ByteSizePartial())
 696       self.filter_.OutputPartial(out)
 697     for i in xrange(len(self.order_)):
 698       out.putVarInt32(42)
 699       out.putVarInt32(self.order_[i].ByteSizePartial())
 700       self.order_[i].OutputPartial(out)
 701     for i in xrange(len(self.group_by_)):
 702       out.putVarInt32(50)
 703       out.putVarInt32(self.group_by_[i].ByteSizePartial())
 704       self.group_by_[i].OutputPartial(out)
 705     if (self.has_start_cursor_):
 706       out.putVarInt32(58)
 707       out.putPrefixedString(self.start_cursor_)
 708     if (self.has_end_cursor_):
 709       out.putVarInt32(66)
 710       out.putPrefixedString(self.end_cursor_)
 711     if (self.has_offset_):
 712       out.putVarInt32(80)
 713       out.putVarInt32(self.offset_)
 714     if (self.has_limit_):
 715       out.putVarInt32(88)
 716       out.putVarInt32(self.limit_)
 717
 718   def TryMerge(self, d):
 719     while d.avail() > 0:
 720       tt = d.getVarInt32()
 721       if tt == 18:
 722         length = d.getVarInt32()
 723         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 724         d.skip(length)
 725         self.add_projection().TryMerge(tmp)
 726         continue
 727       if tt == 26:
 728         length = d.getVarInt32()
 729         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 730         d.skip(length)
 731         self.add_kind().TryMerge(tmp)
 732         continue
 733       if tt == 34:
 734         length = d.getVarInt32()
 735         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 736         d.skip(length)
 737         self.mutable_filter().TryMerge(tmp)
 738         continue
 739       if tt == 42:
 740         length = d.getVarInt32()
 741         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 742         d.skip(length)
 743         self.add_order().TryMerge(tmp)
 744         continue
 745       if tt == 50:
 746         length = d.getVarInt32()
 747         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 748         d.skip(length)
 749         self.add_group_by().TryMerge(tmp)
 750         continue
 751       if tt == 58:
 752         self.set_start_cursor(d.getPrefixedString())
 753         continue
 754       if tt == 66:
 755         self.set_end_cursor(d.getPrefixedString())
 756         continue
 757       if tt == 80:
 758         self.set_offset(d.getVarInt32())
 759         continue
 760       if tt == 88:
 761         self.set_limit(d.getVarInt32())
 762         continue
 763
 764
 765       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 766       d.skipData(tt)
 767
 768
 769   def __str__(self, prefix="", printElemNumber=0):
 770     res=""
 771     cnt=0
 772     for e in self.projection_:
 773       elm=""
 774       if printElemNumber: elm="(%d)" % cnt
 775       res+=prefix+("projection%s <\n" % elm)
 776       res+=e.__str__(prefix + "  ", printElemNumber)
 777       res+=prefix+">\n"
 778       cnt+=1
 779     cnt=0
 780     for e in self.kind_:
 781       elm=""
 782       if printElemNumber: elm="(%d)" % cnt
 783       res+=prefix+("kind%s <\n" % elm)
 784       res+=e.__str__(prefix + "  ", printElemNumber)
 785       res+=prefix+">\n"
 786       cnt+=1
 787     if self.has_filter_:
 788       res+=prefix+"filter <\n"
 789       res+=self.filter_.__str__(prefix + "  ", printElemNumber)
 790       res+=prefix+">\n"
 791     cnt=0
 792     for e in self.order_:
 793       elm=""
 794       if printElemNumber: elm="(%d)" % cnt
 795       res+=prefix+("order%s <\n" % elm)
 796       res+=e.__str__(prefix + "  ", printElemNumber)
 797       res+=prefix+">\n"
 798       cnt+=1
 799     cnt=0
 800     for e in self.group_by_:
 801       elm=""
 802       if printElemNumber: elm="(%d)" % cnt
 803       res+=prefix+("group_by%s <\n" % elm)
 804       res+=e.__str__(prefix + "  ", printElemNumber)
 805       res+=prefix+">\n"
 806       cnt+=1
 807     if self.has_start_cursor_: res+=prefix+("start_cursor: %s\n" % self.DebugFormatString(self.start_cursor_))
 808     if self.has_end_cursor_: res+=prefix+("end_cursor: %s\n" % self.DebugFormatString(self.end_cursor_))
 809     if self.has_offset_: res+=prefix+("offset: %s\n" % self.DebugFormatInt32(self.offset_))
 810     if self.has_limit_: res+=prefix+("limit: %s\n" % self.DebugFormatInt32(self.limit_))
 811     return res
 812
 813
 814   def _BuildTagLookupTable(sparse, maxtag, default=None):
 815     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 816
 817   kprojection = 2
 818   kkind = 3
 819   kfilter = 4
 820   korder = 5
 821   kgroup_by = 6
 822   kstart_cursor = 7
 823   kend_cursor = 8
 824   koffset = 10
 825   klimit = 11
 826
 827   _TEXT = _BuildTagLookupTable({
 828     0: "ErrorCode",
 829     2: "projection",
 830     3: "kind",
 831     4: "filter",
 832     5: "order",
 833     6: "group_by",
 834     7: "start_cursor",
 835     8: "end_cursor",
 836     10: "offset",
 837     11: "limit",
 838   }, 11)
 839
 840   _TYPES = _BuildTagLookupTable({
 841     0: ProtocolBuffer.Encoder.NUMERIC,
 842     2: ProtocolBuffer.Encoder.STRING,
 843     3: ProtocolBuffer.Encoder.STRING,
 844     4: ProtocolBuffer.Encoder.STRING,
 845     5: ProtocolBuffer.Encoder.STRING,
 846     6: ProtocolBuffer.Encoder.STRING,
 847     7: ProtocolBuffer.Encoder.STRING,
 848     8: ProtocolBuffer.Encoder.STRING,
 849     10: ProtocolBuffer.Encoder.NUMERIC,
 850     11: ProtocolBuffer.Encoder.NUMERIC,
 851   }, 11, ProtocolBuffer.Encoder.MAX_TYPE)
 852
 853
 854   _STYLE = """"""
 855   _STYLE_CONTENT_TYPE = """"""
 856   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Query'
 857   _SERIALIZED_DESCRIPTOR = array.array('B')
 858   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlF1ZXJ5ExoKcHJvamVjdGlvbiACKAIwCzgDSiphcHBob3N0aW5nLmRhdGFzdG9yZS52NC5Qcm9wZXJ0eUV4cHJlc3Npb26jAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoEa2luZCADKAIwCzgDSiZhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5LaW5kRXhwcmVzc2lvbqMBqgEFY3R5cGWyAQZwcm90bzKkARQTGgZmaWx0ZXIgBCgCMAs4AUoeYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRmlsdGVyowGqAQVjdHlwZbIBBnByb3RvMqQBFBMaBW9yZGVyIAUoAjALOANKJWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlByb3BlcnR5T3JkZXKjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoIZ3JvdXBfYnkgBigCMAs4A0opYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUHJvcGVydHlSZWZlcmVuY2WjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoMc3RhcnRfY3Vyc29yIAcoAjAJOAEUExoKZW5kX2N1cnNvciAIKAIwCTgBFBMaBm9mZnNldCAKKAAwBTgBQgEwowGqAQdkZWZhdWx0sgEBMKQBFBMaBWxpbWl0IAsoADAFOAEUwgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
 859   if _net_proto___parse__python is not None:
 860     _net_proto___parse__python.RegisterType(
 861         _SERIALIZED_DESCRIPTOR.tostring())
 862
 863 class KindExpression(ProtocolBuffer.ProtocolMessage):
 864   has_name_ = 0
 865   name_ = ""
 866
 867   def __init__(self, contents=None):
 868     if contents is not None: self.MergeFromString(contents)
 869
 870   def name(self): return self.name_
 871
 872   def set_name(self, x):
 873     self.has_name_ = 1
 874     self.name_ = x
 875
 876   def clear_name(self):
 877     if self.has_name_:
 878       self.has_name_ = 0
 879       self.name_ = ""
 880
 881   def has_name(self): return self.has_name_
 882
 883
 884   def MergeFrom(self, x):
 885     assert x is not self
 886     if (x.has_name()): self.set_name(x.name())
 887
 888   if _net_proto___parse__python is not None:
 889     def _CMergeFromString(self, s):
 890       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.KindExpression', s)
 891
 892   if _net_proto___parse__python is not None:
 893     def _CEncode(self):
 894       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.KindExpression')
 895
 896   if _net_proto___parse__python is not None:
 897     def _CEncodePartial(self):
 898       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.KindExpression')
 899
 900   if _net_proto___parse__python is not None:
 901     def _CToASCII(self, output_format):
 902       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.KindExpression', output_format)
 903
 904
 905   if _net_proto___parse__python is not None:
 906     def ParseASCII(self, s):
 907       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.KindExpression', s)
 908
 909
 910   if _net_proto___parse__python is not None:
 911     def ParseASCIIIgnoreUnknown(self, s):
 912       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.KindExpression', s)
 913
 914
 915   def Equals(self, x):
 916     if x is self: return 1
 917     if self.has_name_ != x.has_name_: return 0
 918     if self.has_name_ and self.name_ != x.name_: return 0
 919     return 1
 920
 921   def IsInitialized(self, debug_strs=None):
 922     initialized = 1
 923     if (not self.has_name_):
 924       initialized = 0
 925       if debug_strs is not None:
 926         debug_strs.append('Required field: name not set.')
 927     return initialized
 928
 929   def ByteSize(self):
 930     n = 0
 931     n += self.lengthString(len(self.name_))
 932     return n + 1
 933
 934   def ByteSizePartial(self):
 935     n = 0
 936     if (self.has_name_):
 937       n += 1
 938       n += self.lengthString(len(self.name_))
 939     return n
 940
 941   def Clear(self):
 942     self.clear_name()
 943
 944   def OutputUnchecked(self, out):
 945     out.putVarInt32(10)
 946     out.putPrefixedString(self.name_)
 947
 948   def OutputPartial(self, out):
 949     if (self.has_name_):
 950       out.putVarInt32(10)
 951       out.putPrefixedString(self.name_)
 952
 953   def TryMerge(self, d):
 954     while d.avail() > 0:
 955       tt = d.getVarInt32()
 956       if tt == 10:
 957         self.set_name(d.getPrefixedString())
 958         continue
 959
 960
 961       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 962       d.skipData(tt)
 963
 964
 965   def __str__(self, prefix="", printElemNumber=0):
 966     res=""
 967     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 968     return res
 969
 970
 971   def _BuildTagLookupTable(sparse, maxtag, default=None):
 972     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 973
 974   kname = 1
 975
 976   _TEXT = _BuildTagLookupTable({
 977     0: "ErrorCode",
 978     1: "name",
 979   }, 1)
 980
 981   _TYPES = _BuildTagLookupTable({
 982     0: ProtocolBuffer.Encoder.NUMERIC,
 983     1: ProtocolBuffer.Encoder.STRING,
 984   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
 985
 986
 987   _STYLE = """"""
 988   _STYLE_CONTENT_TYPE = """"""
 989   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.KindExpression'
 990   _SERIALIZED_DESCRIPTOR = array.array('B')
 991   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktpbmRFeHByZXNzaW9uExoEbmFtZSABKAIwCTgCFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
 992   if _net_proto___parse__python is not None:
 993     _net_proto___parse__python.RegisterType(
 994         _SERIALIZED_DESCRIPTOR.tostring())
 995
 996 class PropertyReference(ProtocolBuffer.ProtocolMessage):
 997   has_name_ = 0
 998   name_ = ""
 999
1000   def __init__(self, contents=None):
1001     if contents is not None: self.MergeFromString(contents)
1002
1003   def name(self): return self.name_
1004
1005   def set_name(self, x):
1006     self.has_name_ = 1
1007     self.name_ = x
1008
1009   def clear_name(self):
1010     if self.has_name_:
1011       self.has_name_ = 0
1012       self.name_ = ""
1013
1014   def has_name(self): return self.has_name_
1015
1016
1017   def MergeFrom(self, x):
1018     assert x is not self
1019     if (x.has_name()): self.set_name(x.name())
1020
1021   if _net_proto___parse__python is not None:
1022     def _CMergeFromString(self, s):
1023       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.PropertyReference', s)
1024
1025   if _net_proto___parse__python is not None:
1026     def _CEncode(self):
1027       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.PropertyReference')
1028
1029   if _net_proto___parse__python is not None:
1030     def _CEncodePartial(self):
1031       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.PropertyReference')
1032
1033   if _net_proto___parse__python is not None:
1034     def _CToASCII(self, output_format):
1035       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.PropertyReference', output_format)
1036
1037
1038   if _net_proto___parse__python is not None:
1039     def ParseASCII(self, s):
1040       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.PropertyReference', s)
1041
1042
1043   if _net_proto___parse__python is not None:
1044     def ParseASCIIIgnoreUnknown(self, s):
1045       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.PropertyReference', s)
1046
1047
1048   def Equals(self, x):
1049     if x is self: return 1
1050     if self.has_name_ != x.has_name_: return 0
1051     if self.has_name_ and self.name_ != x.name_: return 0
1052     return 1
1053
1054   def IsInitialized(self, debug_strs=None):
1055     initialized = 1
1056     if (not self.has_name_):
1057       initialized = 0
1058       if debug_strs is not None:
1059         debug_strs.append('Required field: name not set.')
1060     return initialized
1061
1062   def ByteSize(self):
1063     n = 0
1064     n += self.lengthString(len(self.name_))
1065     return n + 1
1066
1067   def ByteSizePartial(self):
1068     n = 0
1069     if (self.has_name_):
1070       n += 1
1071       n += self.lengthString(len(self.name_))
1072     return n
1073
1074   def Clear(self):
1075     self.clear_name()
1076
1077   def OutputUnchecked(self, out):
1078     out.putVarInt32(18)
1079     out.putPrefixedString(self.name_)
1080
1081   def OutputPartial(self, out):
1082     if (self.has_name_):
1083       out.putVarInt32(18)
1084       out.putPrefixedString(self.name_)
1085
1086   def TryMerge(self, d):
1087     while d.avail() > 0:
1088       tt = d.getVarInt32()
1089       if tt == 18:
1090         self.set_name(d.getPrefixedString())
1091         continue
1092
1093
1094       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1095       d.skipData(tt)
1096
1097
1098   def __str__(self, prefix="", printElemNumber=0):
1099     res=""
1100     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1101     return res
1102
1103
1104   def _BuildTagLookupTable(sparse, maxtag, default=None):
1105     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1106
1107   kname = 2
1108
1109   _TEXT = _BuildTagLookupTable({
1110     0: "ErrorCode",
1111     2: "name",
1112   }, 2)
1113
1114   _TYPES = _BuildTagLookupTable({
1115     0: ProtocolBuffer.Encoder.NUMERIC,
1116     2: ProtocolBuffer.Encoder.STRING,
1117   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1118
1119
1120   _STYLE = """"""
1121   _STYLE_CONTENT_TYPE = """"""
1122   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.PropertyReference'
1123   _SERIALIZED_DESCRIPTOR = array.array('B')
1124   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KKWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlByb3BlcnR5UmVmZXJlbmNlExoEbmFtZSACKAIwCTgCFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
1125   if _net_proto___parse__python is not None:
1126     _net_proto___parse__python.RegisterType(
1127         _SERIALIZED_DESCRIPTOR.tostring())
1128
1129 class PropertyExpression(ProtocolBuffer.ProtocolMessage):
1130
1131
1132   FIRST        =    1
1133
1134   _AggregationFunction_NAMES = {
1135     1: "FIRST",
1136   }
1137
1138   def AggregationFunction_Name(cls, x): return cls._AggregationFunction_NAMES.get(x, "")
1139   AggregationFunction_Name = classmethod(AggregationFunction_Name)
1140
1141   has_property_ = 0
1142   has_aggregation_function_ = 0
1143   aggregation_function_ = 0
1144
1145   def __init__(self, contents=None):
1146     self.property_ = PropertyReference()
1147     if contents is not None: self.MergeFromString(contents)
1148
1149   def property(self): return self.property_
1150
1151   def mutable_property(self): self.has_property_ = 1; return self.property_
1152
1153   def clear_property(self):self.has_property_ = 0; self.property_.Clear()
1154
1155   def has_property(self): return self.has_property_
1156
1157   def aggregation_function(self): return self.aggregation_function_
1158
1159   def set_aggregation_function(self, x):
1160     self.has_aggregation_function_ = 1
1161     self.aggregation_function_ = x
1162
1163   def clear_aggregation_function(self):
1164     if self.has_aggregation_function_:
1165       self.has_aggregation_function_ = 0
1166       self.aggregation_function_ = 0
1167
1168   def has_aggregation_function(self): return self.has_aggregation_function_
1169
1170
1171   def MergeFrom(self, x):
1172     assert x is not self
1173     if (x.has_property()): self.mutable_property().MergeFrom(x.property())
1174     if (x.has_aggregation_function()): self.set_aggregation_function(x.aggregation_function())
1175
1176   if _net_proto___parse__python is not None:
1177     def _CMergeFromString(self, s):
1178       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.PropertyExpression', s)
1179
1180   if _net_proto___parse__python is not None:
1181     def _CEncode(self):
1182       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.PropertyExpression')
1183
1184   if _net_proto___parse__python is not None:
1185     def _CEncodePartial(self):
1186       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.PropertyExpression')
1187
1188   if _net_proto___parse__python is not None:
1189     def _CToASCII(self, output_format):
1190       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.PropertyExpression', output_format)
1191
1192
1193   if _net_proto___parse__python is not None:
1194     def ParseASCII(self, s):
1195       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.PropertyExpression', s)
1196
1197
1198   if _net_proto___parse__python is not None:
1199     def ParseASCIIIgnoreUnknown(self, s):
1200       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.PropertyExpression', s)
1201
1202
1203   def Equals(self, x):
1204     if x is self: return 1
1205     if self.has_property_ != x.has_property_: return 0
1206     if self.has_property_ and self.property_ != x.property_: return 0
1207     if self.has_aggregation_function_ != x.has_aggregation_function_: return 0
1208     if self.has_aggregation_function_ and self.aggregation_function_ != x.aggregation_function_: return 0
1209     return 1
1210
1211   def IsInitialized(self, debug_strs=None):
1212     initialized = 1
1213     if (not self.has_property_):
1214       initialized = 0
1215       if debug_strs is not None:
1216         debug_strs.append('Required field: property not set.')
1217     elif not self.property_.IsInitialized(debug_strs): initialized = 0
1218     return initialized
1219
1220   def ByteSize(self):
1221     n = 0
1222     n += self.lengthString(self.property_.ByteSize())
1223     if (self.has_aggregation_function_): n += 1 + self.lengthVarInt64(self.aggregation_function_)
1224     return n + 1
1225
1226   def ByteSizePartial(self):
1227     n = 0
1228     if (self.has_property_):
1229       n += 1
1230       n += self.lengthString(self.property_.ByteSizePartial())
1231     if (self.has_aggregation_function_): n += 1 + self.lengthVarInt64(self.aggregation_function_)
1232     return n
1233
1234   def Clear(self):
1235     self.clear_property()
1236     self.clear_aggregation_function()
1237
1238   def OutputUnchecked(self, out):
1239     out.putVarInt32(10)
1240     out.putVarInt32(self.property_.ByteSize())
1241     self.property_.OutputUnchecked(out)
1242     if (self.has_aggregation_function_):
1243       out.putVarInt32(16)
1244       out.putVarInt32(self.aggregation_function_)
1245
1246   def OutputPartial(self, out):
1247     if (self.has_property_):
1248       out.putVarInt32(10)
1249       out.putVarInt32(self.property_.ByteSizePartial())
1250       self.property_.OutputPartial(out)
1251     if (self.has_aggregation_function_):
1252       out.putVarInt32(16)
1253       out.putVarInt32(self.aggregation_function_)
1254
1255   def TryMerge(self, d):
1256     while d.avail() > 0:
1257       tt = d.getVarInt32()
1258       if tt == 10:
1259         length = d.getVarInt32()
1260         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1261         d.skip(length)
1262         self.mutable_property().TryMerge(tmp)
1263         continue
1264       if tt == 16:
1265         self.set_aggregation_function(d.getVarInt32())
1266         continue
1267
1268
1269       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1270       d.skipData(tt)
1271
1272
1273   def __str__(self, prefix="", printElemNumber=0):
1274     res=""
1275     if self.has_property_:
1276       res+=prefix+"property <\n"
1277       res+=self.property_.__str__(prefix + "  ", printElemNumber)
1278       res+=prefix+">\n"
1279     if self.has_aggregation_function_: res+=prefix+("aggregation_function: %s\n" % self.DebugFormatInt32(self.aggregation_function_))
1280     return res
1281
1282
1283   def _BuildTagLookupTable(sparse, maxtag, default=None):
1284     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1285
1286   kproperty = 1
1287   kaggregation_function = 2
1288
1289   _TEXT = _BuildTagLookupTable({
1290     0: "ErrorCode",
1291     1: "property",
1292     2: "aggregation_function",
1293   }, 2)
1294
1295   _TYPES = _BuildTagLookupTable({
1296     0: ProtocolBuffer.Encoder.NUMERIC,
1297     1: ProtocolBuffer.Encoder.STRING,
1298     2: ProtocolBuffer.Encoder.NUMERIC,
1299   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1300
1301
1302   _STYLE = """"""
1303   _STYLE_CONTENT_TYPE = """"""
1304   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.PropertyExpression'
1305   _SERIALIZED_DESCRIPTOR = array.array('B')
1306   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KKmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlByb3BlcnR5RXhwcmVzc2lvbhMaCHByb3BlcnR5IAEoAjALOAJKKWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlByb3BlcnR5UmVmZXJlbmNlowGqAQVjdHlwZbIBBnByb3RvMqQBFBMaFGFnZ3JlZ2F0aW9uX2Z1bmN0aW9uIAIoADAFOAFoABRzehNBZ2dyZWdhdGlvbkZ1bmN0aW9uiwGSAQVGSVJTVJgBAYwBdMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
1307   if _net_proto___parse__python is not None:
1308     _net_proto___parse__python.RegisterType(
1309         _SERIALIZED_DESCRIPTOR.tostring())
1310
1311 class PropertyOrder(ProtocolBuffer.ProtocolMessage):
1312
1313
1314   ASCENDING    =    1
1315   DESCENDING   =    2
1316
1317   _Direction_NAMES = {
1318     1: "ASCENDING",
1319     2: "DESCENDING",
1320   }
1321
1322   def Direction_Name(cls, x): return cls._Direction_NAMES.get(x, "")
1323   Direction_Name = classmethod(Direction_Name)
1324
1325   has_property_ = 0
1326   has_direction_ = 0
1327   direction_ = 1
1328
1329   def __init__(self, contents=None):
1330     self.property_ = PropertyReference()
1331     if contents is not None: self.MergeFromString(contents)
1332
1333   def property(self): return self.property_
1334
1335   def mutable_property(self): self.has_property_ = 1; return self.property_
1336
1337   def clear_property(self):self.has_property_ = 0; self.property_.Clear()
1338
1339   def has_property(self): return self.has_property_
1340
1341   def direction(self): return self.direction_
1342
1343   def set_direction(self, x):
1344     self.has_direction_ = 1
1345     self.direction_ = x
1346
1347   def clear_direction(self):
1348     if self.has_direction_:
1349       self.has_direction_ = 0
1350       self.direction_ = 1
1351
1352   def has_direction(self): return self.has_direction_
1353
1354
1355   def MergeFrom(self, x):
1356     assert x is not self
1357     if (x.has_property()): self.mutable_property().MergeFrom(x.property())
1358     if (x.has_direction()): self.set_direction(x.direction())
1359
1360   if _net_proto___parse__python is not None:
1361     def _CMergeFromString(self, s):
1362       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.PropertyOrder', s)
1363
1364   if _net_proto___parse__python is not None:
1365     def _CEncode(self):
1366       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.PropertyOrder')
1367
1368   if _net_proto___parse__python is not None:
1369     def _CEncodePartial(self):
1370       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.PropertyOrder')
1371
1372   if _net_proto___parse__python is not None:
1373     def _CToASCII(self, output_format):
1374       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.PropertyOrder', output_format)
1375
1376
1377   if _net_proto___parse__python is not None:
1378     def ParseASCII(self, s):
1379       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.PropertyOrder', s)
1380
1381
1382   if _net_proto___parse__python is not None:
1383     def ParseASCIIIgnoreUnknown(self, s):
1384       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.PropertyOrder', s)
1385
1386
1387   def Equals(self, x):
1388     if x is self: return 1
1389     if self.has_property_ != x.has_property_: return 0
1390     if self.has_property_ and self.property_ != x.property_: return 0
1391     if self.has_direction_ != x.has_direction_: return 0
1392     if self.has_direction_ and self.direction_ != x.direction_: return 0
1393     return 1
1394
1395   def IsInitialized(self, debug_strs=None):
1396     initialized = 1
1397     if (not self.has_property_):
1398       initialized = 0
1399       if debug_strs is not None:
1400         debug_strs.append('Required field: property not set.')
1401     elif not self.property_.IsInitialized(debug_strs): initialized = 0
1402     return initialized
1403
1404   def ByteSize(self):
1405     n = 0
1406     n += self.lengthString(self.property_.ByteSize())
1407     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
1408     return n + 1
1409
1410   def ByteSizePartial(self):
1411     n = 0
1412     if (self.has_property_):
1413       n += 1
1414       n += self.lengthString(self.property_.ByteSizePartial())
1415     if (self.has_direction_): n += 1 + self.lengthVarInt64(self.direction_)
1416     return n
1417
1418   def Clear(self):
1419     self.clear_property()
1420     self.clear_direction()
1421
1422   def OutputUnchecked(self, out):
1423     out.putVarInt32(10)
1424     out.putVarInt32(self.property_.ByteSize())
1425     self.property_.OutputUnchecked(out)
1426     if (self.has_direction_):
1427       out.putVarInt32(16)
1428       out.putVarInt32(self.direction_)
1429
1430   def OutputPartial(self, out):
1431     if (self.has_property_):
1432       out.putVarInt32(10)
1433       out.putVarInt32(self.property_.ByteSizePartial())
1434       self.property_.OutputPartial(out)
1435     if (self.has_direction_):
1436       out.putVarInt32(16)
1437       out.putVarInt32(self.direction_)
1438
1439   def TryMerge(self, d):
1440     while d.avail() > 0:
1441       tt = d.getVarInt32()
1442       if tt == 10:
1443         length = d.getVarInt32()
1444         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1445         d.skip(length)
1446         self.mutable_property().TryMerge(tmp)
1447         continue
1448       if tt == 16:
1449         self.set_direction(d.getVarInt32())
1450         continue
1451
1452
1453       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1454       d.skipData(tt)
1455
1456
1457   def __str__(self, prefix="", printElemNumber=0):
1458     res=""
1459     if self.has_property_:
1460       res+=prefix+"property <\n"
1461       res+=self.property_.__str__(prefix + "  ", printElemNumber)
1462       res+=prefix+">\n"
1463     if self.has_direction_: res+=prefix+("direction: %s\n" % self.DebugFormatInt32(self.direction_))
1464     return res
1465
1466
1467   def _BuildTagLookupTable(sparse, maxtag, default=None):
1468     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1469
1470   kproperty = 1
1471   kdirection = 2
1472
1473   _TEXT = _BuildTagLookupTable({
1474     0: "ErrorCode",
1475     1: "property",
1476     2: "direction",
1477   }, 2)
1478
1479   _TYPES = _BuildTagLookupTable({
1480     0: ProtocolBuffer.Encoder.NUMERIC,
1481     1: ProtocolBuffer.Encoder.STRING,
1482     2: ProtocolBuffer.Encoder.NUMERIC,
1483   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1484
1485
1486   _STYLE = """"""
1487   _STYLE_CONTENT_TYPE = """"""
1488   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.PropertyOrder'
1489   _SERIALIZED_DESCRIPTOR = array.array('B')
1490   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlByb3BlcnR5T3JkZXITGghwcm9wZXJ0eSABKAIwCzgCSilhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5Qcm9wZXJ0eVJlZmVyZW5jZaMBqgEFY3R5cGWyAQZwcm90bzKkARQTGglkaXJlY3Rpb24gAigAMAU4AUIBMWgAowGqAQdkZWZhdWx0sgEJQVNDRU5ESU5HpAEUc3oJRGlyZWN0aW9uiwGSAQlBU0NFTkRJTkeYAQGMAYsBkgEKREVTQ0VORElOR5gBAowBdMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
1491   if _net_proto___parse__python is not None:
1492     _net_proto___parse__python.RegisterType(
1493         _SERIALIZED_DESCRIPTOR.tostring())
1494
1495 class Filter(ProtocolBuffer.ProtocolMessage):
1496   has_composite_filter_ = 0
1497   composite_filter_ = None
1498   has_property_filter_ = 0
1499   property_filter_ = None
1500
1501   def __init__(self, contents=None):
1502     self.lazy_init_lock_ = thread.allocate_lock()
1503     if contents is not None: self.MergeFromString(contents)
1504
1505   def composite_filter(self):
1506     if self.composite_filter_ is None:
1507       self.lazy_init_lock_.acquire()
1508       try:
1509         if self.composite_filter_ is None: self.composite_filter_ = CompositeFilter()
1510       finally:
1511         self.lazy_init_lock_.release()
1512     return self.composite_filter_
1513
1514   def mutable_composite_filter(self): self.has_composite_filter_ = 1; return self.composite_filter()
1515
1516   def clear_composite_filter(self):
1517
1518     if self.has_composite_filter_:
1519       self.has_composite_filter_ = 0;
1520       if self.composite_filter_ is not None: self.composite_filter_.Clear()
1521
1522   def has_composite_filter(self): return self.has_composite_filter_
1523
1524   def property_filter(self):
1525     if self.property_filter_ is None:
1526       self.lazy_init_lock_.acquire()
1527       try:
1528         if self.property_filter_ is None: self.property_filter_ = PropertyFilter()
1529       finally:
1530         self.lazy_init_lock_.release()
1531     return self.property_filter_
1532
1533   def mutable_property_filter(self): self.has_property_filter_ = 1; return self.property_filter()
1534
1535   def clear_property_filter(self):
1536
1537     if self.has_property_filter_:
1538       self.has_property_filter_ = 0;
1539       if self.property_filter_ is not None: self.property_filter_.Clear()
1540
1541   def has_property_filter(self): return self.has_property_filter_
1542
1543
1544   def MergeFrom(self, x):
1545     assert x is not self
1546     if (x.has_composite_filter()): self.mutable_composite_filter().MergeFrom(x.composite_filter())
1547     if (x.has_property_filter()): self.mutable_property_filter().MergeFrom(x.property_filter())
1548
1549   if _net_proto___parse__python is not None:
1550     def _CMergeFromString(self, s):
1551       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Filter', s)
1552
1553   if _net_proto___parse__python is not None:
1554     def _CEncode(self):
1555       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Filter')
1556
1557   if _net_proto___parse__python is not None:
1558     def _CEncodePartial(self):
1559       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Filter')
1560
1561   if _net_proto___parse__python is not None:
1562     def _CToASCII(self, output_format):
1563       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Filter', output_format)
1564
1565
1566   if _net_proto___parse__python is not None:
1567     def ParseASCII(self, s):
1568       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Filter', s)
1569
1570
1571   if _net_proto___parse__python is not None:
1572     def ParseASCIIIgnoreUnknown(self, s):
1573       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Filter', s)
1574
1575
1576   def Equals(self, x):
1577     if x is self: return 1
1578     if self.has_composite_filter_ != x.has_composite_filter_: return 0
1579     if self.has_composite_filter_ and self.composite_filter_ != x.composite_filter_: return 0
1580     if self.has_property_filter_ != x.has_property_filter_: return 0
1581     if self.has_property_filter_ and self.property_filter_ != x.property_filter_: return 0
1582     return 1
1583
1584   def IsInitialized(self, debug_strs=None):
1585     initialized = 1
1586     if (self.has_composite_filter_ and not self.composite_filter_.IsInitialized(debug_strs)): initialized = 0
1587     if (self.has_property_filter_ and not self.property_filter_.IsInitialized(debug_strs)): initialized = 0
1588     return initialized
1589
1590   def ByteSize(self):
1591     n = 0
1592     if (self.has_composite_filter_): n += 1 + self.lengthString(self.composite_filter_.ByteSize())
1593     if (self.has_property_filter_): n += 1 + self.lengthString(self.property_filter_.ByteSize())
1594     return n
1595
1596   def ByteSizePartial(self):
1597     n = 0
1598     if (self.has_composite_filter_): n += 1 + self.lengthString(self.composite_filter_.ByteSizePartial())
1599     if (self.has_property_filter_): n += 1 + self.lengthString(self.property_filter_.ByteSizePartial())
1600     return n
1601
1602   def Clear(self):
1603     self.clear_composite_filter()
1604     self.clear_property_filter()
1605
1606   def OutputUnchecked(self, out):
1607     if (self.has_composite_filter_):
1608       out.putVarInt32(10)
1609       out.putVarInt32(self.composite_filter_.ByteSize())
1610       self.composite_filter_.OutputUnchecked(out)
1611     if (self.has_property_filter_):
1612       out.putVarInt32(18)
1613       out.putVarInt32(self.property_filter_.ByteSize())
1614       self.property_filter_.OutputUnchecked(out)
1615
1616   def OutputPartial(self, out):
1617     if (self.has_composite_filter_):
1618       out.putVarInt32(10)
1619       out.putVarInt32(self.composite_filter_.ByteSizePartial())
1620       self.composite_filter_.OutputPartial(out)
1621     if (self.has_property_filter_):
1622       out.putVarInt32(18)
1623       out.putVarInt32(self.property_filter_.ByteSizePartial())
1624       self.property_filter_.OutputPartial(out)
1625
1626   def TryMerge(self, d):
1627     while d.avail() > 0:
1628       tt = d.getVarInt32()
1629       if tt == 10:
1630         length = d.getVarInt32()
1631         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1632         d.skip(length)
1633         self.mutable_composite_filter().TryMerge(tmp)
1634         continue
1635       if tt == 18:
1636         length = d.getVarInt32()
1637         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1638         d.skip(length)
1639         self.mutable_property_filter().TryMerge(tmp)
1640         continue
1641
1642
1643       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1644       d.skipData(tt)
1645
1646
1647   def __str__(self, prefix="", printElemNumber=0):
1648     res=""
1649     if self.has_composite_filter_:
1650       res+=prefix+"composite_filter <\n"
1651       res+=self.composite_filter_.__str__(prefix + "  ", printElemNumber)
1652       res+=prefix+">\n"
1653     if self.has_property_filter_:
1654       res+=prefix+"property_filter <\n"
1655       res+=self.property_filter_.__str__(prefix + "  ", printElemNumber)
1656       res+=prefix+">\n"
1657     return res
1658
1659
1660   def _BuildTagLookupTable(sparse, maxtag, default=None):
1661     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1662
1663   kcomposite_filter = 1
1664   kproperty_filter = 2
1665
1666   _TEXT = _BuildTagLookupTable({
1667     0: "ErrorCode",
1668     1: "composite_filter",
1669     2: "property_filter",
1670   }, 2)
1671
1672   _TYPES = _BuildTagLookupTable({
1673     0: ProtocolBuffer.Encoder.NUMERIC,
1674     1: ProtocolBuffer.Encoder.STRING,
1675     2: ProtocolBuffer.Encoder.STRING,
1676   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1677
1678
1679   _STYLE = """"""
1680   _STYLE_CONTENT_TYPE = """"""
1681   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Filter'
1682   _SERIALIZED_DESCRIPTOR = array.array('B')
1683   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KHmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkZpbHRlchMaEGNvbXBvc2l0ZV9maWx0ZXIgASgCMAs4AUonYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuQ29tcG9zaXRlRmlsdGVyowGqAQVjdHlwZbIBBnByb3RvMqQBFBMaD3Byb3BlcnR5X2ZpbHRlciACKAIwCzgBSiZhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5Qcm9wZXJ0eUZpbHRlcqMBqgEFY3R5cGWyAQZwcm90bzKkARTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
1684   if _net_proto___parse__python is not None:
1685     _net_proto___parse__python.RegisterType(
1686         _SERIALIZED_DESCRIPTOR.tostring())
1687
1688 class CompositeFilter(ProtocolBuffer.ProtocolMessage):
1689
1690
1691   AND          =    1
1692
1693   _Operator_NAMES = {
1694     1: "AND",
1695   }
1696
1697   def Operator_Name(cls, x): return cls._Operator_NAMES.get(x, "")
1698   Operator_Name = classmethod(Operator_Name)
1699
1700   has_operator_ = 0
1701   operator_ = 0
1702
1703   def __init__(self, contents=None):
1704     self.filter_ = []
1705     if contents is not None: self.MergeFromString(contents)
1706
1707   def operator(self): return self.operator_
1708
1709   def set_operator(self, x):
1710     self.has_operator_ = 1
1711     self.operator_ = x
1712
1713   def clear_operator(self):
1714     if self.has_operator_:
1715       self.has_operator_ = 0
1716       self.operator_ = 0
1717
1718   def has_operator(self): return self.has_operator_
1719
1720   def filter_size(self): return len(self.filter_)
1721   def filter_list(self): return self.filter_
1722
1723   def filter(self, i):
1724     return self.filter_[i]
1725
1726   def mutable_filter(self, i):
1727     return self.filter_[i]
1728
1729   def add_filter(self):
1730     x = Filter()
1731     self.filter_.append(x)
1732     return x
1733
1734   def clear_filter(self):
1735     self.filter_ = []
1736
1737   def MergeFrom(self, x):
1738     assert x is not self
1739     if (x.has_operator()): self.set_operator(x.operator())
1740     for i in xrange(x.filter_size()): self.add_filter().CopyFrom(x.filter(i))
1741
1742   if _net_proto___parse__python is not None:
1743     def _CMergeFromString(self, s):
1744       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.CompositeFilter', s)
1745
1746   if _net_proto___parse__python is not None:
1747     def _CEncode(self):
1748       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.CompositeFilter')
1749
1750   if _net_proto___parse__python is not None:
1751     def _CEncodePartial(self):
1752       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.CompositeFilter')
1753
1754   if _net_proto___parse__python is not None:
1755     def _CToASCII(self, output_format):
1756       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.CompositeFilter', output_format)
1757
1758
1759   if _net_proto___parse__python is not None:
1760     def ParseASCII(self, s):
1761       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.CompositeFilter', s)
1762
1763
1764   if _net_proto___parse__python is not None:
1765     def ParseASCIIIgnoreUnknown(self, s):
1766       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.CompositeFilter', s)
1767
1768
1769   def Equals(self, x):
1770     if x is self: return 1
1771     if self.has_operator_ != x.has_operator_: return 0
1772     if self.has_operator_ and self.operator_ != x.operator_: return 0
1773     if len(self.filter_) != len(x.filter_): return 0
1774     for e1, e2 in zip(self.filter_, x.filter_):
1775       if e1 != e2: return 0
1776     return 1
1777
1778   def IsInitialized(self, debug_strs=None):
1779     initialized = 1
1780     if (not self.has_operator_):
1781       initialized = 0
1782       if debug_strs is not None:
1783         debug_strs.append('Required field: operator not set.')
1784     for p in self.filter_:
1785       if not p.IsInitialized(debug_strs): initialized=0
1786     return initialized
1787
1788   def ByteSize(self):
1789     n = 0
1790     n += self.lengthVarInt64(self.operator_)
1791     n += 1 * len(self.filter_)
1792     for i in xrange(len(self.filter_)): n += self.lengthString(self.filter_[i].ByteSize())
1793     return n + 1
1794
1795   def ByteSizePartial(self):
1796     n = 0
1797     if (self.has_operator_):
1798       n += 1
1799       n += self.lengthVarInt64(self.operator_)
1800     n += 1 * len(self.filter_)
1801     for i in xrange(len(self.filter_)): n += self.lengthString(self.filter_[i].ByteSizePartial())
1802     return n
1803
1804   def Clear(self):
1805     self.clear_operator()
1806     self.clear_filter()
1807
1808   def OutputUnchecked(self, out):
1809     out.putVarInt32(8)
1810     out.putVarInt32(self.operator_)
1811     for i in xrange(len(self.filter_)):
1812       out.putVarInt32(18)
1813       out.putVarInt32(self.filter_[i].ByteSize())
1814       self.filter_[i].OutputUnchecked(out)
1815
1816   def OutputPartial(self, out):
1817     if (self.has_operator_):
1818       out.putVarInt32(8)
1819       out.putVarInt32(self.operator_)
1820     for i in xrange(len(self.filter_)):
1821       out.putVarInt32(18)
1822       out.putVarInt32(self.filter_[i].ByteSizePartial())
1823       self.filter_[i].OutputPartial(out)
1824
1825   def TryMerge(self, d):
1826     while d.avail() > 0:
1827       tt = d.getVarInt32()
1828       if tt == 8:
1829         self.set_operator(d.getVarInt32())
1830         continue
1831       if tt == 18:
1832         length = d.getVarInt32()
1833         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1834         d.skip(length)
1835         self.add_filter().TryMerge(tmp)
1836         continue
1837
1838
1839       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1840       d.skipData(tt)
1841
1842
1843   def __str__(self, prefix="", printElemNumber=0):
1844     res=""
1845     if self.has_operator_: res+=prefix+("operator: %s\n" % self.DebugFormatInt32(self.operator_))
1846     cnt=0
1847     for e in self.filter_:
1848       elm=""
1849       if printElemNumber: elm="(%d)" % cnt
1850       res+=prefix+("filter%s <\n" % elm)
1851       res+=e.__str__(prefix + "  ", printElemNumber)
1852       res+=prefix+">\n"
1853       cnt+=1
1854     return res
1855
1856
1857   def _BuildTagLookupTable(sparse, maxtag, default=None):
1858     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1859
1860   koperator = 1
1861   kfilter = 2
1862
1863   _TEXT = _BuildTagLookupTable({
1864     0: "ErrorCode",
1865     1: "operator",
1866     2: "filter",
1867   }, 2)
1868
1869   _TYPES = _BuildTagLookupTable({
1870     0: ProtocolBuffer.Encoder.NUMERIC,
1871     1: ProtocolBuffer.Encoder.NUMERIC,
1872     2: ProtocolBuffer.Encoder.STRING,
1873   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1874
1875
1876   _STYLE = """"""
1877   _STYLE_CONTENT_TYPE = """"""
1878   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.CompositeFilter'
1879   _SERIALIZED_DESCRIPTOR = array.array('B')
1880   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJ2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkNvbXBvc2l0ZUZpbHRlchMaCG9wZXJhdG9yIAEoADAFOAJoABQTGgZmaWx0ZXIgAigCMAs4A0oeYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRmlsdGVyowGqAQVjdHlwZbIBBnByb3RvMqQBFHN6CE9wZXJhdG9yiwGSAQNBTkSYAQGMAXTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
1881   if _net_proto___parse__python is not None:
1882     _net_proto___parse__python.RegisterType(
1883         _SERIALIZED_DESCRIPTOR.tostring())
1884
1885 class PropertyFilter(ProtocolBuffer.ProtocolMessage):
1886
1887
1888   LESS_THAN    =    1
1889   LESS_THAN_OR_EQUAL =    2
1890   GREATER_THAN =    3
1891   GREATER_THAN_OR_EQUAL =    4
1892   EQUAL        =    5
1893   HAS_ANCESTOR =   11
1894
1895   _Operator_NAMES = {
1896     1: "LESS_THAN",
1897     2: "LESS_THAN_OR_EQUAL",
1898     3: "GREATER_THAN",
1899     4: "GREATER_THAN_OR_EQUAL",
1900     5: "EQUAL",
1901     11: "HAS_ANCESTOR",
1902   }
1903
1904   def Operator_Name(cls, x): return cls._Operator_NAMES.get(x, "")
1905   Operator_Name = classmethod(Operator_Name)
1906
1907   has_property_ = 0
1908   has_operator_ = 0
1909   operator_ = 0
1910   has_value_ = 0
1911
1912   def __init__(self, contents=None):
1913     self.property_ = PropertyReference()
1914     self.value_ = google.appengine.datastore.entity_v4_pb.Value()
1915     if contents is not None: self.MergeFromString(contents)
1916
1917   def property(self): return self.property_
1918
1919   def mutable_property(self): self.has_property_ = 1; return self.property_
1920
1921   def clear_property(self):self.has_property_ = 0; self.property_.Clear()
1922
1923   def has_property(self): return self.has_property_
1924
1925   def operator(self): return self.operator_
1926
1927   def set_operator(self, x):
1928     self.has_operator_ = 1
1929     self.operator_ = x
1930
1931   def clear_operator(self):
1932     if self.has_operator_:
1933       self.has_operator_ = 0
1934       self.operator_ = 0
1935
1936   def has_operator(self): return self.has_operator_
1937
1938   def value(self): return self.value_
1939
1940   def mutable_value(self): self.has_value_ = 1; return self.value_
1941
1942   def clear_value(self):self.has_value_ = 0; self.value_.Clear()
1943
1944   def has_value(self): return self.has_value_
1945
1946
1947   def MergeFrom(self, x):
1948     assert x is not self
1949     if (x.has_property()): self.mutable_property().MergeFrom(x.property())
1950     if (x.has_operator()): self.set_operator(x.operator())
1951     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
1952
1953   if _net_proto___parse__python is not None:
1954     def _CMergeFromString(self, s):
1955       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.PropertyFilter', s)
1956
1957   if _net_proto___parse__python is not None:
1958     def _CEncode(self):
1959       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.PropertyFilter')
1960
1961   if _net_proto___parse__python is not None:
1962     def _CEncodePartial(self):
1963       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.PropertyFilter')
1964
1965   if _net_proto___parse__python is not None:
1966     def _CToASCII(self, output_format):
1967       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.PropertyFilter', output_format)
1968
1969
1970   if _net_proto___parse__python is not None:
1971     def ParseASCII(self, s):
1972       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.PropertyFilter', s)
1973
1974
1975   if _net_proto___parse__python is not None:
1976     def ParseASCIIIgnoreUnknown(self, s):
1977       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.PropertyFilter', s)
1978
1979
1980   def Equals(self, x):
1981     if x is self: return 1
1982     if self.has_property_ != x.has_property_: return 0
1983     if self.has_property_ and self.property_ != x.property_: return 0
1984     if self.has_operator_ != x.has_operator_: return 0
1985     if self.has_operator_ and self.operator_ != x.operator_: return 0
1986     if self.has_value_ != x.has_value_: return 0
1987     if self.has_value_ and self.value_ != x.value_: return 0
1988     return 1
1989
1990   def IsInitialized(self, debug_strs=None):
1991     initialized = 1
1992     if (not self.has_property_):
1993       initialized = 0
1994       if debug_strs is not None:
1995         debug_strs.append('Required field: property not set.')
1996     elif not self.property_.IsInitialized(debug_strs): initialized = 0
1997     if (not self.has_operator_):
1998       initialized = 0
1999       if debug_strs is not None:
2000         debug_strs.append('Required field: operator not set.')
2001     if (not self.has_value_):
2002       initialized = 0
2003       if debug_strs is not None:
2004         debug_strs.append('Required field: value not set.')
2005     elif not self.value_.IsInitialized(debug_strs): initialized = 0
2006     return initialized
2007
2008   def ByteSize(self):
2009     n = 0
2010     n += self.lengthString(self.property_.ByteSize())
2011     n += self.lengthVarInt64(self.operator_)
2012     n += self.lengthString(self.value_.ByteSize())
2013     return n + 3
2014
2015   def ByteSizePartial(self):
2016     n = 0
2017     if (self.has_property_):
2018       n += 1
2019       n += self.lengthString(self.property_.ByteSizePartial())
2020     if (self.has_operator_):
2021       n += 1
2022       n += self.lengthVarInt64(self.operator_)
2023     if (self.has_value_):
2024       n += 1
2025       n += self.lengthString(self.value_.ByteSizePartial())
2026     return n
2027
2028   def Clear(self):
2029     self.clear_property()
2030     self.clear_operator()
2031     self.clear_value()
2032
2033   def OutputUnchecked(self, out):
2034     out.putVarInt32(10)
2035     out.putVarInt32(self.property_.ByteSize())
2036     self.property_.OutputUnchecked(out)
2037     out.putVarInt32(16)
2038     out.putVarInt32(self.operator_)
2039     out.putVarInt32(26)
2040     out.putVarInt32(self.value_.ByteSize())
2041     self.value_.OutputUnchecked(out)
2042
2043   def OutputPartial(self, out):
2044     if (self.has_property_):
2045       out.putVarInt32(10)
2046       out.putVarInt32(self.property_.ByteSizePartial())
2047       self.property_.OutputPartial(out)
2048     if (self.has_operator_):
2049       out.putVarInt32(16)
2050       out.putVarInt32(self.operator_)
2051     if (self.has_value_):
2052       out.putVarInt32(26)
2053       out.putVarInt32(self.value_.ByteSizePartial())
2054       self.value_.OutputPartial(out)
2055
2056   def TryMerge(self, d):
2057     while d.avail() > 0:
2058       tt = d.getVarInt32()
2059       if tt == 10:
2060         length = d.getVarInt32()
2061         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2062         d.skip(length)
2063         self.mutable_property().TryMerge(tmp)
2064         continue
2065       if tt == 16:
2066         self.set_operator(d.getVarInt32())
2067         continue
2068       if tt == 26:
2069         length = d.getVarInt32()
2070         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2071         d.skip(length)
2072         self.mutable_value().TryMerge(tmp)
2073         continue
2074
2075
2076       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2077       d.skipData(tt)
2078
2079
2080   def __str__(self, prefix="", printElemNumber=0):
2081     res=""
2082     if self.has_property_:
2083       res+=prefix+"property <\n"
2084       res+=self.property_.__str__(prefix + "  ", printElemNumber)
2085       res+=prefix+">\n"
2086     if self.has_operator_: res+=prefix+("operator: %s\n" % self.DebugFormatInt32(self.operator_))
2087     if self.has_value_:
2088       res+=prefix+"value <\n"
2089       res+=self.value_.__str__(prefix + "  ", printElemNumber)
2090       res+=prefix+">\n"
2091     return res
2092
2093
2094   def _BuildTagLookupTable(sparse, maxtag, default=None):
2095     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2096
2097   kproperty = 1
2098   koperator = 2
2099   kvalue = 3
2100
2101   _TEXT = _BuildTagLookupTable({
2102     0: "ErrorCode",
2103     1: "property",
2104     2: "operator",
2105     3: "value",
2106   }, 3)
2107
2108   _TYPES = _BuildTagLookupTable({
2109     0: ProtocolBuffer.Encoder.NUMERIC,
2110     1: ProtocolBuffer.Encoder.STRING,
2111     2: ProtocolBuffer.Encoder.NUMERIC,
2112     3: ProtocolBuffer.Encoder.STRING,
2113   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
2114
2115
2116   _STYLE = """"""
2117   _STYLE_CONTENT_TYPE = """"""
2118   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.PropertyFilter'
2119   _SERIALIZED_DESCRIPTOR = array.array('B')
2120   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlByb3BlcnR5RmlsdGVyExoIcHJvcGVydHkgASgCMAs4AkopYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUHJvcGVydHlSZWZlcmVuY2WjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoIb3BlcmF0b3IgAigAMAU4AmgAFBMaBXZhbHVlIAMoAjALOAJKHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlZhbHVlowGqAQVjdHlwZbIBBnByb3RvMqQBFHN6CE9wZXJhdG9yiwGSAQlMRVNTX1RIQU6YAQGMAYsBkgESTEVTU19USEFOX09SX0VRVUFMmAECjAGLAZIBDEdSRUFURVJfVEhBTpgBA4wBiwGSARVHUkVBVEVSX1RIQU5fT1JfRVFVQUyYAQSMAYsBkgEFRVFVQUyYAQWMAYsBkgEMSEFTX0FOQ0VTVE9SmAELjAF0wgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
2121   if _net_proto___parse__python is not None:
2122     _net_proto___parse__python.RegisterType(
2123         _SERIALIZED_DESCRIPTOR.tostring())
2124
2125 class GqlQuery(ProtocolBuffer.ProtocolMessage):
2126   has_query_string_ = 0
2127   query_string_ = ""
2128   has_allow_literal_ = 0
2129   allow_literal_ = 0
2130
2131   def __init__(self, contents=None):
2132     self.name_arg_ = []
2133     self.number_arg_ = []
2134     if contents is not None: self.MergeFromString(contents)
2135
2136   def query_string(self): return self.query_string_
2137
2138   def set_query_string(self, x):
2139     self.has_query_string_ = 1
2140     self.query_string_ = x
2141
2142   def clear_query_string(self):
2143     if self.has_query_string_:
2144       self.has_query_string_ = 0
2145       self.query_string_ = ""
2146
2147   def has_query_string(self): return self.has_query_string_
2148
2149   def allow_literal(self): return self.allow_literal_
2150
2151   def set_allow_literal(self, x):
2152     self.has_allow_literal_ = 1
2153     self.allow_literal_ = x
2154
2155   def clear_allow_literal(self):
2156     if self.has_allow_literal_:
2157       self.has_allow_literal_ = 0
2158       self.allow_literal_ = 0
2159
2160   def has_allow_literal(self): return self.has_allow_literal_
2161
2162   def name_arg_size(self): return len(self.name_arg_)
2163   def name_arg_list(self): return self.name_arg_
2164
2165   def name_arg(self, i):
2166     return self.name_arg_[i]
2167
2168   def mutable_name_arg(self, i):
2169     return self.name_arg_[i]
2170
2171   def add_name_arg(self):
2172     x = GqlQueryArg()
2173     self.name_arg_.append(x)
2174     return x
2175
2176   def clear_name_arg(self):
2177     self.name_arg_ = []
2178   def number_arg_size(self): return len(self.number_arg_)
2179   def number_arg_list(self): return self.number_arg_
2180
2181   def number_arg(self, i):
2182     return self.number_arg_[i]
2183
2184   def mutable_number_arg(self, i):
2185     return self.number_arg_[i]
2186
2187   def add_number_arg(self):
2188     x = GqlQueryArg()
2189     self.number_arg_.append(x)
2190     return x
2191
2192   def clear_number_arg(self):
2193     self.number_arg_ = []
2194
2195   def MergeFrom(self, x):
2196     assert x is not self
2197     if (x.has_query_string()): self.set_query_string(x.query_string())
2198     if (x.has_allow_literal()): self.set_allow_literal(x.allow_literal())
2199     for i in xrange(x.name_arg_size()): self.add_name_arg().CopyFrom(x.name_arg(i))
2200     for i in xrange(x.number_arg_size()): self.add_number_arg().CopyFrom(x.number_arg(i))
2201
2202   if _net_proto___parse__python is not None:
2203     def _CMergeFromString(self, s):
2204       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.GqlQuery', s)
2205
2206   if _net_proto___parse__python is not None:
2207     def _CEncode(self):
2208       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.GqlQuery')
2209
2210   if _net_proto___parse__python is not None:
2211     def _CEncodePartial(self):
2212       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.GqlQuery')
2213
2214   if _net_proto___parse__python is not None:
2215     def _CToASCII(self, output_format):
2216       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.GqlQuery', output_format)
2217
2218
2219   if _net_proto___parse__python is not None:
2220     def ParseASCII(self, s):
2221       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.GqlQuery', s)
2222
2223
2224   if _net_proto___parse__python is not None:
2225     def ParseASCIIIgnoreUnknown(self, s):
2226       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.GqlQuery', s)
2227
2228
2229   def Equals(self, x):
2230     if x is self: return 1
2231     if self.has_query_string_ != x.has_query_string_: return 0
2232     if self.has_query_string_ and self.query_string_ != x.query_string_: return 0
2233     if self.has_allow_literal_ != x.has_allow_literal_: return 0
2234     if self.has_allow_literal_ and self.allow_literal_ != x.allow_literal_: return 0
2235     if len(self.name_arg_) != len(x.name_arg_): return 0
2236     for e1, e2 in zip(self.name_arg_, x.name_arg_):
2237       if e1 != e2: return 0
2238     if len(self.number_arg_) != len(x.number_arg_): return 0
2239     for e1, e2 in zip(self.number_arg_, x.number_arg_):
2240       if e1 != e2: return 0
2241     return 1
2242
2243   def IsInitialized(self, debug_strs=None):
2244     initialized = 1
2245     if (not self.has_query_string_):
2246       initialized = 0
2247       if debug_strs is not None:
2248         debug_strs.append('Required field: query_string not set.')
2249     for p in self.name_arg_:
2250       if not p.IsInitialized(debug_strs): initialized=0
2251     for p in self.number_arg_:
2252       if not p.IsInitialized(debug_strs): initialized=0
2253     return initialized
2254
2255   def ByteSize(self):
2256     n = 0
2257     n += self.lengthString(len(self.query_string_))
2258     if (self.has_allow_literal_): n += 2
2259     n += 1 * len(self.name_arg_)
2260     for i in xrange(len(self.name_arg_)): n += self.lengthString(self.name_arg_[i].ByteSize())
2261     n += 1 * len(self.number_arg_)
2262     for i in xrange(len(self.number_arg_)): n += self.lengthString(self.number_arg_[i].ByteSize())
2263     return n + 1
2264
2265   def ByteSizePartial(self):
2266     n = 0
2267     if (self.has_query_string_):
2268       n += 1
2269       n += self.lengthString(len(self.query_string_))
2270     if (self.has_allow_literal_): n += 2
2271     n += 1 * len(self.name_arg_)
2272     for i in xrange(len(self.name_arg_)): n += self.lengthString(self.name_arg_[i].ByteSizePartial())
2273     n += 1 * len(self.number_arg_)
2274     for i in xrange(len(self.number_arg_)): n += self.lengthString(self.number_arg_[i].ByteSizePartial())
2275     return n
2276
2277   def Clear(self):
2278     self.clear_query_string()
2279     self.clear_allow_literal()
2280     self.clear_name_arg()
2281     self.clear_number_arg()
2282
2283   def OutputUnchecked(self, out):
2284     out.putVarInt32(10)
2285     out.putPrefixedString(self.query_string_)
2286     if (self.has_allow_literal_):
2287       out.putVarInt32(16)
2288       out.putBoolean(self.allow_literal_)
2289     for i in xrange(len(self.name_arg_)):
2290       out.putVarInt32(26)
2291       out.putVarInt32(self.name_arg_[i].ByteSize())
2292       self.name_arg_[i].OutputUnchecked(out)
2293     for i in xrange(len(self.number_arg_)):
2294       out.putVarInt32(34)
2295       out.putVarInt32(self.number_arg_[i].ByteSize())
2296       self.number_arg_[i].OutputUnchecked(out)
2297
2298   def OutputPartial(self, out):
2299     if (self.has_query_string_):
2300       out.putVarInt32(10)
2301       out.putPrefixedString(self.query_string_)
2302     if (self.has_allow_literal_):
2303       out.putVarInt32(16)
2304       out.putBoolean(self.allow_literal_)
2305     for i in xrange(len(self.name_arg_)):
2306       out.putVarInt32(26)
2307       out.putVarInt32(self.name_arg_[i].ByteSizePartial())
2308       self.name_arg_[i].OutputPartial(out)
2309     for i in xrange(len(self.number_arg_)):
2310       out.putVarInt32(34)
2311       out.putVarInt32(self.number_arg_[i].ByteSizePartial())
2312       self.number_arg_[i].OutputPartial(out)
2313
2314   def TryMerge(self, d):
2315     while d.avail() > 0:
2316       tt = d.getVarInt32()
2317       if tt == 10:
2318         self.set_query_string(d.getPrefixedString())
2319         continue
2320       if tt == 16:
2321         self.set_allow_literal(d.getBoolean())
2322         continue
2323       if tt == 26:
2324         length = d.getVarInt32()
2325         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2326         d.skip(length)
2327         self.add_name_arg().TryMerge(tmp)
2328         continue
2329       if tt == 34:
2330         length = d.getVarInt32()
2331         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2332         d.skip(length)
2333         self.add_number_arg().TryMerge(tmp)
2334         continue
2335
2336
2337       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2338       d.skipData(tt)
2339
2340
2341   def __str__(self, prefix="", printElemNumber=0):
2342     res=""
2343     if self.has_query_string_: res+=prefix+("query_string: %s\n" % self.DebugFormatString(self.query_string_))
2344     if self.has_allow_literal_: res+=prefix+("allow_literal: %s\n" % self.DebugFormatBool(self.allow_literal_))
2345     cnt=0
2346     for e in self.name_arg_:
2347       elm=""
2348       if printElemNumber: elm="(%d)" % cnt
2349       res+=prefix+("name_arg%s <\n" % elm)
2350       res+=e.__str__(prefix + "  ", printElemNumber)
2351       res+=prefix+">\n"
2352       cnt+=1
2353     cnt=0
2354     for e in self.number_arg_:
2355       elm=""
2356       if printElemNumber: elm="(%d)" % cnt
2357       res+=prefix+("number_arg%s <\n" % elm)
2358       res+=e.__str__(prefix + "  ", printElemNumber)
2359       res+=prefix+">\n"
2360       cnt+=1
2361     return res
2362
2363
2364   def _BuildTagLookupTable(sparse, maxtag, default=None):
2365     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2366
2367   kquery_string = 1
2368   kallow_literal = 2
2369   kname_arg = 3
2370   knumber_arg = 4
2371
2372   _TEXT = _BuildTagLookupTable({
2373     0: "ErrorCode",
2374     1: "query_string",
2375     2: "allow_literal",
2376     3: "name_arg",
2377     4: "number_arg",
2378   }, 4)
2379
2380   _TYPES = _BuildTagLookupTable({
2381     0: ProtocolBuffer.Encoder.NUMERIC,
2382     1: ProtocolBuffer.Encoder.STRING,
2383     2: ProtocolBuffer.Encoder.NUMERIC,
2384     3: ProtocolBuffer.Encoder.STRING,
2385     4: ProtocolBuffer.Encoder.STRING,
2386   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
2387
2388
2389   _STYLE = """"""
2390   _STYLE_CONTENT_TYPE = """"""
2391   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.GqlQuery'
2392   _SERIALIZED_DESCRIPTOR = array.array('B')
2393   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KIGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkdxbFF1ZXJ5ExoMcXVlcnlfc3RyaW5nIAEoAjAJOAIUExoNYWxsb3dfbGl0ZXJhbCACKAAwCDgBQgVmYWxzZaMBqgEHZGVmYXVsdLIBBWZhbHNlpAEUExoIbmFtZV9hcmcgAygCMAs4A0ojYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuR3FsUXVlcnlBcmejAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoKbnVtYmVyX2FyZyAEKAIwCzgDSiNhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5HcWxRdWVyeUFyZ6MBqgEFY3R5cGWyAQZwcm90bzKkARTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
2394   if _net_proto___parse__python is not None:
2395     _net_proto___parse__python.RegisterType(
2396         _SERIALIZED_DESCRIPTOR.tostring())
2397
2398 class GqlQueryArg(ProtocolBuffer.ProtocolMessage):
2399   has_name_ = 0
2400   name_ = ""
2401   has_value_ = 0
2402   value_ = None
2403   has_cursor_ = 0
2404   cursor_ = ""
2405
2406   def __init__(self, contents=None):
2407     self.lazy_init_lock_ = thread.allocate_lock()
2408     if contents is not None: self.MergeFromString(contents)
2409
2410   def name(self): return self.name_
2411
2412   def set_name(self, x):
2413     self.has_name_ = 1
2414     self.name_ = x
2415
2416   def clear_name(self):
2417     if self.has_name_:
2418       self.has_name_ = 0
2419       self.name_ = ""
2420
2421   def has_name(self): return self.has_name_
2422
2423   def value(self):
2424     if self.value_ is None:
2425       self.lazy_init_lock_.acquire()
2426       try:
2427         if self.value_ is None: self.value_ = google.appengine.datastore.entity_v4_pb.Value()
2428       finally:
2429         self.lazy_init_lock_.release()
2430     return self.value_
2431
2432   def mutable_value(self): self.has_value_ = 1; return self.value()
2433
2434   def clear_value(self):
2435
2436     if self.has_value_:
2437       self.has_value_ = 0;
2438       if self.value_ is not None: self.value_.Clear()
2439
2440   def has_value(self): return self.has_value_
2441
2442   def cursor(self): return self.cursor_
2443
2444   def set_cursor(self, x):
2445     self.has_cursor_ = 1
2446     self.cursor_ = x
2447
2448   def clear_cursor(self):
2449     if self.has_cursor_:
2450       self.has_cursor_ = 0
2451       self.cursor_ = ""
2452
2453   def has_cursor(self): return self.has_cursor_
2454
2455
2456   def MergeFrom(self, x):
2457     assert x is not self
2458     if (x.has_name()): self.set_name(x.name())
2459     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
2460     if (x.has_cursor()): self.set_cursor(x.cursor())
2461
2462   if _net_proto___parse__python is not None:
2463     def _CMergeFromString(self, s):
2464       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.GqlQueryArg', s)
2465
2466   if _net_proto___parse__python is not None:
2467     def _CEncode(self):
2468       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.GqlQueryArg')
2469
2470   if _net_proto___parse__python is not None:
2471     def _CEncodePartial(self):
2472       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.GqlQueryArg')
2473
2474   if _net_proto___parse__python is not None:
2475     def _CToASCII(self, output_format):
2476       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.GqlQueryArg', output_format)
2477
2478
2479   if _net_proto___parse__python is not None:
2480     def ParseASCII(self, s):
2481       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.GqlQueryArg', s)
2482
2483
2484   if _net_proto___parse__python is not None:
2485     def ParseASCIIIgnoreUnknown(self, s):
2486       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.GqlQueryArg', s)
2487
2488
2489   def Equals(self, x):
2490     if x is self: return 1
2491     if self.has_name_ != x.has_name_: return 0
2492     if self.has_name_ and self.name_ != x.name_: return 0
2493     if self.has_value_ != x.has_value_: return 0
2494     if self.has_value_ and self.value_ != x.value_: return 0
2495     if self.has_cursor_ != x.has_cursor_: return 0
2496     if self.has_cursor_ and self.cursor_ != x.cursor_: return 0
2497     return 1
2498
2499   def IsInitialized(self, debug_strs=None):
2500     initialized = 1
2501     if (self.has_value_ and not self.value_.IsInitialized(debug_strs)): initialized = 0
2502     return initialized
2503
2504   def ByteSize(self):
2505     n = 0
2506     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
2507     if (self.has_value_): n += 1 + self.lengthString(self.value_.ByteSize())
2508     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
2509     return n
2510
2511   def ByteSizePartial(self):
2512     n = 0
2513     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
2514     if (self.has_value_): n += 1 + self.lengthString(self.value_.ByteSizePartial())
2515     if (self.has_cursor_): n += 1 + self.lengthString(len(self.cursor_))
2516     return n
2517
2518   def Clear(self):
2519     self.clear_name()
2520     self.clear_value()
2521     self.clear_cursor()
2522
2523   def OutputUnchecked(self, out):
2524     if (self.has_name_):
2525       out.putVarInt32(10)
2526       out.putPrefixedString(self.name_)
2527     if (self.has_value_):
2528       out.putVarInt32(18)
2529       out.putVarInt32(self.value_.ByteSize())
2530       self.value_.OutputUnchecked(out)
2531     if (self.has_cursor_):
2532       out.putVarInt32(26)
2533       out.putPrefixedString(self.cursor_)
2534
2535   def OutputPartial(self, out):
2536     if (self.has_name_):
2537       out.putVarInt32(10)
2538       out.putPrefixedString(self.name_)
2539     if (self.has_value_):
2540       out.putVarInt32(18)
2541       out.putVarInt32(self.value_.ByteSizePartial())
2542       self.value_.OutputPartial(out)
2543     if (self.has_cursor_):
2544       out.putVarInt32(26)
2545       out.putPrefixedString(self.cursor_)
2546
2547   def TryMerge(self, d):
2548     while d.avail() > 0:
2549       tt = d.getVarInt32()
2550       if tt == 10:
2551         self.set_name(d.getPrefixedString())
2552         continue
2553       if tt == 18:
2554         length = d.getVarInt32()
2555         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2556         d.skip(length)
2557         self.mutable_value().TryMerge(tmp)
2558         continue
2559       if tt == 26:
2560         self.set_cursor(d.getPrefixedString())
2561         continue
2562
2563
2564       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2565       d.skipData(tt)
2566
2567
2568   def __str__(self, prefix="", printElemNumber=0):
2569     res=""
2570     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
2571     if self.has_value_:
2572       res+=prefix+"value <\n"
2573       res+=self.value_.__str__(prefix + "  ", printElemNumber)
2574       res+=prefix+">\n"
2575     if self.has_cursor_: res+=prefix+("cursor: %s\n" % self.DebugFormatString(self.cursor_))
2576     return res
2577
2578
2579   def _BuildTagLookupTable(sparse, maxtag, default=None):
2580     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2581
2582   kname = 1
2583   kvalue = 2
2584   kcursor = 3
2585
2586   _TEXT = _BuildTagLookupTable({
2587     0: "ErrorCode",
2588     1: "name",
2589     2: "value",
2590     3: "cursor",
2591   }, 3)
2592
2593   _TYPES = _BuildTagLookupTable({
2594     0: ProtocolBuffer.Encoder.NUMERIC,
2595     1: ProtocolBuffer.Encoder.STRING,
2596     2: ProtocolBuffer.Encoder.STRING,
2597     3: ProtocolBuffer.Encoder.STRING,
2598   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
2599
2600
2601   _STYLE = """"""
2602   _STYLE_CONTENT_TYPE = """"""
2603   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.GqlQueryArg'
2604   _SERIALIZED_DESCRIPTOR = array.array('B')
2605   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KI2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkdxbFF1ZXJ5QXJnExoEbmFtZSABKAIwCTgBFBMaBXZhbHVlIAIoAjALOAFKHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlZhbHVlowGqAQVjdHlwZbIBBnByb3RvMqQBFBMaBmN1cnNvciADKAIwCTgBFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
2606   if _net_proto___parse__python is not None:
2607     _net_proto___parse__python.RegisterType(
2608         _SERIALIZED_DESCRIPTOR.tostring())
2609
2610 class QueryResultBatch(ProtocolBuffer.ProtocolMessage):
2611
2612
2613   NOT_FINISHED =    1
2614   MORE_RESULTS_AFTER_LIMIT =    2
2615   NO_MORE_RESULTS =    3
2616
2617   _MoreResultsType_NAMES = {
2618     1: "NOT_FINISHED",
2619     2: "MORE_RESULTS_AFTER_LIMIT",
2620     3: "NO_MORE_RESULTS",
2621   }
2622
2623   def MoreResultsType_Name(cls, x): return cls._MoreResultsType_NAMES.get(x, "")
2624   MoreResultsType_Name = classmethod(MoreResultsType_Name)
2625
2626   has_entity_result_type_ = 0
2627   entity_result_type_ = 0
2628   has_end_cursor_ = 0
2629   end_cursor_ = ""
2630   has_more_results_ = 0
2631   more_results_ = 0
2632   has_skipped_results_ = 0
2633   skipped_results_ = 0
2634
2635   def __init__(self, contents=None):
2636     self.entity_result_ = []
2637     if contents is not None: self.MergeFromString(contents)
2638
2639   def entity_result_type(self): return self.entity_result_type_
2640
2641   def set_entity_result_type(self, x):
2642     self.has_entity_result_type_ = 1
2643     self.entity_result_type_ = x
2644
2645   def clear_entity_result_type(self):
2646     if self.has_entity_result_type_:
2647       self.has_entity_result_type_ = 0
2648       self.entity_result_type_ = 0
2649
2650   def has_entity_result_type(self): return self.has_entity_result_type_
2651
2652   def entity_result_size(self): return len(self.entity_result_)
2653   def entity_result_list(self): return self.entity_result_
2654
2655   def entity_result(self, i):
2656     return self.entity_result_[i]
2657
2658   def mutable_entity_result(self, i):
2659     return self.entity_result_[i]
2660
2661   def add_entity_result(self):
2662     x = EntityResult()
2663     self.entity_result_.append(x)
2664     return x
2665
2666   def clear_entity_result(self):
2667     self.entity_result_ = []
2668   def end_cursor(self): return self.end_cursor_
2669
2670   def set_end_cursor(self, x):
2671     self.has_end_cursor_ = 1
2672     self.end_cursor_ = x
2673
2674   def clear_end_cursor(self):
2675     if self.has_end_cursor_:
2676       self.has_end_cursor_ = 0
2677       self.end_cursor_ = ""
2678
2679   def has_end_cursor(self): return self.has_end_cursor_
2680
2681   def more_results(self): return self.more_results_
2682
2683   def set_more_results(self, x):
2684     self.has_more_results_ = 1
2685     self.more_results_ = x
2686
2687   def clear_more_results(self):
2688     if self.has_more_results_:
2689       self.has_more_results_ = 0
2690       self.more_results_ = 0
2691
2692   def has_more_results(self): return self.has_more_results_
2693
2694   def skipped_results(self): return self.skipped_results_
2695
2696   def set_skipped_results(self, x):
2697     self.has_skipped_results_ = 1
2698     self.skipped_results_ = x
2699
2700   def clear_skipped_results(self):
2701     if self.has_skipped_results_:
2702       self.has_skipped_results_ = 0
2703       self.skipped_results_ = 0
2704
2705   def has_skipped_results(self): return self.has_skipped_results_
2706
2707
2708   def MergeFrom(self, x):
2709     assert x is not self
2710     if (x.has_entity_result_type()): self.set_entity_result_type(x.entity_result_type())
2711     for i in xrange(x.entity_result_size()): self.add_entity_result().CopyFrom(x.entity_result(i))
2712     if (x.has_end_cursor()): self.set_end_cursor(x.end_cursor())
2713     if (x.has_more_results()): self.set_more_results(x.more_results())
2714     if (x.has_skipped_results()): self.set_skipped_results(x.skipped_results())
2715
2716   if _net_proto___parse__python is not None:
2717     def _CMergeFromString(self, s):
2718       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.QueryResultBatch', s)
2719
2720   if _net_proto___parse__python is not None:
2721     def _CEncode(self):
2722       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.QueryResultBatch')
2723
2724   if _net_proto___parse__python is not None:
2725     def _CEncodePartial(self):
2726       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.QueryResultBatch')
2727
2728   if _net_proto___parse__python is not None:
2729     def _CToASCII(self, output_format):
2730       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.QueryResultBatch', output_format)
2731
2732
2733   if _net_proto___parse__python is not None:
2734     def ParseASCII(self, s):
2735       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.QueryResultBatch', s)
2736
2737
2738   if _net_proto___parse__python is not None:
2739     def ParseASCIIIgnoreUnknown(self, s):
2740       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.QueryResultBatch', s)
2741
2742
2743   def Equals(self, x):
2744     if x is self: return 1
2745     if self.has_entity_result_type_ != x.has_entity_result_type_: return 0
2746     if self.has_entity_result_type_ and self.entity_result_type_ != x.entity_result_type_: return 0
2747     if len(self.entity_result_) != len(x.entity_result_): return 0
2748     for e1, e2 in zip(self.entity_result_, x.entity_result_):
2749       if e1 != e2: return 0
2750     if self.has_end_cursor_ != x.has_end_cursor_: return 0
2751     if self.has_end_cursor_ and self.end_cursor_ != x.end_cursor_: return 0
2752     if self.has_more_results_ != x.has_more_results_: return 0
2753     if self.has_more_results_ and self.more_results_ != x.more_results_: return 0
2754     if self.has_skipped_results_ != x.has_skipped_results_: return 0
2755     if self.has_skipped_results_ and self.skipped_results_ != x.skipped_results_: return 0
2756     return 1
2757
2758   def IsInitialized(self, debug_strs=None):
2759     initialized = 1
2760     if (not self.has_entity_result_type_):
2761       initialized = 0
2762       if debug_strs is not None:
2763         debug_strs.append('Required field: entity_result_type not set.')
2764     for p in self.entity_result_:
2765       if not p.IsInitialized(debug_strs): initialized=0
2766     if (not self.has_more_results_):
2767       initialized = 0
2768       if debug_strs is not None:
2769         debug_strs.append('Required field: more_results not set.')
2770     return initialized
2771
2772   def ByteSize(self):
2773     n = 0
2774     n += self.lengthVarInt64(self.entity_result_type_)
2775     n += 1 * len(self.entity_result_)
2776     for i in xrange(len(self.entity_result_)): n += self.lengthString(self.entity_result_[i].ByteSize())
2777     if (self.has_end_cursor_): n += 1 + self.lengthString(len(self.end_cursor_))
2778     n += self.lengthVarInt64(self.more_results_)
2779     if (self.has_skipped_results_): n += 1 + self.lengthVarInt64(self.skipped_results_)
2780     return n + 2
2781
2782   def ByteSizePartial(self):
2783     n = 0
2784     if (self.has_entity_result_type_):
2785       n += 1
2786       n += self.lengthVarInt64(self.entity_result_type_)
2787     n += 1 * len(self.entity_result_)
2788     for i in xrange(len(self.entity_result_)): n += self.lengthString(self.entity_result_[i].ByteSizePartial())
2789     if (self.has_end_cursor_): n += 1 + self.lengthString(len(self.end_cursor_))
2790     if (self.has_more_results_):
2791       n += 1
2792       n += self.lengthVarInt64(self.more_results_)
2793     if (self.has_skipped_results_): n += 1 + self.lengthVarInt64(self.skipped_results_)
2794     return n
2795
2796   def Clear(self):
2797     self.clear_entity_result_type()
2798     self.clear_entity_result()
2799     self.clear_end_cursor()
2800     self.clear_more_results()
2801     self.clear_skipped_results()
2802
2803   def OutputUnchecked(self, out):
2804     out.putVarInt32(8)
2805     out.putVarInt32(self.entity_result_type_)
2806     for i in xrange(len(self.entity_result_)):
2807       out.putVarInt32(18)
2808       out.putVarInt32(self.entity_result_[i].ByteSize())
2809       self.entity_result_[i].OutputUnchecked(out)
2810     if (self.has_end_cursor_):
2811       out.putVarInt32(34)
2812       out.putPrefixedString(self.end_cursor_)
2813     out.putVarInt32(40)
2814     out.putVarInt32(self.more_results_)
2815     if (self.has_skipped_results_):
2816       out.putVarInt32(48)
2817       out.putVarInt32(self.skipped_results_)
2818
2819   def OutputPartial(self, out):
2820     if (self.has_entity_result_type_):
2821       out.putVarInt32(8)
2822       out.putVarInt32(self.entity_result_type_)
2823     for i in xrange(len(self.entity_result_)):
2824       out.putVarInt32(18)
2825       out.putVarInt32(self.entity_result_[i].ByteSizePartial())
2826       self.entity_result_[i].OutputPartial(out)
2827     if (self.has_end_cursor_):
2828       out.putVarInt32(34)
2829       out.putPrefixedString(self.end_cursor_)
2830     if (self.has_more_results_):
2831       out.putVarInt32(40)
2832       out.putVarInt32(self.more_results_)
2833     if (self.has_skipped_results_):
2834       out.putVarInt32(48)
2835       out.putVarInt32(self.skipped_results_)
2836
2837   def TryMerge(self, d):
2838     while d.avail() > 0:
2839       tt = d.getVarInt32()
2840       if tt == 8:
2841         self.set_entity_result_type(d.getVarInt32())
2842         continue
2843       if tt == 18:
2844         length = d.getVarInt32()
2845         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2846         d.skip(length)
2847         self.add_entity_result().TryMerge(tmp)
2848         continue
2849       if tt == 34:
2850         self.set_end_cursor(d.getPrefixedString())
2851         continue
2852       if tt == 40:
2853         self.set_more_results(d.getVarInt32())
2854         continue
2855       if tt == 48:
2856         self.set_skipped_results(d.getVarInt32())
2857         continue
2858
2859
2860       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2861       d.skipData(tt)
2862
2863
2864   def __str__(self, prefix="", printElemNumber=0):
2865     res=""
2866     if self.has_entity_result_type_: res+=prefix+("entity_result_type: %s\n" % self.DebugFormatInt32(self.entity_result_type_))
2867     cnt=0
2868     for e in self.entity_result_:
2869       elm=""
2870       if printElemNumber: elm="(%d)" % cnt
2871       res+=prefix+("entity_result%s <\n" % elm)
2872       res+=e.__str__(prefix + "  ", printElemNumber)
2873       res+=prefix+">\n"
2874       cnt+=1
2875     if self.has_end_cursor_: res+=prefix+("end_cursor: %s\n" % self.DebugFormatString(self.end_cursor_))
2876     if self.has_more_results_: res+=prefix+("more_results: %s\n" % self.DebugFormatInt32(self.more_results_))
2877     if self.has_skipped_results_: res+=prefix+("skipped_results: %s\n" % self.DebugFormatInt32(self.skipped_results_))
2878     return res
2879
2880
2881   def _BuildTagLookupTable(sparse, maxtag, default=None):
2882     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2883
2884   kentity_result_type = 1
2885   kentity_result = 2
2886   kend_cursor = 4
2887   kmore_results = 5
2888   kskipped_results = 6
2889
2890   _TEXT = _BuildTagLookupTable({
2891     0: "ErrorCode",
2892     1: "entity_result_type",
2893     2: "entity_result",
2894     4: "end_cursor",
2895     5: "more_results",
2896     6: "skipped_results",
2897   }, 6)
2898
2899   _TYPES = _BuildTagLookupTable({
2900     0: ProtocolBuffer.Encoder.NUMERIC,
2901     1: ProtocolBuffer.Encoder.NUMERIC,
2902     2: ProtocolBuffer.Encoder.STRING,
2903     4: ProtocolBuffer.Encoder.STRING,
2904     5: ProtocolBuffer.Encoder.NUMERIC,
2905     6: ProtocolBuffer.Encoder.NUMERIC,
2906   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
2907
2908
2909   _STYLE = """"""
2910   _STYLE_CONTENT_TYPE = """"""
2911   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.QueryResultBatch'
2912   _SERIALIZED_DESCRIPTOR = array.array('B')
2913   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KKGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlF1ZXJ5UmVzdWx0QmF0Y2gTGhJlbnRpdHlfcmVzdWx0X3R5cGUgASgAMAU4AhQTGg1lbnRpdHlfcmVzdWx0IAIoAjALOANKJGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVudGl0eVJlc3VsdKMBqgEFY3R5cGWyAQZwcm90bzKkARQTGgplbmRfY3Vyc29yIAQoAjAJOAEUExoMbW9yZV9yZXN1bHRzIAUoADAFOAJoABQTGg9za2lwcGVkX3Jlc3VsdHMgBigAMAU4AUIBMKMBqgEHZGVmYXVsdLIBATCkARRzeg9Nb3JlUmVzdWx0c1R5cGWLAZIBDE5PVF9GSU5JU0hFRJgBAYwBiwGSARhNT1JFX1JFU1VMVFNfQUZURVJfTElNSVSYAQKMAYsBkgEPTk9fTU9SRV9SRVNVTFRTmAEDjAF0wgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
2914   if _net_proto___parse__python is not None:
2915     _net_proto___parse__python.RegisterType(
2916         _SERIALIZED_DESCRIPTOR.tostring())
2917
2918 class Mutation(ProtocolBuffer.ProtocolMessage):
2919
2920
2921   INSERT       =    1
2922   UPDATE       =    2
2923   UPSERT       =    3
2924   DELETE       =    4
2925
2926   _Operation_NAMES = {
2927     1: "INSERT",
2928     2: "UPDATE",
2929     3: "UPSERT",
2930     4: "DELETE",
2931   }
2932
2933   def Operation_Name(cls, x): return cls._Operation_NAMES.get(x, "")
2934   Operation_Name = classmethod(Operation_Name)
2935
2936   has_op_ = 0
2937   op_ = 0
2938   has_key_ = 0
2939   key_ = None
2940   has_entity_ = 0
2941   entity_ = None
2942
2943   def __init__(self, contents=None):
2944     self.lazy_init_lock_ = thread.allocate_lock()
2945     if contents is not None: self.MergeFromString(contents)
2946
2947   def op(self): return self.op_
2948
2949   def set_op(self, x):
2950     self.has_op_ = 1
2951     self.op_ = x
2952
2953   def clear_op(self):
2954     if self.has_op_:
2955       self.has_op_ = 0
2956       self.op_ = 0
2957
2958   def has_op(self): return self.has_op_
2959
2960   def key(self):
2961     if self.key_ is None:
2962       self.lazy_init_lock_.acquire()
2963       try:
2964         if self.key_ is None: self.key_ = google.appengine.datastore.entity_v4_pb.Key()
2965       finally:
2966         self.lazy_init_lock_.release()
2967     return self.key_
2968
2969   def mutable_key(self): self.has_key_ = 1; return self.key()
2970
2971   def clear_key(self):
2972
2973     if self.has_key_:
2974       self.has_key_ = 0;
2975       if self.key_ is not None: self.key_.Clear()
2976
2977   def has_key(self): return self.has_key_
2978
2979   def entity(self):
2980     if self.entity_ is None:
2981       self.lazy_init_lock_.acquire()
2982       try:
2983         if self.entity_ is None: self.entity_ = google.appengine.datastore.entity_v4_pb.Entity()
2984       finally:
2985         self.lazy_init_lock_.release()
2986     return self.entity_
2987
2988   def mutable_entity(self): self.has_entity_ = 1; return self.entity()
2989
2990   def clear_entity(self):
2991
2992     if self.has_entity_:
2993       self.has_entity_ = 0;
2994       if self.entity_ is not None: self.entity_.Clear()
2995
2996   def has_entity(self): return self.has_entity_
2997
2998
2999   def MergeFrom(self, x):
3000     assert x is not self
3001     if (x.has_op()): self.set_op(x.op())
3002     if (x.has_key()): self.mutable_key().MergeFrom(x.key())
3003     if (x.has_entity()): self.mutable_entity().MergeFrom(x.entity())
3004
3005   if _net_proto___parse__python is not None:
3006     def _CMergeFromString(self, s):
3007       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Mutation', s)
3008
3009   if _net_proto___parse__python is not None:
3010     def _CEncode(self):
3011       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Mutation')
3012
3013   if _net_proto___parse__python is not None:
3014     def _CEncodePartial(self):
3015       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Mutation')
3016
3017   if _net_proto___parse__python is not None:
3018     def _CToASCII(self, output_format):
3019       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Mutation', output_format)
3020
3021
3022   if _net_proto___parse__python is not None:
3023     def ParseASCII(self, s):
3024       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Mutation', s)
3025
3026
3027   if _net_proto___parse__python is not None:
3028     def ParseASCIIIgnoreUnknown(self, s):
3029       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Mutation', s)
3030
3031
3032   def Equals(self, x):
3033     if x is self: return 1
3034     if self.has_op_ != x.has_op_: return 0
3035     if self.has_op_ and self.op_ != x.op_: return 0
3036     if self.has_key_ != x.has_key_: return 0
3037     if self.has_key_ and self.key_ != x.key_: return 0
3038     if self.has_entity_ != x.has_entity_: return 0
3039     if self.has_entity_ and self.entity_ != x.entity_: return 0
3040     return 1
3041
3042   def IsInitialized(self, debug_strs=None):
3043     initialized = 1
3044     if (not self.has_op_):
3045       initialized = 0
3046       if debug_strs is not None:
3047         debug_strs.append('Required field: op not set.')
3048     if (self.has_key_ and not self.key_.IsInitialized(debug_strs)): initialized = 0
3049     if (self.has_entity_ and not self.entity_.IsInitialized(debug_strs)): initialized = 0
3050     return initialized
3051
3052   def ByteSize(self):
3053     n = 0
3054     n += self.lengthVarInt64(self.op_)
3055     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSize())
3056     if (self.has_entity_): n += 1 + self.lengthString(self.entity_.ByteSize())
3057     return n + 1
3058
3059   def ByteSizePartial(self):
3060     n = 0
3061     if (self.has_op_):
3062       n += 1
3063       n += self.lengthVarInt64(self.op_)
3064     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSizePartial())
3065     if (self.has_entity_): n += 1 + self.lengthString(self.entity_.ByteSizePartial())
3066     return n
3067
3068   def Clear(self):
3069     self.clear_op()
3070     self.clear_key()
3071     self.clear_entity()
3072
3073   def OutputUnchecked(self, out):
3074     out.putVarInt32(8)
3075     out.putVarInt32(self.op_)
3076     if (self.has_key_):
3077       out.putVarInt32(18)
3078       out.putVarInt32(self.key_.ByteSize())
3079       self.key_.OutputUnchecked(out)
3080     if (self.has_entity_):
3081       out.putVarInt32(26)
3082       out.putVarInt32(self.entity_.ByteSize())
3083       self.entity_.OutputUnchecked(out)
3084
3085   def OutputPartial(self, out):
3086     if (self.has_op_):
3087       out.putVarInt32(8)
3088       out.putVarInt32(self.op_)
3089     if (self.has_key_):
3090       out.putVarInt32(18)
3091       out.putVarInt32(self.key_.ByteSizePartial())
3092       self.key_.OutputPartial(out)
3093     if (self.has_entity_):
3094       out.putVarInt32(26)
3095       out.putVarInt32(self.entity_.ByteSizePartial())
3096       self.entity_.OutputPartial(out)
3097
3098   def TryMerge(self, d):
3099     while d.avail() > 0:
3100       tt = d.getVarInt32()
3101       if tt == 8:
3102         self.set_op(d.getVarInt32())
3103         continue
3104       if tt == 18:
3105         length = d.getVarInt32()
3106         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3107         d.skip(length)
3108         self.mutable_key().TryMerge(tmp)
3109         continue
3110       if tt == 26:
3111         length = d.getVarInt32()
3112         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3113         d.skip(length)
3114         self.mutable_entity().TryMerge(tmp)
3115         continue
3116
3117
3118       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3119       d.skipData(tt)
3120
3121
3122   def __str__(self, prefix="", printElemNumber=0):
3123     res=""
3124     if self.has_op_: res+=prefix+("op: %s\n" % self.DebugFormatInt32(self.op_))
3125     if self.has_key_:
3126       res+=prefix+"key <\n"
3127       res+=self.key_.__str__(prefix + "  ", printElemNumber)
3128       res+=prefix+">\n"
3129     if self.has_entity_:
3130       res+=prefix+"entity <\n"
3131       res+=self.entity_.__str__(prefix + "  ", printElemNumber)
3132       res+=prefix+">\n"
3133     return res
3134
3135
3136   def _BuildTagLookupTable(sparse, maxtag, default=None):
3137     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3138
3139   kop = 1
3140   kkey = 2
3141   kentity = 3
3142
3143   _TEXT = _BuildTagLookupTable({
3144     0: "ErrorCode",
3145     1: "op",
3146     2: "key",
3147     3: "entity",
3148   }, 3)
3149
3150   _TYPES = _BuildTagLookupTable({
3151     0: ProtocolBuffer.Encoder.NUMERIC,
3152     1: ProtocolBuffer.Encoder.NUMERIC,
3153     2: ProtocolBuffer.Encoder.STRING,
3154     3: ProtocolBuffer.Encoder.STRING,
3155   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
3156
3157
3158   _STYLE = """"""
3159   _STYLE_CONTENT_TYPE = """"""
3160   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Mutation'
3161   _SERIALIZED_DESCRIPTOR = array.array('B')
3162   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KIGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0Lk11dGF0aW9uExoCb3AgASgAMAU4AmgAFBMaA2tleSACKAIwCzgBShthcHBob3N0aW5nLmRhdGFzdG9yZS52NC5LZXmjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoGZW50aXR5IAMoAjALOAFKHmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVudGl0eaMBqgEFY3R5cGWyAQZwcm90bzKkARRzeglPcGVyYXRpb26LAZIBBklOU0VSVJgBAYwBiwGSAQZVUERBVEWYAQKMAYsBkgEGVVBTRVJUmAEDjAGLAZIBBkRFTEVURZgBBIwBdMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
3163   if _net_proto___parse__python is not None:
3164     _net_proto___parse__python.RegisterType(
3165         _SERIALIZED_DESCRIPTOR.tostring())
3166
3167 class MutationResult(ProtocolBuffer.ProtocolMessage):
3168   has_key_ = 0
3169   key_ = None
3170   has_new_version_ = 0
3171   new_version_ = 0
3172
3173   def __init__(self, contents=None):
3174     self.lazy_init_lock_ = thread.allocate_lock()
3175     if contents is not None: self.MergeFromString(contents)
3176
3177   def key(self):
3178     if self.key_ is None:
3179       self.lazy_init_lock_.acquire()
3180       try:
3181         if self.key_ is None: self.key_ = google.appengine.datastore.entity_v4_pb.Key()
3182       finally:
3183         self.lazy_init_lock_.release()
3184     return self.key_
3185
3186   def mutable_key(self): self.has_key_ = 1; return self.key()
3187
3188   def clear_key(self):
3189
3190     if self.has_key_:
3191       self.has_key_ = 0;
3192       if self.key_ is not None: self.key_.Clear()
3193
3194   def has_key(self): return self.has_key_
3195
3196   def new_version(self): return self.new_version_
3197
3198   def set_new_version(self, x):
3199     self.has_new_version_ = 1
3200     self.new_version_ = x
3201
3202   def clear_new_version(self):
3203     if self.has_new_version_:
3204       self.has_new_version_ = 0
3205       self.new_version_ = 0
3206
3207   def has_new_version(self): return self.has_new_version_
3208
3209
3210   def MergeFrom(self, x):
3211     assert x is not self
3212     if (x.has_key()): self.mutable_key().MergeFrom(x.key())
3213     if (x.has_new_version()): self.set_new_version(x.new_version())
3214
3215   if _net_proto___parse__python is not None:
3216     def _CMergeFromString(self, s):
3217       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.MutationResult', s)
3218
3219   if _net_proto___parse__python is not None:
3220     def _CEncode(self):
3221       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.MutationResult')
3222
3223   if _net_proto___parse__python is not None:
3224     def _CEncodePartial(self):
3225       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.MutationResult')
3226
3227   if _net_proto___parse__python is not None:
3228     def _CToASCII(self, output_format):
3229       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.MutationResult', output_format)
3230
3231
3232   if _net_proto___parse__python is not None:
3233     def ParseASCII(self, s):
3234       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.MutationResult', s)
3235
3236
3237   if _net_proto___parse__python is not None:
3238     def ParseASCIIIgnoreUnknown(self, s):
3239       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.MutationResult', s)
3240
3241
3242   def Equals(self, x):
3243     if x is self: return 1
3244     if self.has_key_ != x.has_key_: return 0
3245     if self.has_key_ and self.key_ != x.key_: return 0
3246     if self.has_new_version_ != x.has_new_version_: return 0
3247     if self.has_new_version_ and self.new_version_ != x.new_version_: return 0
3248     return 1
3249
3250   def IsInitialized(self, debug_strs=None):
3251     initialized = 1
3252     if (self.has_key_ and not self.key_.IsInitialized(debug_strs)): initialized = 0
3253     return initialized
3254
3255   def ByteSize(self):
3256     n = 0
3257     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSize())
3258     if (self.has_new_version_): n += 1 + self.lengthVarInt64(self.new_version_)
3259     return n
3260
3261   def ByteSizePartial(self):
3262     n = 0
3263     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSizePartial())
3264     if (self.has_new_version_): n += 1 + self.lengthVarInt64(self.new_version_)
3265     return n
3266
3267   def Clear(self):
3268     self.clear_key()
3269     self.clear_new_version()
3270
3271   def OutputUnchecked(self, out):
3272     if (self.has_key_):
3273       out.putVarInt32(26)
3274       out.putVarInt32(self.key_.ByteSize())
3275       self.key_.OutputUnchecked(out)
3276     if (self.has_new_version_):
3277       out.putVarInt32(32)
3278       out.putVarInt64(self.new_version_)
3279
3280   def OutputPartial(self, out):
3281     if (self.has_key_):
3282       out.putVarInt32(26)
3283       out.putVarInt32(self.key_.ByteSizePartial())
3284       self.key_.OutputPartial(out)
3285     if (self.has_new_version_):
3286       out.putVarInt32(32)
3287       out.putVarInt64(self.new_version_)
3288
3289   def TryMerge(self, d):
3290     while d.avail() > 0:
3291       tt = d.getVarInt32()
3292       if tt == 26:
3293         length = d.getVarInt32()
3294         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3295         d.skip(length)
3296         self.mutable_key().TryMerge(tmp)
3297         continue
3298       if tt == 32:
3299         self.set_new_version(d.getVarInt64())
3300         continue
3301
3302
3303       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3304       d.skipData(tt)
3305
3306
3307   def __str__(self, prefix="", printElemNumber=0):
3308     res=""
3309     if self.has_key_:
3310       res+=prefix+"key <\n"
3311       res+=self.key_.__str__(prefix + "  ", printElemNumber)
3312       res+=prefix+">\n"
3313     if self.has_new_version_: res+=prefix+("new_version: %s\n" % self.DebugFormatInt64(self.new_version_))
3314     return res
3315
3316
3317   def _BuildTagLookupTable(sparse, maxtag, default=None):
3318     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3319
3320   kkey = 3
3321   knew_version = 4
3322
3323   _TEXT = _BuildTagLookupTable({
3324     0: "ErrorCode",
3325     3: "key",
3326     4: "new_version",
3327   }, 4)
3328
3329   _TYPES = _BuildTagLookupTable({
3330     0: ProtocolBuffer.Encoder.NUMERIC,
3331     3: ProtocolBuffer.Encoder.STRING,
3332     4: ProtocolBuffer.Encoder.NUMERIC,
3333   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
3334
3335
3336   _STYLE = """"""
3337   _STYLE_CONTENT_TYPE = """"""
3338   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.MutationResult'
3339   _SERIALIZED_DESCRIPTOR = array.array('B')
3340   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0Lk11dGF0aW9uUmVzdWx0ExoDa2V5IAMoAjALOAFKG2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleaMBqgEFY3R5cGWyAQZwcm90bzKkARQTGgtuZXdfdmVyc2lvbiAEKAAwAzgBQgEwowGqAQdkZWZhdWx0sgEBMKQBFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
3341   if _net_proto___parse__python is not None:
3342     _net_proto___parse__python.RegisterType(
3343         _SERIALIZED_DESCRIPTOR.tostring())
3344
3345 class DeprecatedMutation(ProtocolBuffer.ProtocolMessage):
3346   has_force_ = 0
3347   force_ = 0
3348
3349   def __init__(self, contents=None):
3350     self.upsert_ = []
3351     self.update_ = []
3352     self.insert_ = []
3353     self.insert_auto_id_ = []
3354     self.delete_ = []
3355     if contents is not None: self.MergeFromString(contents)
3356
3357   def upsert_size(self): return len(self.upsert_)
3358   def upsert_list(self): return self.upsert_
3359
3360   def upsert(self, i):
3361     return self.upsert_[i]
3362
3363   def mutable_upsert(self, i):
3364     return self.upsert_[i]
3365
3366   def add_upsert(self):
3367     x = google.appengine.datastore.entity_v4_pb.Entity()
3368     self.upsert_.append(x)
3369     return x
3370
3371   def clear_upsert(self):
3372     self.upsert_ = []
3373   def update_size(self): return len(self.update_)
3374   def update_list(self): return self.update_
3375
3376   def update(self, i):
3377     return self.update_[i]
3378
3379   def mutable_update(self, i):
3380     return self.update_[i]
3381
3382   def add_update(self):
3383     x = google.appengine.datastore.entity_v4_pb.Entity()
3384     self.update_.append(x)
3385     return x
3386
3387   def clear_update(self):
3388     self.update_ = []
3389   def insert_size(self): return len(self.insert_)
3390   def insert_list(self): return self.insert_
3391
3392   def insert(self, i):
3393     return self.insert_[i]
3394
3395   def mutable_insert(self, i):
3396     return self.insert_[i]
3397
3398   def add_insert(self):
3399     x = google.appengine.datastore.entity_v4_pb.Entity()
3400     self.insert_.append(x)
3401     return x
3402
3403   def clear_insert(self):
3404     self.insert_ = []
3405   def insert_auto_id_size(self): return len(self.insert_auto_id_)
3406   def insert_auto_id_list(self): return self.insert_auto_id_
3407
3408   def insert_auto_id(self, i):
3409     return self.insert_auto_id_[i]
3410
3411   def mutable_insert_auto_id(self, i):
3412     return self.insert_auto_id_[i]
3413
3414   def add_insert_auto_id(self):
3415     x = google.appengine.datastore.entity_v4_pb.Entity()
3416     self.insert_auto_id_.append(x)
3417     return x
3418
3419   def clear_insert_auto_id(self):
3420     self.insert_auto_id_ = []
3421   def delete_size(self): return len(self.delete_)
3422   def delete_list(self): return self.delete_
3423
3424   def delete(self, i):
3425     return self.delete_[i]
3426
3427   def mutable_delete(self, i):
3428     return self.delete_[i]
3429
3430   def add_delete(self):
3431     x = google.appengine.datastore.entity_v4_pb.Key()
3432     self.delete_.append(x)
3433     return x
3434
3435   def clear_delete(self):
3436     self.delete_ = []
3437   def force(self): return self.force_
3438
3439   def set_force(self, x):
3440     self.has_force_ = 1
3441     self.force_ = x
3442
3443   def clear_force(self):
3444     if self.has_force_:
3445       self.has_force_ = 0
3446       self.force_ = 0
3447
3448   def has_force(self): return self.has_force_
3449
3450
3451   def MergeFrom(self, x):
3452     assert x is not self
3453     for i in xrange(x.upsert_size()): self.add_upsert().CopyFrom(x.upsert(i))
3454     for i in xrange(x.update_size()): self.add_update().CopyFrom(x.update(i))
3455     for i in xrange(x.insert_size()): self.add_insert().CopyFrom(x.insert(i))
3456     for i in xrange(x.insert_auto_id_size()): self.add_insert_auto_id().CopyFrom(x.insert_auto_id(i))
3457     for i in xrange(x.delete_size()): self.add_delete().CopyFrom(x.delete(i))
3458     if (x.has_force()): self.set_force(x.force())
3459
3460   if _net_proto___parse__python is not None:
3461     def _CMergeFromString(self, s):
3462       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.DeprecatedMutation', s)
3463
3464   if _net_proto___parse__python is not None:
3465     def _CEncode(self):
3466       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.DeprecatedMutation')
3467
3468   if _net_proto___parse__python is not None:
3469     def _CEncodePartial(self):
3470       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.DeprecatedMutation')
3471
3472   if _net_proto___parse__python is not None:
3473     def _CToASCII(self, output_format):
3474       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.DeprecatedMutation', output_format)
3475
3476
3477   if _net_proto___parse__python is not None:
3478     def ParseASCII(self, s):
3479       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.DeprecatedMutation', s)
3480
3481
3482   if _net_proto___parse__python is not None:
3483     def ParseASCIIIgnoreUnknown(self, s):
3484       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.DeprecatedMutation', s)
3485
3486
3487   def Equals(self, x):
3488     if x is self: return 1
3489     if len(self.upsert_) != len(x.upsert_): return 0
3490     for e1, e2 in zip(self.upsert_, x.upsert_):
3491       if e1 != e2: return 0
3492     if len(self.update_) != len(x.update_): return 0
3493     for e1, e2 in zip(self.update_, x.update_):
3494       if e1 != e2: return 0
3495     if len(self.insert_) != len(x.insert_): return 0
3496     for e1, e2 in zip(self.insert_, x.insert_):
3497       if e1 != e2: return 0
3498     if len(self.insert_auto_id_) != len(x.insert_auto_id_): return 0
3499     for e1, e2 in zip(self.insert_auto_id_, x.insert_auto_id_):
3500       if e1 != e2: return 0
3501     if len(self.delete_) != len(x.delete_): return 0
3502     for e1, e2 in zip(self.delete_, x.delete_):
3503       if e1 != e2: return 0
3504     if self.has_force_ != x.has_force_: return 0
3505     if self.has_force_ and self.force_ != x.force_: return 0
3506     return 1
3507
3508   def IsInitialized(self, debug_strs=None):
3509     initialized = 1
3510     for p in self.upsert_:
3511       if not p.IsInitialized(debug_strs): initialized=0
3512     for p in self.update_:
3513       if not p.IsInitialized(debug_strs): initialized=0
3514     for p in self.insert_:
3515       if not p.IsInitialized(debug_strs): initialized=0
3516     for p in self.insert_auto_id_:
3517       if not p.IsInitialized(debug_strs): initialized=0
3518     for p in self.delete_:
3519       if not p.IsInitialized(debug_strs): initialized=0
3520     return initialized
3521
3522   def ByteSize(self):
3523     n = 0
3524     n += 1 * len(self.upsert_)
3525     for i in xrange(len(self.upsert_)): n += self.lengthString(self.upsert_[i].ByteSize())
3526     n += 1 * len(self.update_)
3527     for i in xrange(len(self.update_)): n += self.lengthString(self.update_[i].ByteSize())
3528     n += 1 * len(self.insert_)
3529     for i in xrange(len(self.insert_)): n += self.lengthString(self.insert_[i].ByteSize())
3530     n += 1 * len(self.insert_auto_id_)
3531     for i in xrange(len(self.insert_auto_id_)): n += self.lengthString(self.insert_auto_id_[i].ByteSize())
3532     n += 1 * len(self.delete_)
3533     for i in xrange(len(self.delete_)): n += self.lengthString(self.delete_[i].ByteSize())
3534     if (self.has_force_): n += 2
3535     return n
3536
3537   def ByteSizePartial(self):
3538     n = 0
3539     n += 1 * len(self.upsert_)
3540     for i in xrange(len(self.upsert_)): n += self.lengthString(self.upsert_[i].ByteSizePartial())
3541     n += 1 * len(self.update_)
3542     for i in xrange(len(self.update_)): n += self.lengthString(self.update_[i].ByteSizePartial())
3543     n += 1 * len(self.insert_)
3544     for i in xrange(len(self.insert_)): n += self.lengthString(self.insert_[i].ByteSizePartial())
3545     n += 1 * len(self.insert_auto_id_)
3546     for i in xrange(len(self.insert_auto_id_)): n += self.lengthString(self.insert_auto_id_[i].ByteSizePartial())
3547     n += 1 * len(self.delete_)
3548     for i in xrange(len(self.delete_)): n += self.lengthString(self.delete_[i].ByteSizePartial())
3549     if (self.has_force_): n += 2
3550     return n
3551
3552   def Clear(self):
3553     self.clear_upsert()
3554     self.clear_update()
3555     self.clear_insert()
3556     self.clear_insert_auto_id()
3557     self.clear_delete()
3558     self.clear_force()
3559
3560   def OutputUnchecked(self, out):
3561     for i in xrange(len(self.upsert_)):
3562       out.putVarInt32(10)
3563       out.putVarInt32(self.upsert_[i].ByteSize())
3564       self.upsert_[i].OutputUnchecked(out)
3565     for i in xrange(len(self.update_)):
3566       out.putVarInt32(18)
3567       out.putVarInt32(self.update_[i].ByteSize())
3568       self.update_[i].OutputUnchecked(out)
3569     for i in xrange(len(self.insert_)):
3570       out.putVarInt32(26)
3571       out.putVarInt32(self.insert_[i].ByteSize())
3572       self.insert_[i].OutputUnchecked(out)
3573     for i in xrange(len(self.insert_auto_id_)):
3574       out.putVarInt32(34)
3575       out.putVarInt32(self.insert_auto_id_[i].ByteSize())
3576       self.insert_auto_id_[i].OutputUnchecked(out)
3577     for i in xrange(len(self.delete_)):
3578       out.putVarInt32(42)
3579       out.putVarInt32(self.delete_[i].ByteSize())
3580       self.delete_[i].OutputUnchecked(out)
3581     if (self.has_force_):
3582       out.putVarInt32(48)
3583       out.putBoolean(self.force_)
3584
3585   def OutputPartial(self, out):
3586     for i in xrange(len(self.upsert_)):
3587       out.putVarInt32(10)
3588       out.putVarInt32(self.upsert_[i].ByteSizePartial())
3589       self.upsert_[i].OutputPartial(out)
3590     for i in xrange(len(self.update_)):
3591       out.putVarInt32(18)
3592       out.putVarInt32(self.update_[i].ByteSizePartial())
3593       self.update_[i].OutputPartial(out)
3594     for i in xrange(len(self.insert_)):
3595       out.putVarInt32(26)
3596       out.putVarInt32(self.insert_[i].ByteSizePartial())
3597       self.insert_[i].OutputPartial(out)
3598     for i in xrange(len(self.insert_auto_id_)):
3599       out.putVarInt32(34)
3600       out.putVarInt32(self.insert_auto_id_[i].ByteSizePartial())
3601       self.insert_auto_id_[i].OutputPartial(out)
3602     for i in xrange(len(self.delete_)):
3603       out.putVarInt32(42)
3604       out.putVarInt32(self.delete_[i].ByteSizePartial())
3605       self.delete_[i].OutputPartial(out)
3606     if (self.has_force_):
3607       out.putVarInt32(48)
3608       out.putBoolean(self.force_)
3609
3610   def TryMerge(self, d):
3611     while d.avail() > 0:
3612       tt = d.getVarInt32()
3613       if tt == 10:
3614         length = d.getVarInt32()
3615         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3616         d.skip(length)
3617         self.add_upsert().TryMerge(tmp)
3618         continue
3619       if tt == 18:
3620         length = d.getVarInt32()
3621         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3622         d.skip(length)
3623         self.add_update().TryMerge(tmp)
3624         continue
3625       if tt == 26:
3626         length = d.getVarInt32()
3627         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3628         d.skip(length)
3629         self.add_insert().TryMerge(tmp)
3630         continue
3631       if tt == 34:
3632         length = d.getVarInt32()
3633         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3634         d.skip(length)
3635         self.add_insert_auto_id().TryMerge(tmp)
3636         continue
3637       if tt == 42:
3638         length = d.getVarInt32()
3639         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
3640         d.skip(length)
3641         self.add_delete().TryMerge(tmp)
3642         continue
3643       if tt == 48:
3644         self.set_force(d.getBoolean())
3645         continue
3646
3647
3648       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3649       d.skipData(tt)
3650
3651
3652   def __str__(self, prefix="", printElemNumber=0):
3653     res=""
3654     cnt=0
3655     for e in self.upsert_:
3656       elm=""
3657       if printElemNumber: elm="(%d)" % cnt
3658       res+=prefix+("upsert%s <\n" % elm)
3659       res+=e.__str__(prefix + "  ", printElemNumber)
3660       res+=prefix+">\n"
3661       cnt+=1
3662     cnt=0
3663     for e in self.update_:
3664       elm=""
3665       if printElemNumber: elm="(%d)" % cnt
3666       res+=prefix+("update%s <\n" % elm)
3667       res+=e.__str__(prefix + "  ", printElemNumber)
3668       res+=prefix+">\n"
3669       cnt+=1
3670     cnt=0
3671     for e in self.insert_:
3672       elm=""
3673       if printElemNumber: elm="(%d)" % cnt
3674       res+=prefix+("insert%s <\n" % elm)
3675       res+=e.__str__(prefix + "  ", printElemNumber)
3676       res+=prefix+">\n"
3677       cnt+=1
3678     cnt=0
3679     for e in self.insert_auto_id_:
3680       elm=""
3681       if printElemNumber: elm="(%d)" % cnt
3682       res+=prefix+("insert_auto_id%s <\n" % elm)
3683       res+=e.__str__(prefix + "  ", printElemNumber)
3684       res+=prefix+">\n"
3685       cnt+=1
3686     cnt=0
3687     for e in self.delete_:
3688       elm=""
3689       if printElemNumber: elm="(%d)" % cnt
3690       res+=prefix+("delete%s <\n" % elm)
3691       res+=e.__str__(prefix + "  ", printElemNumber)
3692       res+=prefix+">\n"
3693       cnt+=1
3694     if self.has_force_: res+=prefix+("force: %s\n" % self.DebugFormatBool(self.force_))
3695     return res
3696
3697
3698   def _BuildTagLookupTable(sparse, maxtag, default=None):
3699     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3700
3701   kupsert = 1
3702   kupdate = 2
3703   kinsert = 3
3704   kinsert_auto_id = 4
3705   kdelete = 5
3706   kforce = 6
3707
3708   _TEXT = _BuildTagLookupTable({
3709     0: "ErrorCode",
3710     1: "upsert",
3711     2: "update",
3712     3: "insert",
3713     4: "insert_auto_id",
3714     5: "delete",
3715     6: "force",
3716   }, 6)
3717
3718   _TYPES = _BuildTagLookupTable({
3719     0: ProtocolBuffer.Encoder.NUMERIC,
3720     1: ProtocolBuffer.Encoder.STRING,
3721     2: ProtocolBuffer.Encoder.STRING,
3722     3: ProtocolBuffer.Encoder.STRING,
3723     4: ProtocolBuffer.Encoder.STRING,
3724     5: ProtocolBuffer.Encoder.STRING,
3725     6: ProtocolBuffer.Encoder.NUMERIC,
3726   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
3727
3728
3729   _STYLE = """"""
3730   _STYLE_CONTENT_TYPE = """"""
3731   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.DeprecatedMutation'
3732   _SERIALIZED_DESCRIPTOR = array.array('B')
3733   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KKmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkRlcHJlY2F0ZWRNdXRhdGlvbhMaBnVwc2VydCABKAIwCzgDSh5hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FbnRpdHmjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoGdXBkYXRlIAIoAjALOANKHmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVudGl0eaMBqgEFY3R5cGWyAQZwcm90bzKkARQTGgZpbnNlcnQgAygCMAs4A0oeYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRW50aXR5owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaDmluc2VydF9hdXRvX2lkIAQoAjALOANKHmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVudGl0eaMBqgEFY3R5cGWyAQZwcm90bzKkARQTGgZkZWxldGUgBSgCMAs4A0obYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuS2V5owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaBWZvcmNlIAYoADAIOAFCBWZhbHNlowGqAQdkZWZhdWx0sgEFZmFsc2WkARTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
3734   if _net_proto___parse__python is not None:
3735     _net_proto___parse__python.RegisterType(
3736         _SERIALIZED_DESCRIPTOR.tostring())
3737
3738 class DeprecatedMutationResult(ProtocolBuffer.ProtocolMessage):
3739   has_index_updates_ = 0
3740   index_updates_ = 0
3741
3742   def __init__(self, contents=None):
3743     self.insert_auto_id_key_ = []
3744     self.upsert_version_ = []
3745     self.update_version_ = []
3746     self.insert_version_ = []
3747     self.insert_auto_id_version_ = []
3748     self.delete_version_ = []
3749     if contents is not None: self.MergeFromString(contents)
3750
3751   def index_updates(self): return self.index_updates_
3752
3753   def set_index_updates(self, x):
3754     self.has_index_updates_ = 1
3755     self.index_updates_ = x
3756
3757   def clear_index_updates(self):
3758     if self.has_index_updates_:
3759       self.has_index_updates_ = 0
3760       self.index_updates_ = 0
3761
3762   def has_index_updates(self): return self.has_index_updates_
3763
3764   def insert_auto_id_key_size(self): return len(self.insert_auto_id_key_)
3765   def insert_auto_id_key_list(self): return self.insert_auto_id_key_
3766
3767   def insert_auto_id_key(self, i):
3768     return self.insert_auto_id_key_[i]
3769
3770   def mutable_insert_auto_id_key(self, i):
3771     return self.insert_auto_id_key_[i]
3772
3773   def add_insert_auto_id_key(self):
3774     x = google.appengine.datastore.entity_v4_pb.Key()
3775     self.insert_auto_id_key_.append(x)
3776     return x
3777
3778   def clear_insert_auto_id_key(self):
3779     self.insert_auto_id_key_ = []
3780   def upsert_version_size(self): return len(self.upsert_version_)
3781   def upsert_version_list(self): return self.upsert_version_
3782
3783   def upsert_version(self, i):
3784     return self.upsert_version_[i]
3785
3786   def set_upsert_version(self, i, x):
3787     self.upsert_version_[i] = x
3788
3789   def add_upsert_version(self, x):
3790     self.upsert_version_.append(x)
3791
3792   def clear_upsert_version(self):
3793     self.upsert_version_ = []
3794
3795   def update_version_size(self): return len(self.update_version_)
3796   def update_version_list(self): return self.update_version_
3797
3798   def update_version(self, i):
3799     return self.update_version_[i]
3800
3801   def set_update_version(self, i, x):
3802     self.update_version_[i] = x
3803
3804   def add_update_version(self, x):
3805     self.update_version_.append(x)
3806
3807   def clear_update_version(self):
3808     self.update_version_ = []
3809
3810   def insert_version_size(self): return len(self.insert_version_)
3811   def insert_version_list(self): return self.insert_version_
3812
3813   def insert_version(self, i):
3814     return self.insert_version_[i]
3815
3816   def set_insert_version(self, i, x):
3817     self.insert_version_[i] = x
3818
3819   def add_insert_version(self, x):
3820     self.insert_version_.append(x)
3821
3822   def clear_insert_version(self):
3823     self.insert_version_ = []
3824
3825   def insert_auto_id_version_size(self): return len(self.insert_auto_id_version_)
3826   def insert_auto_id_version_list(self): return self.insert_auto_id_version_
3827
3828   def insert_auto_id_version(self, i):
3829     return self.insert_auto_id_version_[i]
3830
3831   def set_insert_auto_id_version(self, i, x):
3832     self.insert_auto_id_version_[i] = x
3833
3834   def add_insert_auto_id_version(self, x):
3835     self.insert_auto_id_version_.append(x)
3836
3837   def clear_insert_auto_id_version(self):
3838     self.insert_auto_id_version_ = []
3839
3840   def delete_version_size(self): return len(self.delete_version_)
3841   def delete_version_list(self): return self.delete_version_
3842
3843   def delete_version(self, i):
3844     return self.delete_version_[i]
3845
3846   def set_delete_version(self, i, x):
3847     self.delete_version_[i] = x
3848
3849   def add_delete_version(self, x):
3850     self.delete_version_.append(x)
3851
3852   def clear_delete_version(self):
3853     self.delete_version_ = []
3854
3855
3856   def MergeFrom(self, x):
3857     assert x is not self
3858     if (x.has_index_updates()): self.set_index_updates(x.index_updates())
3859     for i in xrange(x.insert_auto_id_key_size()): self.add_insert_auto_id_key().CopyFrom(x.insert_auto_id_key(i))
3860     for i in xrange(x.upsert_version_size()): self.add_upsert_version(x.upsert_version(i))
3861     for i in xrange(x.update_version_size()): self.add_update_version(x.update_version(i))
3862     for i in xrange(x.insert_version_size()): self.add_insert_version(x.insert_version(i))
3863     for i in xrange(x.insert_auto_id_version_size()): self.add_insert_auto_id_version(x.insert_auto_id_version(i))
3864     for i in xrange(x.delete_version_size()): self.add_delete_version(x.delete_version(i))
3865
3866   if _net_proto___parse__python is not None:
3867     def _CMergeFromString(self, s):
3868       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.DeprecatedMutationResult', s)
3869
3870   if _net_proto___parse__python is not None:
3871     def _CEncode(self):
3872       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.DeprecatedMutationResult')
3873
3874   if _net_proto___parse__python is not None:
3875     def _CEncodePartial(self):
3876       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.DeprecatedMutationResult')
3877
3878   if _net_proto___parse__python is not None:
3879     def _CToASCII(self, output_format):
3880       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.DeprecatedMutationResult', output_format)
3881
3882
3883   if _net_proto___parse__python is not None:
3884     def ParseASCII(self, s):
3885       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.DeprecatedMutationResult', s)
3886
3887
3888   if _net_proto___parse__python is not None:
3889     def ParseASCIIIgnoreUnknown(self, s):
3890       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.DeprecatedMutationResult', s)
3891
3892
3893   def Equals(self, x):
3894     if x is self: return 1
3895     if self.has_index_updates_ != x.has_index_updates_: return 0
3896     if self.has_index_updates_ and self.index_updates_ != x.index_updates_: return 0
3897     if len(self.insert_auto_id_key_) != len(x.insert_auto_id_key_): return 0
3898     for e1, e2 in zip(self.insert_auto_id_key_, x.insert_auto_id_key_):
3899       if e1 != e2: return 0
3900     if len(self.upsert_version_) != len(x.upsert_version_): return 0
3901     for e1, e2 in zip(self.upsert_version_, x.upsert_version_):
3902       if e1 != e2: return 0
3903     if len(self.update_version_) != len(x.update_version_): return 0
3904     for e1, e2 in zip(self.update_version_, x.update_version_):
3905       if e1 != e2: return 0
3906     if len(self.insert_version_) != len(x.insert_version_): return 0
3907     for e1, e2 in zip(self.insert_version_, x.insert_version_):
3908       if e1 != e2: return 0
3909     if len(self.insert_auto_id_version_) != len(x.insert_auto_id_version_): return 0
3910     for e1, e2 in zip(self.insert_auto_id_version_, x.insert_auto_id_version_):
3911       if e1 != e2: return 0
3912     if len(self.delete_version_) != len(x.delete_version_): return 0
3913     for e1, e2 in zip(self.delete_version_, x.delete_version_):
3914       if e1 != e2: return 0
3915     return 1
3916
3917   def IsInitialized(self, debug_strs=None):
3918     initialized = 1
3919     if (not self.has_index_updates_):
3920       initialized = 0
3921       if debug_strs is not None:
3922         debug_strs.append('Required field: index_updates not set.')
3923     for p in self.insert_auto_id_key_:
3924       if not p.IsInitialized(debug_strs): initialized=0
3925     return initialized
3926
3927   def ByteSize(self):
3928     n = 0
3929     n += self.lengthVarInt64(self.index_updates_)
3930     n += 1 * len(self.insert_auto_id_key_)
3931     for i in xrange(len(self.insert_auto_id_key_)): n += self.lengthString(self.insert_auto_id_key_[i].ByteSize())
3932     n += 1 * len(self.upsert_version_)
3933     for i in xrange(len(self.upsert_version_)): n += self.lengthVarInt64(self.upsert_version_[i])
3934     n += 1 * len(self.update_version_)
3935     for i in xrange(len(self.update_version_)): n += self.lengthVarInt64(self.update_version_[i])
3936     n += 1 * len(self.insert_version_)
3937     for i in xrange(len(self.insert_version_)): n += self.lengthVarInt64(self.insert_version_[i])
3938     n += 1 * len(self.insert_auto_id_version_)
3939     for i in xrange(len(self.insert_auto_id_version_)): n += self.lengthVarInt64(self.insert_auto_id_version_[i])
3940     n += 1 * len(self.delete_version_)
3941     for i in xrange(len(self.delete_version_)): n += self.lengthVarInt64(self.delete_version_[i])
3942     return n + 1
3943
3944   def ByteSizePartial(self):
3945     n = 0
3946     if (self.has_index_updates_):
3947       n += 1
3948       n += self.lengthVarInt64(self.index_updates_)
3949     n += 1 * len(self.insert_auto_id_key_)
3950     for i in xrange(len(self.insert_auto_id_key_)): n += self.lengthString(self.insert_auto_id_key_[i].ByteSizePartial())
3951     n += 1 * len(self.upsert_version_)
3952     for i in xrange(len(self.upsert_version_)): n += self.lengthVarInt64(self.upsert_version_[i])
3953     n += 1 * len(self.update_version_)
3954     for i in xrange(len(self.update_version_)): n += self.lengthVarInt64(self.update_version_[i])
3955     n += 1 * len(self.insert_version_)
3956     for i in xrange(len(self.insert_version_)): n += self.lengthVarInt64(self.insert_version_[i])
3957     n += 1 * len(self.insert_auto_id_version_)
3958     for i in xrange(len(self.insert_auto_id_version_)): n += self.lengthVarInt64(self.insert_auto_id_version_[i])
3959     n += 1 * len(self.delete_version_)
3960     for i in xrange(len(self.delete_version_)): n += self.lengthVarInt64(self.delete_version_[i])
3961     return n
3962
3963   def Clear(self):
3964     self.clear_index_updates()
3965     self.clear_insert_auto_id_key()
3966     self.clear_upsert_version()
3967     self.clear_update_version()
3968     self.clear_insert_version()
3969     self.clear_insert_auto_id_version()
3970     self.clear_delete_version()
3971
3972   def OutputUnchecked(self, out):
3973     out.putVarInt32(8)
3974     out.putVarInt32(self.index_updates_)
3975     for i in xrange(len(self.insert_auto_id_key_)):
3976       out.putVarInt32(18)
3977       out.putVarInt32(self.insert_auto_id_key_[i].ByteSize())
3978       self.insert_auto_id_key_[i].OutputUnchecked(out)
3979     for i in xrange(len(self.upsert_version_)):
3980       out.putVarInt32(24)
3981       out.putVarInt64(self.upsert_version_[i])
3982     for i in xrange(len(self.update_version_)):
3983       out.putVarInt32(32)
3984       out.putVarInt64(self.update_version_[i])
3985     for i in xrange(len(self.insert_version_)):
3986       out.putVarInt32(40)
3987       out.putVarInt64(self.insert_version_[i])
3988     for i in xrange(len(self.insert_auto_id_version_)):
3989       out.putVarInt32(48)
3990       out.putVarInt64(self.insert_auto_id_version_[i])
3991     for i in xrange(len(self.delete_version_)):
3992       out.putVarInt32(56)
3993       out.putVarInt64(self.delete_version_[i])
3994
3995   def OutputPartial(self, out):
3996     if (self.has_index_updates_):
3997       out.putVarInt32(8)
3998       out.putVarInt32(self.index_updates_)
3999     for i in xrange(len(self.insert_auto_id_key_)):
4000       out.putVarInt32(18)
4001       out.putVarInt32(self.insert_auto_id_key_[i].ByteSizePartial())
4002       self.insert_auto_id_key_[i].OutputPartial(out)
4003     for i in xrange(len(self.upsert_version_)):
4004       out.putVarInt32(24)
4005       out.putVarInt64(self.upsert_version_[i])
4006     for i in xrange(len(self.update_version_)):
4007       out.putVarInt32(32)
4008       out.putVarInt64(self.update_version_[i])
4009     for i in xrange(len(self.insert_version_)):
4010       out.putVarInt32(40)
4011       out.putVarInt64(self.insert_version_[i])
4012     for i in xrange(len(self.insert_auto_id_version_)):
4013       out.putVarInt32(48)
4014       out.putVarInt64(self.insert_auto_id_version_[i])
4015     for i in xrange(len(self.delete_version_)):
4016       out.putVarInt32(56)
4017       out.putVarInt64(self.delete_version_[i])
4018
4019   def TryMerge(self, d):
4020     while d.avail() > 0:
4021       tt = d.getVarInt32()
4022       if tt == 8:
4023         self.set_index_updates(d.getVarInt32())
4024         continue
4025       if tt == 18:
4026         length = d.getVarInt32()
4027         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4028         d.skip(length)
4029         self.add_insert_auto_id_key().TryMerge(tmp)
4030         continue
4031       if tt == 24:
4032         self.add_upsert_version(d.getVarInt64())
4033         continue
4034       if tt == 32:
4035         self.add_update_version(d.getVarInt64())
4036         continue
4037       if tt == 40:
4038         self.add_insert_version(d.getVarInt64())
4039         continue
4040       if tt == 48:
4041         self.add_insert_auto_id_version(d.getVarInt64())
4042         continue
4043       if tt == 56:
4044         self.add_delete_version(d.getVarInt64())
4045         continue
4046
4047
4048       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4049       d.skipData(tt)
4050
4051
4052   def __str__(self, prefix="", printElemNumber=0):
4053     res=""
4054     if self.has_index_updates_: res+=prefix+("index_updates: %s\n" % self.DebugFormatInt32(self.index_updates_))
4055     cnt=0
4056     for e in self.insert_auto_id_key_:
4057       elm=""
4058       if printElemNumber: elm="(%d)" % cnt
4059       res+=prefix+("insert_auto_id_key%s <\n" % elm)
4060       res+=e.__str__(prefix + "  ", printElemNumber)
4061       res+=prefix+">\n"
4062       cnt+=1
4063     cnt=0
4064     for e in self.upsert_version_:
4065       elm=""
4066       if printElemNumber: elm="(%d)" % cnt
4067       res+=prefix+("upsert_version%s: %s\n" % (elm, self.DebugFormatInt64(e)))
4068       cnt+=1
4069     cnt=0
4070     for e in self.update_version_:
4071       elm=""
4072       if printElemNumber: elm="(%d)" % cnt
4073       res+=prefix+("update_version%s: %s\n" % (elm, self.DebugFormatInt64(e)))
4074       cnt+=1
4075     cnt=0
4076     for e in self.insert_version_:
4077       elm=""
4078       if printElemNumber: elm="(%d)" % cnt
4079       res+=prefix+("insert_version%s: %s\n" % (elm, self.DebugFormatInt64(e)))
4080       cnt+=1
4081     cnt=0
4082     for e in self.insert_auto_id_version_:
4083       elm=""
4084       if printElemNumber: elm="(%d)" % cnt
4085       res+=prefix+("insert_auto_id_version%s: %s\n" % (elm, self.DebugFormatInt64(e)))
4086       cnt+=1
4087     cnt=0
4088     for e in self.delete_version_:
4089       elm=""
4090       if printElemNumber: elm="(%d)" % cnt
4091       res+=prefix+("delete_version%s: %s\n" % (elm, self.DebugFormatInt64(e)))
4092       cnt+=1
4093     return res
4094
4095
4096   def _BuildTagLookupTable(sparse, maxtag, default=None):
4097     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4098
4099   kindex_updates = 1
4100   kinsert_auto_id_key = 2
4101   kupsert_version = 3
4102   kupdate_version = 4
4103   kinsert_version = 5
4104   kinsert_auto_id_version = 6
4105   kdelete_version = 7
4106
4107   _TEXT = _BuildTagLookupTable({
4108     0: "ErrorCode",
4109     1: "index_updates",
4110     2: "insert_auto_id_key",
4111     3: "upsert_version",
4112     4: "update_version",
4113     5: "insert_version",
4114     6: "insert_auto_id_version",
4115     7: "delete_version",
4116   }, 7)
4117
4118   _TYPES = _BuildTagLookupTable({
4119     0: ProtocolBuffer.Encoder.NUMERIC,
4120     1: ProtocolBuffer.Encoder.NUMERIC,
4121     2: ProtocolBuffer.Encoder.STRING,
4122     3: ProtocolBuffer.Encoder.NUMERIC,
4123     4: ProtocolBuffer.Encoder.NUMERIC,
4124     5: ProtocolBuffer.Encoder.NUMERIC,
4125     6: ProtocolBuffer.Encoder.NUMERIC,
4126     7: ProtocolBuffer.Encoder.NUMERIC,
4127   }, 7, ProtocolBuffer.Encoder.MAX_TYPE)
4128
4129
4130   _STYLE = """"""
4131   _STYLE_CONTENT_TYPE = """"""
4132   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.DeprecatedMutationResult'
4133   _SERIALIZED_DESCRIPTOR = array.array('B')
4134   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KMGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkRlcHJlY2F0ZWRNdXRhdGlvblJlc3VsdBMaDWluZGV4X3VwZGF0ZXMgASgAMAU4AhQTGhJpbnNlcnRfYXV0b19pZF9rZXkgAigCMAs4A0obYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuS2V5owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaDnVwc2VydF92ZXJzaW9uIAMoADADOAMUExoOdXBkYXRlX3ZlcnNpb24gBCgAMAM4AxQTGg5pbnNlcnRfdmVyc2lvbiAFKAAwAzgDFBMaFmluc2VydF9hdXRvX2lkX3ZlcnNpb24gBigAMAM4AxQTGg5kZWxldGVfdmVyc2lvbiAHKAAwAzgDFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
4135   if _net_proto___parse__python is not None:
4136     _net_proto___parse__python.RegisterType(
4137         _SERIALIZED_DESCRIPTOR.tostring())
4138
4139 class ReadOptions(ProtocolBuffer.ProtocolMessage):
4140
4141
4142   DEFAULT      =    0
4143   STRONG       =    1
4144   EVENTUAL     =    2
4145
4146   _ReadConsistency_NAMES = {
4147     0: "DEFAULT",
4148     1: "STRONG",
4149     2: "EVENTUAL",
4150   }
4151
4152   def ReadConsistency_Name(cls, x): return cls._ReadConsistency_NAMES.get(x, "")
4153   ReadConsistency_Name = classmethod(ReadConsistency_Name)
4154
4155   has_read_consistency_ = 0
4156   read_consistency_ = 0
4157   has_transaction_ = 0
4158   transaction_ = ""
4159
4160   def __init__(self, contents=None):
4161     if contents is not None: self.MergeFromString(contents)
4162
4163   def read_consistency(self): return self.read_consistency_
4164
4165   def set_read_consistency(self, x):
4166     self.has_read_consistency_ = 1
4167     self.read_consistency_ = x
4168
4169   def clear_read_consistency(self):
4170     if self.has_read_consistency_:
4171       self.has_read_consistency_ = 0
4172       self.read_consistency_ = 0
4173
4174   def has_read_consistency(self): return self.has_read_consistency_
4175
4176   def transaction(self): return self.transaction_
4177
4178   def set_transaction(self, x):
4179     self.has_transaction_ = 1
4180     self.transaction_ = x
4181
4182   def clear_transaction(self):
4183     if self.has_transaction_:
4184       self.has_transaction_ = 0
4185       self.transaction_ = ""
4186
4187   def has_transaction(self): return self.has_transaction_
4188
4189
4190   def MergeFrom(self, x):
4191     assert x is not self
4192     if (x.has_read_consistency()): self.set_read_consistency(x.read_consistency())
4193     if (x.has_transaction()): self.set_transaction(x.transaction())
4194
4195   if _net_proto___parse__python is not None:
4196     def _CMergeFromString(self, s):
4197       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.ReadOptions', s)
4198
4199   if _net_proto___parse__python is not None:
4200     def _CEncode(self):
4201       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.ReadOptions')
4202
4203   if _net_proto___parse__python is not None:
4204     def _CEncodePartial(self):
4205       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.ReadOptions')
4206
4207   if _net_proto___parse__python is not None:
4208     def _CToASCII(self, output_format):
4209       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.ReadOptions', output_format)
4210
4211
4212   if _net_proto___parse__python is not None:
4213     def ParseASCII(self, s):
4214       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.ReadOptions', s)
4215
4216
4217   if _net_proto___parse__python is not None:
4218     def ParseASCIIIgnoreUnknown(self, s):
4219       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.ReadOptions', s)
4220
4221
4222   def Equals(self, x):
4223     if x is self: return 1
4224     if self.has_read_consistency_ != x.has_read_consistency_: return 0
4225     if self.has_read_consistency_ and self.read_consistency_ != x.read_consistency_: return 0
4226     if self.has_transaction_ != x.has_transaction_: return 0
4227     if self.has_transaction_ and self.transaction_ != x.transaction_: return 0
4228     return 1
4229
4230   def IsInitialized(self, debug_strs=None):
4231     initialized = 1
4232     return initialized
4233
4234   def ByteSize(self):
4235     n = 0
4236     if (self.has_read_consistency_): n += 1 + self.lengthVarInt64(self.read_consistency_)
4237     if (self.has_transaction_): n += 1 + self.lengthString(len(self.transaction_))
4238     return n
4239
4240   def ByteSizePartial(self):
4241     n = 0
4242     if (self.has_read_consistency_): n += 1 + self.lengthVarInt64(self.read_consistency_)
4243     if (self.has_transaction_): n += 1 + self.lengthString(len(self.transaction_))
4244     return n
4245
4246   def Clear(self):
4247     self.clear_read_consistency()
4248     self.clear_transaction()
4249
4250   def OutputUnchecked(self, out):
4251     if (self.has_read_consistency_):
4252       out.putVarInt32(8)
4253       out.putVarInt32(self.read_consistency_)
4254     if (self.has_transaction_):
4255       out.putVarInt32(18)
4256       out.putPrefixedString(self.transaction_)
4257
4258   def OutputPartial(self, out):
4259     if (self.has_read_consistency_):
4260       out.putVarInt32(8)
4261       out.putVarInt32(self.read_consistency_)
4262     if (self.has_transaction_):
4263       out.putVarInt32(18)
4264       out.putPrefixedString(self.transaction_)
4265
4266   def TryMerge(self, d):
4267     while d.avail() > 0:
4268       tt = d.getVarInt32()
4269       if tt == 8:
4270         self.set_read_consistency(d.getVarInt32())
4271         continue
4272       if tt == 18:
4273         self.set_transaction(d.getPrefixedString())
4274         continue
4275
4276
4277       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4278       d.skipData(tt)
4279
4280
4281   def __str__(self, prefix="", printElemNumber=0):
4282     res=""
4283     if self.has_read_consistency_: res+=prefix+("read_consistency: %s\n" % self.DebugFormatInt32(self.read_consistency_))
4284     if self.has_transaction_: res+=prefix+("transaction: %s\n" % self.DebugFormatString(self.transaction_))
4285     return res
4286
4287
4288   def _BuildTagLookupTable(sparse, maxtag, default=None):
4289     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4290
4291   kread_consistency = 1
4292   ktransaction = 2
4293
4294   _TEXT = _BuildTagLookupTable({
4295     0: "ErrorCode",
4296     1: "read_consistency",
4297     2: "transaction",
4298   }, 2)
4299
4300   _TYPES = _BuildTagLookupTable({
4301     0: ProtocolBuffer.Encoder.NUMERIC,
4302     1: ProtocolBuffer.Encoder.NUMERIC,
4303     2: ProtocolBuffer.Encoder.STRING,
4304   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
4305
4306
4307   _STYLE = """"""
4308   _STYLE_CONTENT_TYPE = """"""
4309   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.ReadOptions'
4310   _SERIALIZED_DESCRIPTOR = array.array('B')
4311   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KI2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlJlYWRPcHRpb25zExoQcmVhZF9jb25zaXN0ZW5jeSABKAAwBTgBQgEwaACjAaoBB2RlZmF1bHSyAQdERUZBVUxUpAEUExoLdHJhbnNhY3Rpb24gAigCMAk4ARRzeg9SZWFkQ29uc2lzdGVuY3mLAZIBB0RFRkFVTFSYAQCMAYsBkgEGU1RST05HmAEBjAGLAZIBCEVWRU5UVUFMmAECjAF0wgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
4312   if _net_proto___parse__python is not None:
4313     _net_proto___parse__python.RegisterType(
4314         _SERIALIZED_DESCRIPTOR.tostring())
4315
4316 class LookupRequest(ProtocolBuffer.ProtocolMessage):
4317   has_read_options_ = 0
4318   read_options_ = None
4319
4320   def __init__(self, contents=None):
4321     self.key_ = []
4322     self.lazy_init_lock_ = thread.allocate_lock()
4323     if contents is not None: self.MergeFromString(contents)
4324
4325   def read_options(self):
4326     if self.read_options_ is None:
4327       self.lazy_init_lock_.acquire()
4328       try:
4329         if self.read_options_ is None: self.read_options_ = ReadOptions()
4330       finally:
4331         self.lazy_init_lock_.release()
4332     return self.read_options_
4333
4334   def mutable_read_options(self): self.has_read_options_ = 1; return self.read_options()
4335
4336   def clear_read_options(self):
4337
4338     if self.has_read_options_:
4339       self.has_read_options_ = 0;
4340       if self.read_options_ is not None: self.read_options_.Clear()
4341
4342   def has_read_options(self): return self.has_read_options_
4343
4344   def key_size(self): return len(self.key_)
4345   def key_list(self): return self.key_
4346
4347   def key(self, i):
4348     return self.key_[i]
4349
4350   def mutable_key(self, i):
4351     return self.key_[i]
4352
4353   def add_key(self):
4354     x = google.appengine.datastore.entity_v4_pb.Key()
4355     self.key_.append(x)
4356     return x
4357
4358   def clear_key(self):
4359     self.key_ = []
4360
4361   def MergeFrom(self, x):
4362     assert x is not self
4363     if (x.has_read_options()): self.mutable_read_options().MergeFrom(x.read_options())
4364     for i in xrange(x.key_size()): self.add_key().CopyFrom(x.key(i))
4365
4366   if _net_proto___parse__python is not None:
4367     def _CMergeFromString(self, s):
4368       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.LookupRequest', s)
4369
4370   if _net_proto___parse__python is not None:
4371     def _CEncode(self):
4372       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.LookupRequest')
4373
4374   if _net_proto___parse__python is not None:
4375     def _CEncodePartial(self):
4376       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.LookupRequest')
4377
4378   if _net_proto___parse__python is not None:
4379     def _CToASCII(self, output_format):
4380       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.LookupRequest', output_format)
4381
4382
4383   if _net_proto___parse__python is not None:
4384     def ParseASCII(self, s):
4385       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.LookupRequest', s)
4386
4387
4388   if _net_proto___parse__python is not None:
4389     def ParseASCIIIgnoreUnknown(self, s):
4390       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.LookupRequest', s)
4391
4392
4393   def Equals(self, x):
4394     if x is self: return 1
4395     if self.has_read_options_ != x.has_read_options_: return 0
4396     if self.has_read_options_ and self.read_options_ != x.read_options_: return 0
4397     if len(self.key_) != len(x.key_): return 0
4398     for e1, e2 in zip(self.key_, x.key_):
4399       if e1 != e2: return 0
4400     return 1
4401
4402   def IsInitialized(self, debug_strs=None):
4403     initialized = 1
4404     if (self.has_read_options_ and not self.read_options_.IsInitialized(debug_strs)): initialized = 0
4405     for p in self.key_:
4406       if not p.IsInitialized(debug_strs): initialized=0
4407     return initialized
4408
4409   def ByteSize(self):
4410     n = 0
4411     if (self.has_read_options_): n += 1 + self.lengthString(self.read_options_.ByteSize())
4412     n += 1 * len(self.key_)
4413     for i in xrange(len(self.key_)): n += self.lengthString(self.key_[i].ByteSize())
4414     return n
4415
4416   def ByteSizePartial(self):
4417     n = 0
4418     if (self.has_read_options_): n += 1 + self.lengthString(self.read_options_.ByteSizePartial())
4419     n += 1 * len(self.key_)
4420     for i in xrange(len(self.key_)): n += self.lengthString(self.key_[i].ByteSizePartial())
4421     return n
4422
4423   def Clear(self):
4424     self.clear_read_options()
4425     self.clear_key()
4426
4427   def OutputUnchecked(self, out):
4428     if (self.has_read_options_):
4429       out.putVarInt32(10)
4430       out.putVarInt32(self.read_options_.ByteSize())
4431       self.read_options_.OutputUnchecked(out)
4432     for i in xrange(len(self.key_)):
4433       out.putVarInt32(26)
4434       out.putVarInt32(self.key_[i].ByteSize())
4435       self.key_[i].OutputUnchecked(out)
4436
4437   def OutputPartial(self, out):
4438     if (self.has_read_options_):
4439       out.putVarInt32(10)
4440       out.putVarInt32(self.read_options_.ByteSizePartial())
4441       self.read_options_.OutputPartial(out)
4442     for i in xrange(len(self.key_)):
4443       out.putVarInt32(26)
4444       out.putVarInt32(self.key_[i].ByteSizePartial())
4445       self.key_[i].OutputPartial(out)
4446
4447   def TryMerge(self, d):
4448     while d.avail() > 0:
4449       tt = d.getVarInt32()
4450       if tt == 10:
4451         length = d.getVarInt32()
4452         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4453         d.skip(length)
4454         self.mutable_read_options().TryMerge(tmp)
4455         continue
4456       if tt == 26:
4457         length = d.getVarInt32()
4458         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4459         d.skip(length)
4460         self.add_key().TryMerge(tmp)
4461         continue
4462
4463
4464       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4465       d.skipData(tt)
4466
4467
4468   def __str__(self, prefix="", printElemNumber=0):
4469     res=""
4470     if self.has_read_options_:
4471       res+=prefix+"read_options <\n"
4472       res+=self.read_options_.__str__(prefix + "  ", printElemNumber)
4473       res+=prefix+">\n"
4474     cnt=0
4475     for e in self.key_:
4476       elm=""
4477       if printElemNumber: elm="(%d)" % cnt
4478       res+=prefix+("key%s <\n" % elm)
4479       res+=e.__str__(prefix + "  ", printElemNumber)
4480       res+=prefix+">\n"
4481       cnt+=1
4482     return res
4483
4484
4485   def _BuildTagLookupTable(sparse, maxtag, default=None):
4486     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4487
4488   kread_options = 1
4489   kkey = 3
4490
4491   _TEXT = _BuildTagLookupTable({
4492     0: "ErrorCode",
4493     1: "read_options",
4494     3: "key",
4495   }, 3)
4496
4497   _TYPES = _BuildTagLookupTable({
4498     0: ProtocolBuffer.Encoder.NUMERIC,
4499     1: ProtocolBuffer.Encoder.STRING,
4500     3: ProtocolBuffer.Encoder.STRING,
4501   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
4502
4503
4504   _STYLE = """"""
4505   _STYLE_CONTENT_TYPE = """"""
4506   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.LookupRequest'
4507   _SERIALIZED_DESCRIPTOR = array.array('B')
4508   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0Lkxvb2t1cFJlcXVlc3QTGgxyZWFkX29wdGlvbnMgASgCMAs4AUojYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUmVhZE9wdGlvbnOjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoDa2V5IAMoAjALOANKG2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleaMBqgEFY3R5cGWyAQZwcm90bzKkARTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
4509   if _net_proto___parse__python is not None:
4510     _net_proto___parse__python.RegisterType(
4511         _SERIALIZED_DESCRIPTOR.tostring())
4512
4513 class LookupResponse(ProtocolBuffer.ProtocolMessage):
4514
4515   def __init__(self, contents=None):
4516     self.found_ = []
4517     self.missing_ = []
4518     self.deferred_ = []
4519     if contents is not None: self.MergeFromString(contents)
4520
4521   def found_size(self): return len(self.found_)
4522   def found_list(self): return self.found_
4523
4524   def found(self, i):
4525     return self.found_[i]
4526
4527   def mutable_found(self, i):
4528     return self.found_[i]
4529
4530   def add_found(self):
4531     x = EntityResult()
4532     self.found_.append(x)
4533     return x
4534
4535   def clear_found(self):
4536     self.found_ = []
4537   def missing_size(self): return len(self.missing_)
4538   def missing_list(self): return self.missing_
4539
4540   def missing(self, i):
4541     return self.missing_[i]
4542
4543   def mutable_missing(self, i):
4544     return self.missing_[i]
4545
4546   def add_missing(self):
4547     x = EntityResult()
4548     self.missing_.append(x)
4549     return x
4550
4551   def clear_missing(self):
4552     self.missing_ = []
4553   def deferred_size(self): return len(self.deferred_)
4554   def deferred_list(self): return self.deferred_
4555
4556   def deferred(self, i):
4557     return self.deferred_[i]
4558
4559   def mutable_deferred(self, i):
4560     return self.deferred_[i]
4561
4562   def add_deferred(self):
4563     x = google.appengine.datastore.entity_v4_pb.Key()
4564     self.deferred_.append(x)
4565     return x
4566
4567   def clear_deferred(self):
4568     self.deferred_ = []
4569
4570   def MergeFrom(self, x):
4571     assert x is not self
4572     for i in xrange(x.found_size()): self.add_found().CopyFrom(x.found(i))
4573     for i in xrange(x.missing_size()): self.add_missing().CopyFrom(x.missing(i))
4574     for i in xrange(x.deferred_size()): self.add_deferred().CopyFrom(x.deferred(i))
4575
4576   if _net_proto___parse__python is not None:
4577     def _CMergeFromString(self, s):
4578       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.LookupResponse', s)
4579
4580   if _net_proto___parse__python is not None:
4581     def _CEncode(self):
4582       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.LookupResponse')
4583
4584   if _net_proto___parse__python is not None:
4585     def _CEncodePartial(self):
4586       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.LookupResponse')
4587
4588   if _net_proto___parse__python is not None:
4589     def _CToASCII(self, output_format):
4590       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.LookupResponse', output_format)
4591
4592
4593   if _net_proto___parse__python is not None:
4594     def ParseASCII(self, s):
4595       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.LookupResponse', s)
4596
4597
4598   if _net_proto___parse__python is not None:
4599     def ParseASCIIIgnoreUnknown(self, s):
4600       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.LookupResponse', s)
4601
4602
4603   def Equals(self, x):
4604     if x is self: return 1
4605     if len(self.found_) != len(x.found_): return 0
4606     for e1, e2 in zip(self.found_, x.found_):
4607       if e1 != e2: return 0
4608     if len(self.missing_) != len(x.missing_): return 0
4609     for e1, e2 in zip(self.missing_, x.missing_):
4610       if e1 != e2: return 0
4611     if len(self.deferred_) != len(x.deferred_): return 0
4612     for e1, e2 in zip(self.deferred_, x.deferred_):
4613       if e1 != e2: return 0
4614     return 1
4615
4616   def IsInitialized(self, debug_strs=None):
4617     initialized = 1
4618     for p in self.found_:
4619       if not p.IsInitialized(debug_strs): initialized=0
4620     for p in self.missing_:
4621       if not p.IsInitialized(debug_strs): initialized=0
4622     for p in self.deferred_:
4623       if not p.IsInitialized(debug_strs): initialized=0
4624     return initialized
4625
4626   def ByteSize(self):
4627     n = 0
4628     n += 1 * len(self.found_)
4629     for i in xrange(len(self.found_)): n += self.lengthString(self.found_[i].ByteSize())
4630     n += 1 * len(self.missing_)
4631     for i in xrange(len(self.missing_)): n += self.lengthString(self.missing_[i].ByteSize())
4632     n += 1 * len(self.deferred_)
4633     for i in xrange(len(self.deferred_)): n += self.lengthString(self.deferred_[i].ByteSize())
4634     return n
4635
4636   def ByteSizePartial(self):
4637     n = 0
4638     n += 1 * len(self.found_)
4639     for i in xrange(len(self.found_)): n += self.lengthString(self.found_[i].ByteSizePartial())
4640     n += 1 * len(self.missing_)
4641     for i in xrange(len(self.missing_)): n += self.lengthString(self.missing_[i].ByteSizePartial())
4642     n += 1 * len(self.deferred_)
4643     for i in xrange(len(self.deferred_)): n += self.lengthString(self.deferred_[i].ByteSizePartial())
4644     return n
4645
4646   def Clear(self):
4647     self.clear_found()
4648     self.clear_missing()
4649     self.clear_deferred()
4650
4651   def OutputUnchecked(self, out):
4652     for i in xrange(len(self.found_)):
4653       out.putVarInt32(10)
4654       out.putVarInt32(self.found_[i].ByteSize())
4655       self.found_[i].OutputUnchecked(out)
4656     for i in xrange(len(self.missing_)):
4657       out.putVarInt32(18)
4658       out.putVarInt32(self.missing_[i].ByteSize())
4659       self.missing_[i].OutputUnchecked(out)
4660     for i in xrange(len(self.deferred_)):
4661       out.putVarInt32(26)
4662       out.putVarInt32(self.deferred_[i].ByteSize())
4663       self.deferred_[i].OutputUnchecked(out)
4664
4665   def OutputPartial(self, out):
4666     for i in xrange(len(self.found_)):
4667       out.putVarInt32(10)
4668       out.putVarInt32(self.found_[i].ByteSizePartial())
4669       self.found_[i].OutputPartial(out)
4670     for i in xrange(len(self.missing_)):
4671       out.putVarInt32(18)
4672       out.putVarInt32(self.missing_[i].ByteSizePartial())
4673       self.missing_[i].OutputPartial(out)
4674     for i in xrange(len(self.deferred_)):
4675       out.putVarInt32(26)
4676       out.putVarInt32(self.deferred_[i].ByteSizePartial())
4677       self.deferred_[i].OutputPartial(out)
4678
4679   def TryMerge(self, d):
4680     while d.avail() > 0:
4681       tt = d.getVarInt32()
4682       if tt == 10:
4683         length = d.getVarInt32()
4684         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4685         d.skip(length)
4686         self.add_found().TryMerge(tmp)
4687         continue
4688       if tt == 18:
4689         length = d.getVarInt32()
4690         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4691         d.skip(length)
4692         self.add_missing().TryMerge(tmp)
4693         continue
4694       if tt == 26:
4695         length = d.getVarInt32()
4696         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
4697         d.skip(length)
4698         self.add_deferred().TryMerge(tmp)
4699         continue
4700
4701
4702       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
4703       d.skipData(tt)
4704
4705
4706   def __str__(self, prefix="", printElemNumber=0):
4707     res=""
4708     cnt=0
4709     for e in self.found_:
4710       elm=""
4711       if printElemNumber: elm="(%d)" % cnt
4712       res+=prefix+("found%s <\n" % elm)
4713       res+=e.__str__(prefix + "  ", printElemNumber)
4714       res+=prefix+">\n"
4715       cnt+=1
4716     cnt=0
4717     for e in self.missing_:
4718       elm=""
4719       if printElemNumber: elm="(%d)" % cnt
4720       res+=prefix+("missing%s <\n" % elm)
4721       res+=e.__str__(prefix + "  ", printElemNumber)
4722       res+=prefix+">\n"
4723       cnt+=1
4724     cnt=0
4725     for e in self.deferred_:
4726       elm=""
4727       if printElemNumber: elm="(%d)" % cnt
4728       res+=prefix+("deferred%s <\n" % elm)
4729       res+=e.__str__(prefix + "  ", printElemNumber)
4730       res+=prefix+">\n"
4731       cnt+=1
4732     return res
4733
4734
4735   def _BuildTagLookupTable(sparse, maxtag, default=None):
4736     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
4737
4738   kfound = 1
4739   kmissing = 2
4740   kdeferred = 3
4741
4742   _TEXT = _BuildTagLookupTable({
4743     0: "ErrorCode",
4744     1: "found",
4745     2: "missing",
4746     3: "deferred",
4747   }, 3)
4748
4749   _TYPES = _BuildTagLookupTable({
4750     0: ProtocolBuffer.Encoder.NUMERIC,
4751     1: ProtocolBuffer.Encoder.STRING,
4752     2: ProtocolBuffer.Encoder.STRING,
4753     3: ProtocolBuffer.Encoder.STRING,
4754   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
4755
4756
4757   _STYLE = """"""
4758   _STYLE_CONTENT_TYPE = """"""
4759   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.LookupResponse'
4760   _SERIALIZED_DESCRIPTOR = array.array('B')
4761   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0Lkxvb2t1cFJlc3BvbnNlExoFZm91bmQgASgCMAs4A0okYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRW50aXR5UmVzdWx0owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaB21pc3NpbmcgAigCMAs4A0okYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRW50aXR5UmVzdWx0owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaCGRlZmVycmVkIAMoAjALOANKG2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleaMBqgEFY3R5cGWyAQZwcm90bzKkARTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
4762   if _net_proto___parse__python is not None:
4763     _net_proto___parse__python.RegisterType(
4764         _SERIALIZED_DESCRIPTOR.tostring())
4765
4766 class RunQueryRequest(ProtocolBuffer.ProtocolMessage):
4767   has_read_options_ = 0
4768   read_options_ = None
4769   has_partition_id_ = 0
4770   partition_id_ = None
4771   has_query_ = 0
4772   query_ = None
4773   has_gql_query_ = 0
4774   gql_query_ = None
4775   has_min_safe_time_seconds_ = 0
4776   min_safe_time_seconds_ = 0
4777   has_suggested_batch_size_ = 0
4778   suggested_batch_size_ = 0
4779
4780   def __init__(self, contents=None):
4781     self.lazy_init_lock_ = thread.allocate_lock()
4782     if contents is not None: self.MergeFromString(contents)
4783
4784   def read_options(self):
4785     if self.read_options_ is None:
4786       self.lazy_init_lock_.acquire()
4787       try:
4788         if self.read_options_ is None: self.read_options_ = ReadOptions()
4789       finally:
4790         self.lazy_init_lock_.release()
4791     return self.read_options_
4792
4793   def mutable_read_options(self): self.has_read_options_ = 1; return self.read_options()
4794
4795   def clear_read_options(self):
4796
4797     if self.has_read_options_:
4798       self.has_read_options_ = 0;
4799       if self.read_options_ is not None: self.read_options_.Clear()
4800
4801   def has_read_options(self): return self.has_read_options_
4802
4803   def partition_id(self):
4804     if self.partition_id_ is None:
4805       self.lazy_init_lock_.acquire()
4806       try:
4807         if self.partition_id_ is None: self.partition_id_ = google.appengine.datastore.entity_v4_pb.PartitionId()
4808       finally:
4809         self.lazy_init_lock_.release()
4810     return self.partition_id_
4811
4812   def mutable_partition_id(self): self.has_partition_id_ = 1; return self.partition_id()
4813
4814   def clear_partition_id(self):
4815
4816     if self.has_partition_id_:
4817       self.has_partition_id_ = 0;
4818       if self.partition_id_ is not None: self.partition_id_.Clear()
4819
4820   def has_partition_id(self): return self.has_partition_id_
4821
4822   def query(self):
4823     if self.query_ is None:
4824       self.lazy_init_lock_.acquire()
4825       try:
4826         if self.query_ is None: self.query_ = Query()
4827       finally:
4828         self.lazy_init_lock_.release()
4829     return self.query_
4830
4831   def mutable_query(self): self.has_query_ = 1; return self.query()
4832
4833   def clear_query(self):
4834
4835     if self.has_query_:
4836       self.has_query_ = 0;
4837       if self.query_ is not None: self.query_.Clear()
4838
4839   def has_query(self): return self.has_query_
4840
4841   def gql_query(self):
4842     if self.gql_query_ is None:
4843       self.lazy_init_lock_.acquire()
4844       try:
4845         if self.gql_query_ is None: self.gql_query_ = GqlQuery()
4846       finally:
4847         self.lazy_init_lock_.release()
4848     return self.gql_query_
4849
4850   def mutable_gql_query(self): self.has_gql_query_ = 1; return self.gql_query()
4851
4852   def clear_gql_query(self):
4853
4854     if self.has_gql_query_:
4855       self.has_gql_query_ = 0;
4856       if self.gql_query_ is not None: self.gql_query_.Clear()
4857
4858   def has_gql_query(self): return self.has_gql_query_
4859
4860   def min_safe_time_seconds(self): return self.min_safe_time_seconds_
4861
4862   def set_min_safe_time_seconds(self, x):
4863     self.has_min_safe_time_seconds_ = 1
4864     self.min_safe_time_seconds_ = x
4865
4866   def clear_min_safe_time_seconds(self):
4867     if self.has_min_safe_time_seconds_:
4868       self.has_min_safe_time_seconds_ = 0
4869       self.min_safe_time_seconds_ = 0
4870
4871   def has_min_safe_time_seconds(self): return self.has_min_safe_time_seconds_
4872
4873   def suggested_batch_size(self): return self.suggested_batch_size_
4874
4875   def set_suggested_batch_size(self, x):
4876     self.has_suggested_batch_size_ = 1
4877     self.suggested_batch_size_ = x
4878
4879   def clear_suggested_batch_size(self):
4880     if self.has_suggested_batch_size_:
4881       self.has_suggested_batch_size_ = 0
4882       self.suggested_batch_size_ = 0
4883
4884   def has_suggested_batch_size(self): return self.has_suggested_batch_size_
4885
4886
4887   def MergeFrom(self, x):
4888     assert x is not self
4889     if (x.has_read_options()): self.mutable_read_options().MergeFrom(x.read_options())
4890     if (x.has_partition_id()): self.mutable_partition_id().MergeFrom(x.partition_id())
4891     if (x.has_query()): self.mutable_query().MergeFrom(x.query())
4892     if (x.has_gql_query()): self.mutable_gql_query().MergeFrom(x.gql_query())
4893     if (x.has_min_safe_time_seconds()): self.set_min_safe_time_seconds(x.min_safe_time_seconds())
4894     if (x.has_suggested_batch_size()): self.set_suggested_batch_size(x.suggested_batch_size())
4895
4896   if _net_proto___parse__python is not None:
4897     def _CMergeFromString(self, s):
4898       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.RunQueryRequest', s)
4899
4900   if _net_proto___parse__python is not None:
4901     def _CEncode(self):
4902       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.RunQueryRequest')
4903
4904   if _net_proto___parse__python is not None:
4905     def _CEncodePartial(self):
4906       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.RunQueryRequest')
4907
4908   if _net_proto___parse__python is not None:
4909     def _CToASCII(self, output_format):
4910       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.RunQueryRequest', output_format)
4911
4912
4913   if _net_proto___parse__python is not None:
4914     def ParseASCII(self, s):
4915       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.RunQueryRequest', s)
4916
4917
4918   if _net_proto___parse__python is not None:
4919     def ParseASCIIIgnoreUnknown(self, s):
4920       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.RunQueryRequest', s)
4921
4922
4923   def Equals(self, x):
4924     if x is self: return 1
4925     if self.has_read_options_ != x.has_read_options_: return 0
4926     if self.has_read_options_ and self.read_options_ != x.read_options_: return 0
4927     if self.has_partition_id_ != x.has_partition_id_: return 0
4928     if self.has_partition_id_ and self.partition_id_ != x.partition_id_: return 0
4929     if self.has_query_ != x.has_query_: return 0
4930     if self.has_query_ and self.query_ != x.query_: return 0
4931     if self.has_gql_query_ != x.has_gql_query_: return 0
4932     if self.has_gql_query_ and self.gql_query_ != x.gql_query_: return 0
4933     if self.has_min_safe_time_seconds_ != x.has_min_safe_time_seconds_: return 0
4934     if self.has_min_safe_time_seconds_ and self.min_safe_time_seconds_ != x.min_safe_time_seconds_: return 0
4935     if self.has_suggested_batch_size_ != x.has_suggested_batch_size_: return 0
4936     if self.has_suggested_batch_size_ and self.suggested_batch_size_ != x.suggested_batch_size_: return 0
4937     return 1
4938
4939   def IsInitialized(self, debug_strs=None):
4940     initialized = 1
4941     if (self.has_read_options_ and not self.read_options_.IsInitialized(debug_strs)): initialized = 0
4942     if (self.has_partition_id_ and not self.partition_id_.IsInitialized(debug_strs)): initialized = 0
4943     if (self.has_query_ and not self.query_.IsInitialized(debug_strs)): initialized = 0
4944     if (self.has_gql_query_ and not self.gql_query_.IsInitialized(debug_strs)): initialized = 0
4945     return initialized
4946
4947   def ByteSize(self):
4948     n = 0
4949     if (self.has_read_options_): n += 1 + self.lengthString(self.read_options_.ByteSize())
4950     if (self.has_partition_id_): n += 1 + self.lengthString(self.partition_id_.ByteSize())
4951     if (self.has_query_): n += 1 + self.lengthString(self.query_.ByteSize())
4952     if (self.has_gql_query_): n += 1 + self.lengthString(self.gql_query_.ByteSize())
4953     if (self.has_min_safe_time_seconds_): n += 1 + self.lengthVarInt64(self.min_safe_time_seconds_)
4954     if (self.has_suggested_batch_size_): n += 1 + self.lengthVarInt64(self.suggested_batch_size_)
4955     return n
4956
4957   def ByteSizePartial(self):
4958     n = 0
4959     if (self.has_read_options_): n += 1 + self.lengthString(self.read_options_.ByteSizePartial())
4960     if (self.has_partition_id_): n += 1 + self.lengthString(self.partition_id_.ByteSizePartial())
4961     if (self.has_query_): n += 1 + self.lengthString(self.query_.ByteSizePartial())
4962     if (self.has_gql_query_): n += 1 + self.lengthString(self.gql_query_.ByteSizePartial())
4963     if (self.has_min_safe_time_seconds_): n += 1 + self.lengthVarInt64(self.min_safe_time_seconds_)
4964     if (self.has_suggested_batch_size_): n += 1 + self.lengthVarInt64(self.suggested_batch_size_)
4965     return n
4966
4967   def Clear(self):
4968     self.clear_read_options()
4969     self.clear_partition_id()
4970     self.clear_query()
4971     self.clear_gql_query()
4972     self.clear_min_safe_time_seconds()
4973     self.clear_suggested_batch_size()
4974
4975   def OutputUnchecked(self, out):
4976     if (self.has_read_options_):
4977       out.putVarInt32(10)
4978       out.putVarInt32(self.read_options_.ByteSize())
4979       self.read_options_.OutputUnchecked(out)
4980     if (self.has_partition_id_):
4981       out.putVarInt32(18)
4982       out.putVarInt32(self.partition_id_.ByteSize())
4983       self.partition_id_.OutputUnchecked(out)
4984     if (self.has_query_):
4985       out.putVarInt32(26)
4986       out.putVarInt32(self.query_.ByteSize())
4987       self.query_.OutputUnchecked(out)
4988     if (self.has_min_safe_time_seconds_):
4989       out.putVarInt32(32)
4990       out.putVarInt64(self.min_safe_time_seconds_)
4991     if (self.has_suggested_batch_size_):
4992       out.putVarInt32(40)
4993       out.putVarInt32(self.suggested_batch_size_)
4994     if (self.has_gql_query_):
4995       out.putVarInt32(58)
4996       out.putVarInt32(self.gql_query_.ByteSize())
4997       self.gql_query_.OutputUnchecked(out)
4998
4999   def OutputPartial(self, out):
5000     if (self.has_read_options_):
5001       out.putVarInt32(10)
5002       out.putVarInt32(self.read_options_.ByteSizePartial())
5003       self.read_options_.OutputPartial(out)
5004     if (self.has_partition_id_):
5005       out.putVarInt32(18)
5006       out.putVarInt32(self.partition_id_.ByteSizePartial())
5007       self.partition_id_.OutputPartial(out)
5008     if (self.has_query_):
5009       out.putVarInt32(26)
5010       out.putVarInt32(self.query_.ByteSizePartial())
5011       self.query_.OutputPartial(out)
5012     if (self.has_min_safe_time_seconds_):
5013       out.putVarInt32(32)
5014       out.putVarInt64(self.min_safe_time_seconds_)
5015     if (self.has_suggested_batch_size_):
5016       out.putVarInt32(40)
5017       out.putVarInt32(self.suggested_batch_size_)
5018     if (self.has_gql_query_):
5019       out.putVarInt32(58)
5020       out.putVarInt32(self.gql_query_.ByteSizePartial())
5021       self.gql_query_.OutputPartial(out)
5022
5023   def TryMerge(self, d):
5024     while d.avail() > 0:
5025       tt = d.getVarInt32()
5026       if tt == 10:
5027         length = d.getVarInt32()
5028         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5029         d.skip(length)
5030         self.mutable_read_options().TryMerge(tmp)
5031         continue
5032       if tt == 18:
5033         length = d.getVarInt32()
5034         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5035         d.skip(length)
5036         self.mutable_partition_id().TryMerge(tmp)
5037         continue
5038       if tt == 26:
5039         length = d.getVarInt32()
5040         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5041         d.skip(length)
5042         self.mutable_query().TryMerge(tmp)
5043         continue
5044       if tt == 32:
5045         self.set_min_safe_time_seconds(d.getVarInt64())
5046         continue
5047       if tt == 40:
5048         self.set_suggested_batch_size(d.getVarInt32())
5049         continue
5050       if tt == 58:
5051         length = d.getVarInt32()
5052         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5053         d.skip(length)
5054         self.mutable_gql_query().TryMerge(tmp)
5055         continue
5056
5057
5058       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5059       d.skipData(tt)
5060
5061
5062   def __str__(self, prefix="", printElemNumber=0):
5063     res=""
5064     if self.has_read_options_:
5065       res+=prefix+"read_options <\n"
5066       res+=self.read_options_.__str__(prefix + "  ", printElemNumber)
5067       res+=prefix+">\n"
5068     if self.has_partition_id_:
5069       res+=prefix+"partition_id <\n"
5070       res+=self.partition_id_.__str__(prefix + "  ", printElemNumber)
5071       res+=prefix+">\n"
5072     if self.has_query_:
5073       res+=prefix+"query <\n"
5074       res+=self.query_.__str__(prefix + "  ", printElemNumber)
5075       res+=prefix+">\n"
5076     if self.has_gql_query_:
5077       res+=prefix+"gql_query <\n"
5078       res+=self.gql_query_.__str__(prefix + "  ", printElemNumber)
5079       res+=prefix+">\n"
5080     if self.has_min_safe_time_seconds_: res+=prefix+("min_safe_time_seconds: %s\n" % self.DebugFormatInt64(self.min_safe_time_seconds_))
5081     if self.has_suggested_batch_size_: res+=prefix+("suggested_batch_size: %s\n" % self.DebugFormatInt32(self.suggested_batch_size_))
5082     return res
5083
5084
5085   def _BuildTagLookupTable(sparse, maxtag, default=None):
5086     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5087
5088   kread_options = 1
5089   kpartition_id = 2
5090   kquery = 3
5091   kgql_query = 7
5092   kmin_safe_time_seconds = 4
5093   ksuggested_batch_size = 5
5094
5095   _TEXT = _BuildTagLookupTable({
5096     0: "ErrorCode",
5097     1: "read_options",
5098     2: "partition_id",
5099     3: "query",
5100     4: "min_safe_time_seconds",
5101     5: "suggested_batch_size",
5102     7: "gql_query",
5103   }, 7)
5104
5105   _TYPES = _BuildTagLookupTable({
5106     0: ProtocolBuffer.Encoder.NUMERIC,
5107     1: ProtocolBuffer.Encoder.STRING,
5108     2: ProtocolBuffer.Encoder.STRING,
5109     3: ProtocolBuffer.Encoder.STRING,
5110     4: ProtocolBuffer.Encoder.NUMERIC,
5111     5: ProtocolBuffer.Encoder.NUMERIC,
5112     7: ProtocolBuffer.Encoder.STRING,
5113   }, 7, ProtocolBuffer.Encoder.MAX_TYPE)
5114
5115
5116   _STYLE = """"""
5117   _STYLE_CONTENT_TYPE = """"""
5118   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.RunQueryRequest'
5119   _SERIALIZED_DESCRIPTOR = array.array('B')
5120   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJ2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlJ1blF1ZXJ5UmVxdWVzdBMaDHJlYWRfb3B0aW9ucyABKAIwCzgBSiNhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5SZWFkT3B0aW9uc6MBqgEFY3R5cGWyAQZwcm90bzKkARQTGgxwYXJ0aXRpb25faWQgAigCMAs4AUojYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUGFydGl0aW9uSWSjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoFcXVlcnkgAygCMAs4AUodYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUXVlcnmjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoJZ3FsX3F1ZXJ5IAcoAjALOAFKIGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkdxbFF1ZXJ5owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaFW1pbl9zYWZlX3RpbWVfc2Vjb25kcyAEKAAwAzgBFBMaFHN1Z2dlc3RlZF9iYXRjaF9zaXplIAUoADAFOAEUwgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
5121   if _net_proto___parse__python is not None:
5122     _net_proto___parse__python.RegisterType(
5123         _SERIALIZED_DESCRIPTOR.tostring())
5124
5125 class RunQueryResponse(ProtocolBuffer.ProtocolMessage):
5126   has_batch_ = 0
5127   has_query_handle_ = 0
5128   query_handle_ = ""
5129
5130   def __init__(self, contents=None):
5131     self.batch_ = QueryResultBatch()
5132     if contents is not None: self.MergeFromString(contents)
5133
5134   def batch(self): return self.batch_
5135
5136   def mutable_batch(self): self.has_batch_ = 1; return self.batch_
5137
5138   def clear_batch(self):self.has_batch_ = 0; self.batch_.Clear()
5139
5140   def has_batch(self): return self.has_batch_
5141
5142   def query_handle(self): return self.query_handle_
5143
5144   def set_query_handle(self, x):
5145     self.has_query_handle_ = 1
5146     self.query_handle_ = x
5147
5148   def clear_query_handle(self):
5149     if self.has_query_handle_:
5150       self.has_query_handle_ = 0
5151       self.query_handle_ = ""
5152
5153   def has_query_handle(self): return self.has_query_handle_
5154
5155
5156   def MergeFrom(self, x):
5157     assert x is not self
5158     if (x.has_batch()): self.mutable_batch().MergeFrom(x.batch())
5159     if (x.has_query_handle()): self.set_query_handle(x.query_handle())
5160
5161   if _net_proto___parse__python is not None:
5162     def _CMergeFromString(self, s):
5163       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.RunQueryResponse', s)
5164
5165   if _net_proto___parse__python is not None:
5166     def _CEncode(self):
5167       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.RunQueryResponse')
5168
5169   if _net_proto___parse__python is not None:
5170     def _CEncodePartial(self):
5171       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.RunQueryResponse')
5172
5173   if _net_proto___parse__python is not None:
5174     def _CToASCII(self, output_format):
5175       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.RunQueryResponse', output_format)
5176
5177
5178   if _net_proto___parse__python is not None:
5179     def ParseASCII(self, s):
5180       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.RunQueryResponse', s)
5181
5182
5183   if _net_proto___parse__python is not None:
5184     def ParseASCIIIgnoreUnknown(self, s):
5185       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.RunQueryResponse', s)
5186
5187
5188   def Equals(self, x):
5189     if x is self: return 1
5190     if self.has_batch_ != x.has_batch_: return 0
5191     if self.has_batch_ and self.batch_ != x.batch_: return 0
5192     if self.has_query_handle_ != x.has_query_handle_: return 0
5193     if self.has_query_handle_ and self.query_handle_ != x.query_handle_: return 0
5194     return 1
5195
5196   def IsInitialized(self, debug_strs=None):
5197     initialized = 1
5198     if (not self.has_batch_):
5199       initialized = 0
5200       if debug_strs is not None:
5201         debug_strs.append('Required field: batch not set.')
5202     elif not self.batch_.IsInitialized(debug_strs): initialized = 0
5203     return initialized
5204
5205   def ByteSize(self):
5206     n = 0
5207     n += self.lengthString(self.batch_.ByteSize())
5208     if (self.has_query_handle_): n += 1 + self.lengthString(len(self.query_handle_))
5209     return n + 1
5210
5211   def ByteSizePartial(self):
5212     n = 0
5213     if (self.has_batch_):
5214       n += 1
5215       n += self.lengthString(self.batch_.ByteSizePartial())
5216     if (self.has_query_handle_): n += 1 + self.lengthString(len(self.query_handle_))
5217     return n
5218
5219   def Clear(self):
5220     self.clear_batch()
5221     self.clear_query_handle()
5222
5223   def OutputUnchecked(self, out):
5224     out.putVarInt32(10)
5225     out.putVarInt32(self.batch_.ByteSize())
5226     self.batch_.OutputUnchecked(out)
5227     if (self.has_query_handle_):
5228       out.putVarInt32(18)
5229       out.putPrefixedString(self.query_handle_)
5230
5231   def OutputPartial(self, out):
5232     if (self.has_batch_):
5233       out.putVarInt32(10)
5234       out.putVarInt32(self.batch_.ByteSizePartial())
5235       self.batch_.OutputPartial(out)
5236     if (self.has_query_handle_):
5237       out.putVarInt32(18)
5238       out.putPrefixedString(self.query_handle_)
5239
5240   def TryMerge(self, d):
5241     while d.avail() > 0:
5242       tt = d.getVarInt32()
5243       if tt == 10:
5244         length = d.getVarInt32()
5245         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5246         d.skip(length)
5247         self.mutable_batch().TryMerge(tmp)
5248         continue
5249       if tt == 18:
5250         self.set_query_handle(d.getPrefixedString())
5251         continue
5252
5253
5254       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5255       d.skipData(tt)
5256
5257
5258   def __str__(self, prefix="", printElemNumber=0):
5259     res=""
5260     if self.has_batch_:
5261       res+=prefix+"batch <\n"
5262       res+=self.batch_.__str__(prefix + "  ", printElemNumber)
5263       res+=prefix+">\n"
5264     if self.has_query_handle_: res+=prefix+("query_handle: %s\n" % self.DebugFormatString(self.query_handle_))
5265     return res
5266
5267
5268   def _BuildTagLookupTable(sparse, maxtag, default=None):
5269     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5270
5271   kbatch = 1
5272   kquery_handle = 2
5273
5274   _TEXT = _BuildTagLookupTable({
5275     0: "ErrorCode",
5276     1: "batch",
5277     2: "query_handle",
5278   }, 2)
5279
5280   _TYPES = _BuildTagLookupTable({
5281     0: ProtocolBuffer.Encoder.NUMERIC,
5282     1: ProtocolBuffer.Encoder.STRING,
5283     2: ProtocolBuffer.Encoder.STRING,
5284   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
5285
5286
5287   _STYLE = """"""
5288   _STYLE_CONTENT_TYPE = """"""
5289   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.RunQueryResponse'
5290   _SERIALIZED_DESCRIPTOR = array.array('B')
5291   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KKGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlJ1blF1ZXJ5UmVzcG9uc2UTGgViYXRjaCABKAIwCzgCSihhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5RdWVyeVJlc3VsdEJhdGNoowGqAQVjdHlwZbIBBnByb3RvMqQBFBMaDHF1ZXJ5X2hhbmRsZSACKAIwCTgBFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
5292   if _net_proto___parse__python is not None:
5293     _net_proto___parse__python.RegisterType(
5294         _SERIALIZED_DESCRIPTOR.tostring())
5295
5296 class ContinueQueryRequest(ProtocolBuffer.ProtocolMessage):
5297   has_query_handle_ = 0
5298   query_handle_ = ""
5299
5300   def __init__(self, contents=None):
5301     if contents is not None: self.MergeFromString(contents)
5302
5303   def query_handle(self): return self.query_handle_
5304
5305   def set_query_handle(self, x):
5306     self.has_query_handle_ = 1
5307     self.query_handle_ = x
5308
5309   def clear_query_handle(self):
5310     if self.has_query_handle_:
5311       self.has_query_handle_ = 0
5312       self.query_handle_ = ""
5313
5314   def has_query_handle(self): return self.has_query_handle_
5315
5316
5317   def MergeFrom(self, x):
5318     assert x is not self
5319     if (x.has_query_handle()): self.set_query_handle(x.query_handle())
5320
5321   if _net_proto___parse__python is not None:
5322     def _CMergeFromString(self, s):
5323       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.ContinueQueryRequest', s)
5324
5325   if _net_proto___parse__python is not None:
5326     def _CEncode(self):
5327       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.ContinueQueryRequest')
5328
5329   if _net_proto___parse__python is not None:
5330     def _CEncodePartial(self):
5331       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.ContinueQueryRequest')
5332
5333   if _net_proto___parse__python is not None:
5334     def _CToASCII(self, output_format):
5335       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.ContinueQueryRequest', output_format)
5336
5337
5338   if _net_proto___parse__python is not None:
5339     def ParseASCII(self, s):
5340       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.ContinueQueryRequest', s)
5341
5342
5343   if _net_proto___parse__python is not None:
5344     def ParseASCIIIgnoreUnknown(self, s):
5345       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.ContinueQueryRequest', s)
5346
5347
5348   def Equals(self, x):
5349     if x is self: return 1
5350     if self.has_query_handle_ != x.has_query_handle_: return 0
5351     if self.has_query_handle_ and self.query_handle_ != x.query_handle_: return 0
5352     return 1
5353
5354   def IsInitialized(self, debug_strs=None):
5355     initialized = 1
5356     if (not self.has_query_handle_):
5357       initialized = 0
5358       if debug_strs is not None:
5359         debug_strs.append('Required field: query_handle not set.')
5360     return initialized
5361
5362   def ByteSize(self):
5363     n = 0
5364     n += self.lengthString(len(self.query_handle_))
5365     return n + 1
5366
5367   def ByteSizePartial(self):
5368     n = 0
5369     if (self.has_query_handle_):
5370       n += 1
5371       n += self.lengthString(len(self.query_handle_))
5372     return n
5373
5374   def Clear(self):
5375     self.clear_query_handle()
5376
5377   def OutputUnchecked(self, out):
5378     out.putVarInt32(10)
5379     out.putPrefixedString(self.query_handle_)
5380
5381   def OutputPartial(self, out):
5382     if (self.has_query_handle_):
5383       out.putVarInt32(10)
5384       out.putPrefixedString(self.query_handle_)
5385
5386   def TryMerge(self, d):
5387     while d.avail() > 0:
5388       tt = d.getVarInt32()
5389       if tt == 10:
5390         self.set_query_handle(d.getPrefixedString())
5391         continue
5392
5393
5394       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5395       d.skipData(tt)
5396
5397
5398   def __str__(self, prefix="", printElemNumber=0):
5399     res=""
5400     if self.has_query_handle_: res+=prefix+("query_handle: %s\n" % self.DebugFormatString(self.query_handle_))
5401     return res
5402
5403
5404   def _BuildTagLookupTable(sparse, maxtag, default=None):
5405     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5406
5407   kquery_handle = 1
5408
5409   _TEXT = _BuildTagLookupTable({
5410     0: "ErrorCode",
5411     1: "query_handle",
5412   }, 1)
5413
5414   _TYPES = _BuildTagLookupTable({
5415     0: ProtocolBuffer.Encoder.NUMERIC,
5416     1: ProtocolBuffer.Encoder.STRING,
5417   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
5418
5419
5420   _STYLE = """"""
5421   _STYLE_CONTENT_TYPE = """"""
5422   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.ContinueQueryRequest'
5423   _SERIALIZED_DESCRIPTOR = array.array('B')
5424   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KLGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkNvbnRpbnVlUXVlcnlSZXF1ZXN0ExoMcXVlcnlfaGFuZGxlIAEoAjAJOAIUwgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
5425   if _net_proto___parse__python is not None:
5426     _net_proto___parse__python.RegisterType(
5427         _SERIALIZED_DESCRIPTOR.tostring())
5428
5429 class ContinueQueryResponse(ProtocolBuffer.ProtocolMessage):
5430   has_batch_ = 0
5431
5432   def __init__(self, contents=None):
5433     self.batch_ = QueryResultBatch()
5434     if contents is not None: self.MergeFromString(contents)
5435
5436   def batch(self): return self.batch_
5437
5438   def mutable_batch(self): self.has_batch_ = 1; return self.batch_
5439
5440   def clear_batch(self):self.has_batch_ = 0; self.batch_.Clear()
5441
5442   def has_batch(self): return self.has_batch_
5443
5444
5445   def MergeFrom(self, x):
5446     assert x is not self
5447     if (x.has_batch()): self.mutable_batch().MergeFrom(x.batch())
5448
5449   if _net_proto___parse__python is not None:
5450     def _CMergeFromString(self, s):
5451       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.ContinueQueryResponse', s)
5452
5453   if _net_proto___parse__python is not None:
5454     def _CEncode(self):
5455       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.ContinueQueryResponse')
5456
5457   if _net_proto___parse__python is not None:
5458     def _CEncodePartial(self):
5459       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.ContinueQueryResponse')
5460
5461   if _net_proto___parse__python is not None:
5462     def _CToASCII(self, output_format):
5463       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.ContinueQueryResponse', output_format)
5464
5465
5466   if _net_proto___parse__python is not None:
5467     def ParseASCII(self, s):
5468       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.ContinueQueryResponse', s)
5469
5470
5471   if _net_proto___parse__python is not None:
5472     def ParseASCIIIgnoreUnknown(self, s):
5473       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.ContinueQueryResponse', s)
5474
5475
5476   def Equals(self, x):
5477     if x is self: return 1
5478     if self.has_batch_ != x.has_batch_: return 0
5479     if self.has_batch_ and self.batch_ != x.batch_: return 0
5480     return 1
5481
5482   def IsInitialized(self, debug_strs=None):
5483     initialized = 1
5484     if (not self.has_batch_):
5485       initialized = 0
5486       if debug_strs is not None:
5487         debug_strs.append('Required field: batch not set.')
5488     elif not self.batch_.IsInitialized(debug_strs): initialized = 0
5489     return initialized
5490
5491   def ByteSize(self):
5492     n = 0
5493     n += self.lengthString(self.batch_.ByteSize())
5494     return n + 1
5495
5496   def ByteSizePartial(self):
5497     n = 0
5498     if (self.has_batch_):
5499       n += 1
5500       n += self.lengthString(self.batch_.ByteSizePartial())
5501     return n
5502
5503   def Clear(self):
5504     self.clear_batch()
5505
5506   def OutputUnchecked(self, out):
5507     out.putVarInt32(10)
5508     out.putVarInt32(self.batch_.ByteSize())
5509     self.batch_.OutputUnchecked(out)
5510
5511   def OutputPartial(self, out):
5512     if (self.has_batch_):
5513       out.putVarInt32(10)
5514       out.putVarInt32(self.batch_.ByteSizePartial())
5515       self.batch_.OutputPartial(out)
5516
5517   def TryMerge(self, d):
5518     while d.avail() > 0:
5519       tt = d.getVarInt32()
5520       if tt == 10:
5521         length = d.getVarInt32()
5522         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
5523         d.skip(length)
5524         self.mutable_batch().TryMerge(tmp)
5525         continue
5526
5527
5528       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5529       d.skipData(tt)
5530
5531
5532   def __str__(self, prefix="", printElemNumber=0):
5533     res=""
5534     if self.has_batch_:
5535       res+=prefix+"batch <\n"
5536       res+=self.batch_.__str__(prefix + "  ", printElemNumber)
5537       res+=prefix+">\n"
5538     return res
5539
5540
5541   def _BuildTagLookupTable(sparse, maxtag, default=None):
5542     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5543
5544   kbatch = 1
5545
5546   _TEXT = _BuildTagLookupTable({
5547     0: "ErrorCode",
5548     1: "batch",
5549   }, 1)
5550
5551   _TYPES = _BuildTagLookupTable({
5552     0: ProtocolBuffer.Encoder.NUMERIC,
5553     1: ProtocolBuffer.Encoder.STRING,
5554   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
5555
5556
5557   _STYLE = """"""
5558   _STYLE_CONTENT_TYPE = """"""
5559   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.ContinueQueryResponse'
5560   _SERIALIZED_DESCRIPTOR = array.array('B')
5561   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KLWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkNvbnRpbnVlUXVlcnlSZXNwb25zZRMaBWJhdGNoIAEoAjALOAJKKGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlF1ZXJ5UmVzdWx0QmF0Y2ijAaoBBWN0eXBlsgEGcHJvdG8ypAEUwgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
5562   if _net_proto___parse__python is not None:
5563     _net_proto___parse__python.RegisterType(
5564         _SERIALIZED_DESCRIPTOR.tostring())
5565
5566 class BeginTransactionRequest(ProtocolBuffer.ProtocolMessage):
5567   has_cross_group_ = 0
5568   cross_group_ = 0
5569   has_cross_request_ = 0
5570   cross_request_ = 0
5571
5572   def __init__(self, contents=None):
5573     if contents is not None: self.MergeFromString(contents)
5574
5575   def cross_group(self): return self.cross_group_
5576
5577   def set_cross_group(self, x):
5578     self.has_cross_group_ = 1
5579     self.cross_group_ = x
5580
5581   def clear_cross_group(self):
5582     if self.has_cross_group_:
5583       self.has_cross_group_ = 0
5584       self.cross_group_ = 0
5585
5586   def has_cross_group(self): return self.has_cross_group_
5587
5588   def cross_request(self): return self.cross_request_
5589
5590   def set_cross_request(self, x):
5591     self.has_cross_request_ = 1
5592     self.cross_request_ = x
5593
5594   def clear_cross_request(self):
5595     if self.has_cross_request_:
5596       self.has_cross_request_ = 0
5597       self.cross_request_ = 0
5598
5599   def has_cross_request(self): return self.has_cross_request_
5600
5601
5602   def MergeFrom(self, x):
5603     assert x is not self
5604     if (x.has_cross_group()): self.set_cross_group(x.cross_group())
5605     if (x.has_cross_request()): self.set_cross_request(x.cross_request())
5606
5607   if _net_proto___parse__python is not None:
5608     def _CMergeFromString(self, s):
5609       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.BeginTransactionRequest', s)
5610
5611   if _net_proto___parse__python is not None:
5612     def _CEncode(self):
5613       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.BeginTransactionRequest')
5614
5615   if _net_proto___parse__python is not None:
5616     def _CEncodePartial(self):
5617       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.BeginTransactionRequest')
5618
5619   if _net_proto___parse__python is not None:
5620     def _CToASCII(self, output_format):
5621       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.BeginTransactionRequest', output_format)
5622
5623
5624   if _net_proto___parse__python is not None:
5625     def ParseASCII(self, s):
5626       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.BeginTransactionRequest', s)
5627
5628
5629   if _net_proto___parse__python is not None:
5630     def ParseASCIIIgnoreUnknown(self, s):
5631       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.BeginTransactionRequest', s)
5632
5633
5634   def Equals(self, x):
5635     if x is self: return 1
5636     if self.has_cross_group_ != x.has_cross_group_: return 0
5637     if self.has_cross_group_ and self.cross_group_ != x.cross_group_: return 0
5638     if self.has_cross_request_ != x.has_cross_request_: return 0
5639     if self.has_cross_request_ and self.cross_request_ != x.cross_request_: return 0
5640     return 1
5641
5642   def IsInitialized(self, debug_strs=None):
5643     initialized = 1
5644     return initialized
5645
5646   def ByteSize(self):
5647     n = 0
5648     if (self.has_cross_group_): n += 2
5649     if (self.has_cross_request_): n += 2
5650     return n
5651
5652   def ByteSizePartial(self):
5653     n = 0
5654     if (self.has_cross_group_): n += 2
5655     if (self.has_cross_request_): n += 2
5656     return n
5657
5658   def Clear(self):
5659     self.clear_cross_group()
5660     self.clear_cross_request()
5661
5662   def OutputUnchecked(self, out):
5663     if (self.has_cross_group_):
5664       out.putVarInt32(8)
5665       out.putBoolean(self.cross_group_)
5666     if (self.has_cross_request_):
5667       out.putVarInt32(16)
5668       out.putBoolean(self.cross_request_)
5669
5670   def OutputPartial(self, out):
5671     if (self.has_cross_group_):
5672       out.putVarInt32(8)
5673       out.putBoolean(self.cross_group_)
5674     if (self.has_cross_request_):
5675       out.putVarInt32(16)
5676       out.putBoolean(self.cross_request_)
5677
5678   def TryMerge(self, d):
5679     while d.avail() > 0:
5680       tt = d.getVarInt32()
5681       if tt == 8:
5682         self.set_cross_group(d.getBoolean())
5683         continue
5684       if tt == 16:
5685         self.set_cross_request(d.getBoolean())
5686         continue
5687
5688
5689       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5690       d.skipData(tt)
5691
5692
5693   def __str__(self, prefix="", printElemNumber=0):
5694     res=""
5695     if self.has_cross_group_: res+=prefix+("cross_group: %s\n" % self.DebugFormatBool(self.cross_group_))
5696     if self.has_cross_request_: res+=prefix+("cross_request: %s\n" % self.DebugFormatBool(self.cross_request_))
5697     return res
5698
5699
5700   def _BuildTagLookupTable(sparse, maxtag, default=None):
5701     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5702
5703   kcross_group = 1
5704   kcross_request = 2
5705
5706   _TEXT = _BuildTagLookupTable({
5707     0: "ErrorCode",
5708     1: "cross_group",
5709     2: "cross_request",
5710   }, 2)
5711
5712   _TYPES = _BuildTagLookupTable({
5713     0: ProtocolBuffer.Encoder.NUMERIC,
5714     1: ProtocolBuffer.Encoder.NUMERIC,
5715     2: ProtocolBuffer.Encoder.NUMERIC,
5716   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
5717
5718
5719   _STYLE = """"""
5720   _STYLE_CONTENT_TYPE = """"""
5721   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.BeginTransactionRequest'
5722   _SERIALIZED_DESCRIPTOR = array.array('B')
5723   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KL2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkJlZ2luVHJhbnNhY3Rpb25SZXF1ZXN0ExoLY3Jvc3NfZ3JvdXAgASgAMAg4AUIFZmFsc2WjAaoBB2RlZmF1bHSyAQVmYWxzZaQBFBMaDWNyb3NzX3JlcXVlc3QgAigAMAg4AUIFZmFsc2WjAaoBB2RlZmF1bHSyAQVmYWxzZaQBFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
5724   if _net_proto___parse__python is not None:
5725     _net_proto___parse__python.RegisterType(
5726         _SERIALIZED_DESCRIPTOR.tostring())
5727
5728 class BeginTransactionResponse(ProtocolBuffer.ProtocolMessage):
5729   has_transaction_ = 0
5730   transaction_ = ""
5731
5732   def __init__(self, contents=None):
5733     if contents is not None: self.MergeFromString(contents)
5734
5735   def transaction(self): return self.transaction_
5736
5737   def set_transaction(self, x):
5738     self.has_transaction_ = 1
5739     self.transaction_ = x
5740
5741   def clear_transaction(self):
5742     if self.has_transaction_:
5743       self.has_transaction_ = 0
5744       self.transaction_ = ""
5745
5746   def has_transaction(self): return self.has_transaction_
5747
5748
5749   def MergeFrom(self, x):
5750     assert x is not self
5751     if (x.has_transaction()): self.set_transaction(x.transaction())
5752
5753   if _net_proto___parse__python is not None:
5754     def _CMergeFromString(self, s):
5755       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.BeginTransactionResponse', s)
5756
5757   if _net_proto___parse__python is not None:
5758     def _CEncode(self):
5759       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.BeginTransactionResponse')
5760
5761   if _net_proto___parse__python is not None:
5762     def _CEncodePartial(self):
5763       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.BeginTransactionResponse')
5764
5765   if _net_proto___parse__python is not None:
5766     def _CToASCII(self, output_format):
5767       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.BeginTransactionResponse', output_format)
5768
5769
5770   if _net_proto___parse__python is not None:
5771     def ParseASCII(self, s):
5772       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.BeginTransactionResponse', s)
5773
5774
5775   if _net_proto___parse__python is not None:
5776     def ParseASCIIIgnoreUnknown(self, s):
5777       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.BeginTransactionResponse', s)
5778
5779
5780   def Equals(self, x):
5781     if x is self: return 1
5782     if self.has_transaction_ != x.has_transaction_: return 0
5783     if self.has_transaction_ and self.transaction_ != x.transaction_: return 0
5784     return 1
5785
5786   def IsInitialized(self, debug_strs=None):
5787     initialized = 1
5788     if (not self.has_transaction_):
5789       initialized = 0
5790       if debug_strs is not None:
5791         debug_strs.append('Required field: transaction not set.')
5792     return initialized
5793
5794   def ByteSize(self):
5795     n = 0
5796     n += self.lengthString(len(self.transaction_))
5797     return n + 1
5798
5799   def ByteSizePartial(self):
5800     n = 0
5801     if (self.has_transaction_):
5802       n += 1
5803       n += self.lengthString(len(self.transaction_))
5804     return n
5805
5806   def Clear(self):
5807     self.clear_transaction()
5808
5809   def OutputUnchecked(self, out):
5810     out.putVarInt32(10)
5811     out.putPrefixedString(self.transaction_)
5812
5813   def OutputPartial(self, out):
5814     if (self.has_transaction_):
5815       out.putVarInt32(10)
5816       out.putPrefixedString(self.transaction_)
5817
5818   def TryMerge(self, d):
5819     while d.avail() > 0:
5820       tt = d.getVarInt32()
5821       if tt == 10:
5822         self.set_transaction(d.getPrefixedString())
5823         continue
5824
5825
5826       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5827       d.skipData(tt)
5828
5829
5830   def __str__(self, prefix="", printElemNumber=0):
5831     res=""
5832     if self.has_transaction_: res+=prefix+("transaction: %s\n" % self.DebugFormatString(self.transaction_))
5833     return res
5834
5835
5836   def _BuildTagLookupTable(sparse, maxtag, default=None):
5837     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5838
5839   ktransaction = 1
5840
5841   _TEXT = _BuildTagLookupTable({
5842     0: "ErrorCode",
5843     1: "transaction",
5844   }, 1)
5845
5846   _TYPES = _BuildTagLookupTable({
5847     0: ProtocolBuffer.Encoder.NUMERIC,
5848     1: ProtocolBuffer.Encoder.STRING,
5849   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
5850
5851
5852   _STYLE = """"""
5853   _STYLE_CONTENT_TYPE = """"""
5854   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.BeginTransactionResponse'
5855   _SERIALIZED_DESCRIPTOR = array.array('B')
5856   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KMGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkJlZ2luVHJhbnNhY3Rpb25SZXNwb25zZRMaC3RyYW5zYWN0aW9uIAEoAjAJOAIUwgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
5857   if _net_proto___parse__python is not None:
5858     _net_proto___parse__python.RegisterType(
5859         _SERIALIZED_DESCRIPTOR.tostring())
5860
5861 class RollbackRequest(ProtocolBuffer.ProtocolMessage):
5862   has_transaction_ = 0
5863   transaction_ = ""
5864
5865   def __init__(self, contents=None):
5866     if contents is not None: self.MergeFromString(contents)
5867
5868   def transaction(self): return self.transaction_
5869
5870   def set_transaction(self, x):
5871     self.has_transaction_ = 1
5872     self.transaction_ = x
5873
5874   def clear_transaction(self):
5875     if self.has_transaction_:
5876       self.has_transaction_ = 0
5877       self.transaction_ = ""
5878
5879   def has_transaction(self): return self.has_transaction_
5880
5881
5882   def MergeFrom(self, x):
5883     assert x is not self
5884     if (x.has_transaction()): self.set_transaction(x.transaction())
5885
5886   if _net_proto___parse__python is not None:
5887     def _CMergeFromString(self, s):
5888       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.RollbackRequest', s)
5889
5890   if _net_proto___parse__python is not None:
5891     def _CEncode(self):
5892       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.RollbackRequest')
5893
5894   if _net_proto___parse__python is not None:
5895     def _CEncodePartial(self):
5896       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.RollbackRequest')
5897
5898   if _net_proto___parse__python is not None:
5899     def _CToASCII(self, output_format):
5900       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.RollbackRequest', output_format)
5901
5902
5903   if _net_proto___parse__python is not None:
5904     def ParseASCII(self, s):
5905       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.RollbackRequest', s)
5906
5907
5908   if _net_proto___parse__python is not None:
5909     def ParseASCIIIgnoreUnknown(self, s):
5910       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.RollbackRequest', s)
5911
5912
5913   def Equals(self, x):
5914     if x is self: return 1
5915     if self.has_transaction_ != x.has_transaction_: return 0
5916     if self.has_transaction_ and self.transaction_ != x.transaction_: return 0
5917     return 1
5918
5919   def IsInitialized(self, debug_strs=None):
5920     initialized = 1
5921     if (not self.has_transaction_):
5922       initialized = 0
5923       if debug_strs is not None:
5924         debug_strs.append('Required field: transaction not set.')
5925     return initialized
5926
5927   def ByteSize(self):
5928     n = 0
5929     n += self.lengthString(len(self.transaction_))
5930     return n + 1
5931
5932   def ByteSizePartial(self):
5933     n = 0
5934     if (self.has_transaction_):
5935       n += 1
5936       n += self.lengthString(len(self.transaction_))
5937     return n
5938
5939   def Clear(self):
5940     self.clear_transaction()
5941
5942   def OutputUnchecked(self, out):
5943     out.putVarInt32(10)
5944     out.putPrefixedString(self.transaction_)
5945
5946   def OutputPartial(self, out):
5947     if (self.has_transaction_):
5948       out.putVarInt32(10)
5949       out.putPrefixedString(self.transaction_)
5950
5951   def TryMerge(self, d):
5952     while d.avail() > 0:
5953       tt = d.getVarInt32()
5954       if tt == 10:
5955         self.set_transaction(d.getPrefixedString())
5956         continue
5957
5958
5959       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
5960       d.skipData(tt)
5961
5962
5963   def __str__(self, prefix="", printElemNumber=0):
5964     res=""
5965     if self.has_transaction_: res+=prefix+("transaction: %s\n" % self.DebugFormatString(self.transaction_))
5966     return res
5967
5968
5969   def _BuildTagLookupTable(sparse, maxtag, default=None):
5970     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
5971
5972   ktransaction = 1
5973
5974   _TEXT = _BuildTagLookupTable({
5975     0: "ErrorCode",
5976     1: "transaction",
5977   }, 1)
5978
5979   _TYPES = _BuildTagLookupTable({
5980     0: ProtocolBuffer.Encoder.NUMERIC,
5981     1: ProtocolBuffer.Encoder.STRING,
5982   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
5983
5984
5985   _STYLE = """"""
5986   _STYLE_CONTENT_TYPE = """"""
5987   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.RollbackRequest'
5988   _SERIALIZED_DESCRIPTOR = array.array('B')
5989   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJ2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlJvbGxiYWNrUmVxdWVzdBMaC3RyYW5zYWN0aW9uIAEoAjAJOAIUwgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
5990   if _net_proto___parse__python is not None:
5991     _net_proto___parse__python.RegisterType(
5992         _SERIALIZED_DESCRIPTOR.tostring())
5993
5994 class RollbackResponse(ProtocolBuffer.ProtocolMessage):
5995
5996   def __init__(self, contents=None):
5997     pass
5998     if contents is not None: self.MergeFromString(contents)
5999
6000
6001   def MergeFrom(self, x):
6002     assert x is not self
6003
6004   if _net_proto___parse__python is not None:
6005     def _CMergeFromString(self, s):
6006       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.RollbackResponse', s)
6007
6008   if _net_proto___parse__python is not None:
6009     def _CEncode(self):
6010       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.RollbackResponse')
6011
6012   if _net_proto___parse__python is not None:
6013     def _CEncodePartial(self):
6014       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.RollbackResponse')
6015
6016   if _net_proto___parse__python is not None:
6017     def _CToASCII(self, output_format):
6018       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.RollbackResponse', output_format)
6019
6020
6021   if _net_proto___parse__python is not None:
6022     def ParseASCII(self, s):
6023       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.RollbackResponse', s)
6024
6025
6026   if _net_proto___parse__python is not None:
6027     def ParseASCIIIgnoreUnknown(self, s):
6028       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.RollbackResponse', s)
6029
6030
6031   def Equals(self, x):
6032     if x is self: return 1
6033     return 1
6034
6035   def IsInitialized(self, debug_strs=None):
6036     initialized = 1
6037     return initialized
6038
6039   def ByteSize(self):
6040     n = 0
6041     return n
6042
6043   def ByteSizePartial(self):
6044     n = 0
6045     return n
6046
6047   def Clear(self):
6048     pass
6049
6050   def OutputUnchecked(self, out):
6051     pass
6052
6053   def OutputPartial(self, out):
6054     pass
6055
6056   def TryMerge(self, d):
6057     while d.avail() > 0:
6058       tt = d.getVarInt32()
6059
6060
6061       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6062       d.skipData(tt)
6063
6064
6065   def __str__(self, prefix="", printElemNumber=0):
6066     res=""
6067     return res
6068
6069
6070   def _BuildTagLookupTable(sparse, maxtag, default=None):
6071     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6072
6073
6074   _TEXT = _BuildTagLookupTable({
6075     0: "ErrorCode",
6076   }, 0)
6077
6078   _TYPES = _BuildTagLookupTable({
6079     0: ProtocolBuffer.Encoder.NUMERIC,
6080   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
6081
6082
6083   _STYLE = """"""
6084   _STYLE_CONTENT_TYPE = """"""
6085   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.RollbackResponse'
6086   _SERIALIZED_DESCRIPTOR = array.array('B')
6087   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KKGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlJvbGxiYWNrUmVzcG9uc2XCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
6088   if _net_proto___parse__python is not None:
6089     _net_proto___parse__python.RegisterType(
6090         _SERIALIZED_DESCRIPTOR.tostring())
6091
6092 class CommitRequest(ProtocolBuffer.ProtocolMessage):
6093
6094
6095   TRANSACTIONAL =    1
6096   NON_TRANSACTIONAL =    2
6097
6098   _Mode_NAMES = {
6099     1: "TRANSACTIONAL",
6100     2: "NON_TRANSACTIONAL",
6101   }
6102
6103   def Mode_Name(cls, x): return cls._Mode_NAMES.get(x, "")
6104   Mode_Name = classmethod(Mode_Name)
6105
6106   has_transaction_ = 0
6107   transaction_ = ""
6108   has_deprecated_mutation_ = 0
6109   deprecated_mutation_ = None
6110   has_mode_ = 0
6111   mode_ = 1
6112   has_ignore_read_only_ = 0
6113   ignore_read_only_ = 0
6114
6115   def __init__(self, contents=None):
6116     self.mutation_ = []
6117     self.lazy_init_lock_ = thread.allocate_lock()
6118     if contents is not None: self.MergeFromString(contents)
6119
6120   def transaction(self): return self.transaction_
6121
6122   def set_transaction(self, x):
6123     self.has_transaction_ = 1
6124     self.transaction_ = x
6125
6126   def clear_transaction(self):
6127     if self.has_transaction_:
6128       self.has_transaction_ = 0
6129       self.transaction_ = ""
6130
6131   def has_transaction(self): return self.has_transaction_
6132
6133   def mutation_size(self): return len(self.mutation_)
6134   def mutation_list(self): return self.mutation_
6135
6136   def mutation(self, i):
6137     return self.mutation_[i]
6138
6139   def mutable_mutation(self, i):
6140     return self.mutation_[i]
6141
6142   def add_mutation(self):
6143     x = Mutation()
6144     self.mutation_.append(x)
6145     return x
6146
6147   def clear_mutation(self):
6148     self.mutation_ = []
6149   def deprecated_mutation(self):
6150     if self.deprecated_mutation_ is None:
6151       self.lazy_init_lock_.acquire()
6152       try:
6153         if self.deprecated_mutation_ is None: self.deprecated_mutation_ = DeprecatedMutation()
6154       finally:
6155         self.lazy_init_lock_.release()
6156     return self.deprecated_mutation_
6157
6158   def mutable_deprecated_mutation(self): self.has_deprecated_mutation_ = 1; return self.deprecated_mutation()
6159
6160   def clear_deprecated_mutation(self):
6161
6162     if self.has_deprecated_mutation_:
6163       self.has_deprecated_mutation_ = 0;
6164       if self.deprecated_mutation_ is not None: self.deprecated_mutation_.Clear()
6165
6166   def has_deprecated_mutation(self): return self.has_deprecated_mutation_
6167
6168   def mode(self): return self.mode_
6169
6170   def set_mode(self, x):
6171     self.has_mode_ = 1
6172     self.mode_ = x
6173
6174   def clear_mode(self):
6175     if self.has_mode_:
6176       self.has_mode_ = 0
6177       self.mode_ = 1
6178
6179   def has_mode(self): return self.has_mode_
6180
6181   def ignore_read_only(self): return self.ignore_read_only_
6182
6183   def set_ignore_read_only(self, x):
6184     self.has_ignore_read_only_ = 1
6185     self.ignore_read_only_ = x
6186
6187   def clear_ignore_read_only(self):
6188     if self.has_ignore_read_only_:
6189       self.has_ignore_read_only_ = 0
6190       self.ignore_read_only_ = 0
6191
6192   def has_ignore_read_only(self): return self.has_ignore_read_only_
6193
6194
6195   def MergeFrom(self, x):
6196     assert x is not self
6197     if (x.has_transaction()): self.set_transaction(x.transaction())
6198     for i in xrange(x.mutation_size()): self.add_mutation().CopyFrom(x.mutation(i))
6199     if (x.has_deprecated_mutation()): self.mutable_deprecated_mutation().MergeFrom(x.deprecated_mutation())
6200     if (x.has_mode()): self.set_mode(x.mode())
6201     if (x.has_ignore_read_only()): self.set_ignore_read_only(x.ignore_read_only())
6202
6203   if _net_proto___parse__python is not None:
6204     def _CMergeFromString(self, s):
6205       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.CommitRequest', s)
6206
6207   if _net_proto___parse__python is not None:
6208     def _CEncode(self):
6209       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.CommitRequest')
6210
6211   if _net_proto___parse__python is not None:
6212     def _CEncodePartial(self):
6213       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.CommitRequest')
6214
6215   if _net_proto___parse__python is not None:
6216     def _CToASCII(self, output_format):
6217       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.CommitRequest', output_format)
6218
6219
6220   if _net_proto___parse__python is not None:
6221     def ParseASCII(self, s):
6222       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.CommitRequest', s)
6223
6224
6225   if _net_proto___parse__python is not None:
6226     def ParseASCIIIgnoreUnknown(self, s):
6227       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.CommitRequest', s)
6228
6229
6230   def Equals(self, x):
6231     if x is self: return 1
6232     if self.has_transaction_ != x.has_transaction_: return 0
6233     if self.has_transaction_ and self.transaction_ != x.transaction_: return 0
6234     if len(self.mutation_) != len(x.mutation_): return 0
6235     for e1, e2 in zip(self.mutation_, x.mutation_):
6236       if e1 != e2: return 0
6237     if self.has_deprecated_mutation_ != x.has_deprecated_mutation_: return 0
6238     if self.has_deprecated_mutation_ and self.deprecated_mutation_ != x.deprecated_mutation_: return 0
6239     if self.has_mode_ != x.has_mode_: return 0
6240     if self.has_mode_ and self.mode_ != x.mode_: return 0
6241     if self.has_ignore_read_only_ != x.has_ignore_read_only_: return 0
6242     if self.has_ignore_read_only_ and self.ignore_read_only_ != x.ignore_read_only_: return 0
6243     return 1
6244
6245   def IsInitialized(self, debug_strs=None):
6246     initialized = 1
6247     for p in self.mutation_:
6248       if not p.IsInitialized(debug_strs): initialized=0
6249     if (self.has_deprecated_mutation_ and not self.deprecated_mutation_.IsInitialized(debug_strs)): initialized = 0
6250     return initialized
6251
6252   def ByteSize(self):
6253     n = 0
6254     if (self.has_transaction_): n += 1 + self.lengthString(len(self.transaction_))
6255     n += 1 * len(self.mutation_)
6256     for i in xrange(len(self.mutation_)): n += self.lengthString(self.mutation_[i].ByteSize())
6257     if (self.has_deprecated_mutation_): n += 1 + self.lengthString(self.deprecated_mutation_.ByteSize())
6258     if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
6259     if (self.has_ignore_read_only_): n += 2
6260     return n
6261
6262   def ByteSizePartial(self):
6263     n = 0
6264     if (self.has_transaction_): n += 1 + self.lengthString(len(self.transaction_))
6265     n += 1 * len(self.mutation_)
6266     for i in xrange(len(self.mutation_)): n += self.lengthString(self.mutation_[i].ByteSizePartial())
6267     if (self.has_deprecated_mutation_): n += 1 + self.lengthString(self.deprecated_mutation_.ByteSizePartial())
6268     if (self.has_mode_): n += 1 + self.lengthVarInt64(self.mode_)
6269     if (self.has_ignore_read_only_): n += 2
6270     return n
6271
6272   def Clear(self):
6273     self.clear_transaction()
6274     self.clear_mutation()
6275     self.clear_deprecated_mutation()
6276     self.clear_mode()
6277     self.clear_ignore_read_only()
6278
6279   def OutputUnchecked(self, out):
6280     if (self.has_transaction_):
6281       out.putVarInt32(10)
6282       out.putPrefixedString(self.transaction_)
6283     if (self.has_deprecated_mutation_):
6284       out.putVarInt32(18)
6285       out.putVarInt32(self.deprecated_mutation_.ByteSize())
6286       self.deprecated_mutation_.OutputUnchecked(out)
6287     if (self.has_mode_):
6288       out.putVarInt32(32)
6289       out.putVarInt32(self.mode_)
6290     for i in xrange(len(self.mutation_)):
6291       out.putVarInt32(42)
6292       out.putVarInt32(self.mutation_[i].ByteSize())
6293       self.mutation_[i].OutputUnchecked(out)
6294     if (self.has_ignore_read_only_):
6295       out.putVarInt32(48)
6296       out.putBoolean(self.ignore_read_only_)
6297
6298   def OutputPartial(self, out):
6299     if (self.has_transaction_):
6300       out.putVarInt32(10)
6301       out.putPrefixedString(self.transaction_)
6302     if (self.has_deprecated_mutation_):
6303       out.putVarInt32(18)
6304       out.putVarInt32(self.deprecated_mutation_.ByteSizePartial())
6305       self.deprecated_mutation_.OutputPartial(out)
6306     if (self.has_mode_):
6307       out.putVarInt32(32)
6308       out.putVarInt32(self.mode_)
6309     for i in xrange(len(self.mutation_)):
6310       out.putVarInt32(42)
6311       out.putVarInt32(self.mutation_[i].ByteSizePartial())
6312       self.mutation_[i].OutputPartial(out)
6313     if (self.has_ignore_read_only_):
6314       out.putVarInt32(48)
6315       out.putBoolean(self.ignore_read_only_)
6316
6317   def TryMerge(self, d):
6318     while d.avail() > 0:
6319       tt = d.getVarInt32()
6320       if tt == 10:
6321         self.set_transaction(d.getPrefixedString())
6322         continue
6323       if tt == 18:
6324         length = d.getVarInt32()
6325         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6326         d.skip(length)
6327         self.mutable_deprecated_mutation().TryMerge(tmp)
6328         continue
6329       if tt == 32:
6330         self.set_mode(d.getVarInt32())
6331         continue
6332       if tt == 42:
6333         length = d.getVarInt32()
6334         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6335         d.skip(length)
6336         self.add_mutation().TryMerge(tmp)
6337         continue
6338       if tt == 48:
6339         self.set_ignore_read_only(d.getBoolean())
6340         continue
6341
6342
6343       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6344       d.skipData(tt)
6345
6346
6347   def __str__(self, prefix="", printElemNumber=0):
6348     res=""
6349     if self.has_transaction_: res+=prefix+("transaction: %s\n" % self.DebugFormatString(self.transaction_))
6350     cnt=0
6351     for e in self.mutation_:
6352       elm=""
6353       if printElemNumber: elm="(%d)" % cnt
6354       res+=prefix+("mutation%s <\n" % elm)
6355       res+=e.__str__(prefix + "  ", printElemNumber)
6356       res+=prefix+">\n"
6357       cnt+=1
6358     if self.has_deprecated_mutation_:
6359       res+=prefix+"deprecated_mutation <\n"
6360       res+=self.deprecated_mutation_.__str__(prefix + "  ", printElemNumber)
6361       res+=prefix+">\n"
6362     if self.has_mode_: res+=prefix+("mode: %s\n" % self.DebugFormatInt32(self.mode_))
6363     if self.has_ignore_read_only_: res+=prefix+("ignore_read_only: %s\n" % self.DebugFormatBool(self.ignore_read_only_))
6364     return res
6365
6366
6367   def _BuildTagLookupTable(sparse, maxtag, default=None):
6368     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6369
6370   ktransaction = 1
6371   kmutation = 5
6372   kdeprecated_mutation = 2
6373   kmode = 4
6374   kignore_read_only = 6
6375
6376   _TEXT = _BuildTagLookupTable({
6377     0: "ErrorCode",
6378     1: "transaction",
6379     2: "deprecated_mutation",
6380     4: "mode",
6381     5: "mutation",
6382     6: "ignore_read_only",
6383   }, 6)
6384
6385   _TYPES = _BuildTagLookupTable({
6386     0: ProtocolBuffer.Encoder.NUMERIC,
6387     1: ProtocolBuffer.Encoder.STRING,
6388     2: ProtocolBuffer.Encoder.STRING,
6389     4: ProtocolBuffer.Encoder.NUMERIC,
6390     5: ProtocolBuffer.Encoder.STRING,
6391     6: ProtocolBuffer.Encoder.NUMERIC,
6392   }, 6, ProtocolBuffer.Encoder.MAX_TYPE)
6393
6394
6395   _STYLE = """"""
6396   _STYLE_CONTENT_TYPE = """"""
6397   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.CommitRequest'
6398   _SERIALIZED_DESCRIPTOR = array.array('B')
6399   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkNvbW1pdFJlcXVlc3QTGgt0cmFuc2FjdGlvbiABKAIwCTgBFBMaCG11dGF0aW9uIAUoAjALOANKIGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0Lk11dGF0aW9uowGqAQVjdHlwZbIBBnByb3RvMqQBFBMaE2RlcHJlY2F0ZWRfbXV0YXRpb24gAigCMAs4AUoqYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRGVwcmVjYXRlZE11dGF0aW9uowGqAQVjdHlwZbIBBnByb3RvMqQBFBMaBG1vZGUgBCgAMAU4AUIBMWgAowGqAQdkZWZhdWx0sgENVFJBTlNBQ1RJT05BTKQBFBMaEGlnbm9yZV9yZWFkX29ubHkgBigAMAg4AUIFZmFsc2WjAaoBB2RlZmF1bHSyAQVmYWxzZaQBFHN6BE1vZGWLAZIBDVRSQU5TQUNUSU9OQUyYAQGMAYsBkgERTk9OX1RSQU5TQUNUSU9OQUyYAQKMAXTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
6400   if _net_proto___parse__python is not None:
6401     _net_proto___parse__python.RegisterType(
6402         _SERIALIZED_DESCRIPTOR.tostring())
6403
6404 class CommitResponse(ProtocolBuffer.ProtocolMessage):
6405   has_deprecated_mutation_result_ = 0
6406   deprecated_mutation_result_ = None
6407   has_index_updates_ = 0
6408   index_updates_ = 0
6409
6410   def __init__(self, contents=None):
6411     self.mutation_result_ = []
6412     self.lazy_init_lock_ = thread.allocate_lock()
6413     if contents is not None: self.MergeFromString(contents)
6414
6415   def mutation_result_size(self): return len(self.mutation_result_)
6416   def mutation_result_list(self): return self.mutation_result_
6417
6418   def mutation_result(self, i):
6419     return self.mutation_result_[i]
6420
6421   def mutable_mutation_result(self, i):
6422     return self.mutation_result_[i]
6423
6424   def add_mutation_result(self):
6425     x = MutationResult()
6426     self.mutation_result_.append(x)
6427     return x
6428
6429   def clear_mutation_result(self):
6430     self.mutation_result_ = []
6431   def deprecated_mutation_result(self):
6432     if self.deprecated_mutation_result_ is None:
6433       self.lazy_init_lock_.acquire()
6434       try:
6435         if self.deprecated_mutation_result_ is None: self.deprecated_mutation_result_ = DeprecatedMutationResult()
6436       finally:
6437         self.lazy_init_lock_.release()
6438     return self.deprecated_mutation_result_
6439
6440   def mutable_deprecated_mutation_result(self): self.has_deprecated_mutation_result_ = 1; return self.deprecated_mutation_result()
6441
6442   def clear_deprecated_mutation_result(self):
6443
6444     if self.has_deprecated_mutation_result_:
6445       self.has_deprecated_mutation_result_ = 0;
6446       if self.deprecated_mutation_result_ is not None: self.deprecated_mutation_result_.Clear()
6447
6448   def has_deprecated_mutation_result(self): return self.has_deprecated_mutation_result_
6449
6450   def index_updates(self): return self.index_updates_
6451
6452   def set_index_updates(self, x):
6453     self.has_index_updates_ = 1
6454     self.index_updates_ = x
6455
6456   def clear_index_updates(self):
6457     if self.has_index_updates_:
6458       self.has_index_updates_ = 0
6459       self.index_updates_ = 0
6460
6461   def has_index_updates(self): return self.has_index_updates_
6462
6463
6464   def MergeFrom(self, x):
6465     assert x is not self
6466     for i in xrange(x.mutation_result_size()): self.add_mutation_result().CopyFrom(x.mutation_result(i))
6467     if (x.has_deprecated_mutation_result()): self.mutable_deprecated_mutation_result().MergeFrom(x.deprecated_mutation_result())
6468     if (x.has_index_updates()): self.set_index_updates(x.index_updates())
6469
6470   if _net_proto___parse__python is not None:
6471     def _CMergeFromString(self, s):
6472       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.CommitResponse', s)
6473
6474   if _net_proto___parse__python is not None:
6475     def _CEncode(self):
6476       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.CommitResponse')
6477
6478   if _net_proto___parse__python is not None:
6479     def _CEncodePartial(self):
6480       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.CommitResponse')
6481
6482   if _net_proto___parse__python is not None:
6483     def _CToASCII(self, output_format):
6484       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.CommitResponse', output_format)
6485
6486
6487   if _net_proto___parse__python is not None:
6488     def ParseASCII(self, s):
6489       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.CommitResponse', s)
6490
6491
6492   if _net_proto___parse__python is not None:
6493     def ParseASCIIIgnoreUnknown(self, s):
6494       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.CommitResponse', s)
6495
6496
6497   def Equals(self, x):
6498     if x is self: return 1
6499     if len(self.mutation_result_) != len(x.mutation_result_): return 0
6500     for e1, e2 in zip(self.mutation_result_, x.mutation_result_):
6501       if e1 != e2: return 0
6502     if self.has_deprecated_mutation_result_ != x.has_deprecated_mutation_result_: return 0
6503     if self.has_deprecated_mutation_result_ and self.deprecated_mutation_result_ != x.deprecated_mutation_result_: return 0
6504     if self.has_index_updates_ != x.has_index_updates_: return 0
6505     if self.has_index_updates_ and self.index_updates_ != x.index_updates_: return 0
6506     return 1
6507
6508   def IsInitialized(self, debug_strs=None):
6509     initialized = 1
6510     for p in self.mutation_result_:
6511       if not p.IsInitialized(debug_strs): initialized=0
6512     if (self.has_deprecated_mutation_result_ and not self.deprecated_mutation_result_.IsInitialized(debug_strs)): initialized = 0
6513     return initialized
6514
6515   def ByteSize(self):
6516     n = 0
6517     n += 1 * len(self.mutation_result_)
6518     for i in xrange(len(self.mutation_result_)): n += self.lengthString(self.mutation_result_[i].ByteSize())
6519     if (self.has_deprecated_mutation_result_): n += 1 + self.lengthString(self.deprecated_mutation_result_.ByteSize())
6520     if (self.has_index_updates_): n += 1 + self.lengthVarInt64(self.index_updates_)
6521     return n
6522
6523   def ByteSizePartial(self):
6524     n = 0
6525     n += 1 * len(self.mutation_result_)
6526     for i in xrange(len(self.mutation_result_)): n += self.lengthString(self.mutation_result_[i].ByteSizePartial())
6527     if (self.has_deprecated_mutation_result_): n += 1 + self.lengthString(self.deprecated_mutation_result_.ByteSizePartial())
6528     if (self.has_index_updates_): n += 1 + self.lengthVarInt64(self.index_updates_)
6529     return n
6530
6531   def Clear(self):
6532     self.clear_mutation_result()
6533     self.clear_deprecated_mutation_result()
6534     self.clear_index_updates()
6535
6536   def OutputUnchecked(self, out):
6537     if (self.has_deprecated_mutation_result_):
6538       out.putVarInt32(10)
6539       out.putVarInt32(self.deprecated_mutation_result_.ByteSize())
6540       self.deprecated_mutation_result_.OutputUnchecked(out)
6541     for i in xrange(len(self.mutation_result_)):
6542       out.putVarInt32(26)
6543       out.putVarInt32(self.mutation_result_[i].ByteSize())
6544       self.mutation_result_[i].OutputUnchecked(out)
6545     if (self.has_index_updates_):
6546       out.putVarInt32(32)
6547       out.putVarInt32(self.index_updates_)
6548
6549   def OutputPartial(self, out):
6550     if (self.has_deprecated_mutation_result_):
6551       out.putVarInt32(10)
6552       out.putVarInt32(self.deprecated_mutation_result_.ByteSizePartial())
6553       self.deprecated_mutation_result_.OutputPartial(out)
6554     for i in xrange(len(self.mutation_result_)):
6555       out.putVarInt32(26)
6556       out.putVarInt32(self.mutation_result_[i].ByteSizePartial())
6557       self.mutation_result_[i].OutputPartial(out)
6558     if (self.has_index_updates_):
6559       out.putVarInt32(32)
6560       out.putVarInt32(self.index_updates_)
6561
6562   def TryMerge(self, d):
6563     while d.avail() > 0:
6564       tt = d.getVarInt32()
6565       if tt == 10:
6566         length = d.getVarInt32()
6567         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6568         d.skip(length)
6569         self.mutable_deprecated_mutation_result().TryMerge(tmp)
6570         continue
6571       if tt == 26:
6572         length = d.getVarInt32()
6573         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6574         d.skip(length)
6575         self.add_mutation_result().TryMerge(tmp)
6576         continue
6577       if tt == 32:
6578         self.set_index_updates(d.getVarInt32())
6579         continue
6580
6581
6582       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6583       d.skipData(tt)
6584
6585
6586   def __str__(self, prefix="", printElemNumber=0):
6587     res=""
6588     cnt=0
6589     for e in self.mutation_result_:
6590       elm=""
6591       if printElemNumber: elm="(%d)" % cnt
6592       res+=prefix+("mutation_result%s <\n" % elm)
6593       res+=e.__str__(prefix + "  ", printElemNumber)
6594       res+=prefix+">\n"
6595       cnt+=1
6596     if self.has_deprecated_mutation_result_:
6597       res+=prefix+"deprecated_mutation_result <\n"
6598       res+=self.deprecated_mutation_result_.__str__(prefix + "  ", printElemNumber)
6599       res+=prefix+">\n"
6600     if self.has_index_updates_: res+=prefix+("index_updates: %s\n" % self.DebugFormatInt32(self.index_updates_))
6601     return res
6602
6603
6604   def _BuildTagLookupTable(sparse, maxtag, default=None):
6605     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6606
6607   kmutation_result = 3
6608   kdeprecated_mutation_result = 1
6609   kindex_updates = 4
6610
6611   _TEXT = _BuildTagLookupTable({
6612     0: "ErrorCode",
6613     1: "deprecated_mutation_result",
6614     3: "mutation_result",
6615     4: "index_updates",
6616   }, 4)
6617
6618   _TYPES = _BuildTagLookupTable({
6619     0: ProtocolBuffer.Encoder.NUMERIC,
6620     1: ProtocolBuffer.Encoder.STRING,
6621     3: ProtocolBuffer.Encoder.STRING,
6622     4: ProtocolBuffer.Encoder.NUMERIC,
6623   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
6624
6625
6626   _STYLE = """"""
6627   _STYLE_CONTENT_TYPE = """"""
6628   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.CommitResponse'
6629   _SERIALIZED_DESCRIPTOR = array.array('B')
6630   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkNvbW1pdFJlc3BvbnNlExoPbXV0YXRpb25fcmVzdWx0IAMoAjALOANKJmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0Lk11dGF0aW9uUmVzdWx0owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaGmRlcHJlY2F0ZWRfbXV0YXRpb25fcmVzdWx0IAEoAjALOAFKMGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkRlcHJlY2F0ZWRNdXRhdGlvblJlc3VsdKMBqgEFY3R5cGWyAQZwcm90bzKkARQTGg1pbmRleF91cGRhdGVzIAQoADAFOAEUwgEdYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRXJyb3I="))
6631   if _net_proto___parse__python is not None:
6632     _net_proto___parse__python.RegisterType(
6633         _SERIALIZED_DESCRIPTOR.tostring())
6634
6635 class AllocateIdsRequest(ProtocolBuffer.ProtocolMessage):
6636
6637   def __init__(self, contents=None):
6638     self.allocate_ = []
6639     self.reserve_ = []
6640     if contents is not None: self.MergeFromString(contents)
6641
6642   def allocate_size(self): return len(self.allocate_)
6643   def allocate_list(self): return self.allocate_
6644
6645   def allocate(self, i):
6646     return self.allocate_[i]
6647
6648   def mutable_allocate(self, i):
6649     return self.allocate_[i]
6650
6651   def add_allocate(self):
6652     x = google.appengine.datastore.entity_v4_pb.Key()
6653     self.allocate_.append(x)
6654     return x
6655
6656   def clear_allocate(self):
6657     self.allocate_ = []
6658   def reserve_size(self): return len(self.reserve_)
6659   def reserve_list(self): return self.reserve_
6660
6661   def reserve(self, i):
6662     return self.reserve_[i]
6663
6664   def mutable_reserve(self, i):
6665     return self.reserve_[i]
6666
6667   def add_reserve(self):
6668     x = google.appengine.datastore.entity_v4_pb.Key()
6669     self.reserve_.append(x)
6670     return x
6671
6672   def clear_reserve(self):
6673     self.reserve_ = []
6674
6675   def MergeFrom(self, x):
6676     assert x is not self
6677     for i in xrange(x.allocate_size()): self.add_allocate().CopyFrom(x.allocate(i))
6678     for i in xrange(x.reserve_size()): self.add_reserve().CopyFrom(x.reserve(i))
6679
6680   if _net_proto___parse__python is not None:
6681     def _CMergeFromString(self, s):
6682       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.AllocateIdsRequest', s)
6683
6684   if _net_proto___parse__python is not None:
6685     def _CEncode(self):
6686       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.AllocateIdsRequest')
6687
6688   if _net_proto___parse__python is not None:
6689     def _CEncodePartial(self):
6690       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.AllocateIdsRequest')
6691
6692   if _net_proto___parse__python is not None:
6693     def _CToASCII(self, output_format):
6694       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.AllocateIdsRequest', output_format)
6695
6696
6697   if _net_proto___parse__python is not None:
6698     def ParseASCII(self, s):
6699       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.AllocateIdsRequest', s)
6700
6701
6702   if _net_proto___parse__python is not None:
6703     def ParseASCIIIgnoreUnknown(self, s):
6704       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.AllocateIdsRequest', s)
6705
6706
6707   def Equals(self, x):
6708     if x is self: return 1
6709     if len(self.allocate_) != len(x.allocate_): return 0
6710     for e1, e2 in zip(self.allocate_, x.allocate_):
6711       if e1 != e2: return 0
6712     if len(self.reserve_) != len(x.reserve_): return 0
6713     for e1, e2 in zip(self.reserve_, x.reserve_):
6714       if e1 != e2: return 0
6715     return 1
6716
6717   def IsInitialized(self, debug_strs=None):
6718     initialized = 1
6719     for p in self.allocate_:
6720       if not p.IsInitialized(debug_strs): initialized=0
6721     for p in self.reserve_:
6722       if not p.IsInitialized(debug_strs): initialized=0
6723     return initialized
6724
6725   def ByteSize(self):
6726     n = 0
6727     n += 1 * len(self.allocate_)
6728     for i in xrange(len(self.allocate_)): n += self.lengthString(self.allocate_[i].ByteSize())
6729     n += 1 * len(self.reserve_)
6730     for i in xrange(len(self.reserve_)): n += self.lengthString(self.reserve_[i].ByteSize())
6731     return n
6732
6733   def ByteSizePartial(self):
6734     n = 0
6735     n += 1 * len(self.allocate_)
6736     for i in xrange(len(self.allocate_)): n += self.lengthString(self.allocate_[i].ByteSizePartial())
6737     n += 1 * len(self.reserve_)
6738     for i in xrange(len(self.reserve_)): n += self.lengthString(self.reserve_[i].ByteSizePartial())
6739     return n
6740
6741   def Clear(self):
6742     self.clear_allocate()
6743     self.clear_reserve()
6744
6745   def OutputUnchecked(self, out):
6746     for i in xrange(len(self.allocate_)):
6747       out.putVarInt32(10)
6748       out.putVarInt32(self.allocate_[i].ByteSize())
6749       self.allocate_[i].OutputUnchecked(out)
6750     for i in xrange(len(self.reserve_)):
6751       out.putVarInt32(18)
6752       out.putVarInt32(self.reserve_[i].ByteSize())
6753       self.reserve_[i].OutputUnchecked(out)
6754
6755   def OutputPartial(self, out):
6756     for i in xrange(len(self.allocate_)):
6757       out.putVarInt32(10)
6758       out.putVarInt32(self.allocate_[i].ByteSizePartial())
6759       self.allocate_[i].OutputPartial(out)
6760     for i in xrange(len(self.reserve_)):
6761       out.putVarInt32(18)
6762       out.putVarInt32(self.reserve_[i].ByteSizePartial())
6763       self.reserve_[i].OutputPartial(out)
6764
6765   def TryMerge(self, d):
6766     while d.avail() > 0:
6767       tt = d.getVarInt32()
6768       if tt == 10:
6769         length = d.getVarInt32()
6770         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6771         d.skip(length)
6772         self.add_allocate().TryMerge(tmp)
6773         continue
6774       if tt == 18:
6775         length = d.getVarInt32()
6776         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6777         d.skip(length)
6778         self.add_reserve().TryMerge(tmp)
6779         continue
6780
6781
6782       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6783       d.skipData(tt)
6784
6785
6786   def __str__(self, prefix="", printElemNumber=0):
6787     res=""
6788     cnt=0
6789     for e in self.allocate_:
6790       elm=""
6791       if printElemNumber: elm="(%d)" % cnt
6792       res+=prefix+("allocate%s <\n" % elm)
6793       res+=e.__str__(prefix + "  ", printElemNumber)
6794       res+=prefix+">\n"
6795       cnt+=1
6796     cnt=0
6797     for e in self.reserve_:
6798       elm=""
6799       if printElemNumber: elm="(%d)" % cnt
6800       res+=prefix+("reserve%s <\n" % elm)
6801       res+=e.__str__(prefix + "  ", printElemNumber)
6802       res+=prefix+">\n"
6803       cnt+=1
6804     return res
6805
6806
6807   def _BuildTagLookupTable(sparse, maxtag, default=None):
6808     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6809
6810   kallocate = 1
6811   kreserve = 2
6812
6813   _TEXT = _BuildTagLookupTable({
6814     0: "ErrorCode",
6815     1: "allocate",
6816     2: "reserve",
6817   }, 2)
6818
6819   _TYPES = _BuildTagLookupTable({
6820     0: ProtocolBuffer.Encoder.NUMERIC,
6821     1: ProtocolBuffer.Encoder.STRING,
6822     2: ProtocolBuffer.Encoder.STRING,
6823   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
6824
6825
6826   _STYLE = """"""
6827   _STYLE_CONTENT_TYPE = """"""
6828   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.AllocateIdsRequest'
6829   _SERIALIZED_DESCRIPTOR = array.array('B')
6830   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KKmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkFsbG9jYXRlSWRzUmVxdWVzdBMaCGFsbG9jYXRlIAEoAjALOANKG2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleaMBqgEFY3R5cGWyAQZwcm90bzKkARQTGgdyZXNlcnZlIAIoAjALOANKG2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleaMBqgEFY3R5cGWyAQZwcm90bzKkARTCAR1hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FcnJvcg=="))
6831   if _net_proto___parse__python is not None:
6832     _net_proto___parse__python.RegisterType(
6833         _SERIALIZED_DESCRIPTOR.tostring())
6834
6835 class AllocateIdsResponse(ProtocolBuffer.ProtocolMessage):
6836
6837   def __init__(self, contents=None):
6838     self.allocated_ = []
6839     if contents is not None: self.MergeFromString(contents)
6840
6841   def allocated_size(self): return len(self.allocated_)
6842   def allocated_list(self): return self.allocated_
6843
6844   def allocated(self, i):
6845     return self.allocated_[i]
6846
6847   def mutable_allocated(self, i):
6848     return self.allocated_[i]
6849
6850   def add_allocated(self):
6851     x = google.appengine.datastore.entity_v4_pb.Key()
6852     self.allocated_.append(x)
6853     return x
6854
6855   def clear_allocated(self):
6856     self.allocated_ = []
6857
6858   def MergeFrom(self, x):
6859     assert x is not self
6860     for i in xrange(x.allocated_size()): self.add_allocated().CopyFrom(x.allocated(i))
6861
6862   if _net_proto___parse__python is not None:
6863     def _CMergeFromString(self, s):
6864       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.AllocateIdsResponse', s)
6865
6866   if _net_proto___parse__python is not None:
6867     def _CEncode(self):
6868       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.AllocateIdsResponse')
6869
6870   if _net_proto___parse__python is not None:
6871     def _CEncodePartial(self):
6872       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.AllocateIdsResponse')
6873
6874   if _net_proto___parse__python is not None:
6875     def _CToASCII(self, output_format):
6876       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.AllocateIdsResponse', output_format)
6877
6878
6879   if _net_proto___parse__python is not None:
6880     def ParseASCII(self, s):
6881       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.AllocateIdsResponse', s)
6882
6883
6884   if _net_proto___parse__python is not None:
6885     def ParseASCIIIgnoreUnknown(self, s):
6886       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.AllocateIdsResponse', s)
6887
6888
6889   def Equals(self, x):
6890     if x is self: return 1
6891     if len(self.allocated_) != len(x.allocated_): return 0
6892     for e1, e2 in zip(self.allocated_, x.allocated_):
6893       if e1 != e2: return 0
6894     return 1
6895
6896   def IsInitialized(self, debug_strs=None):
6897     initialized = 1
6898     for p in self.allocated_:
6899       if not p.IsInitialized(debug_strs): initialized=0
6900     return initialized
6901
6902   def ByteSize(self):
6903     n = 0
6904     n += 1 * len(self.allocated_)
6905     for i in xrange(len(self.allocated_)): n += self.lengthString(self.allocated_[i].ByteSize())
6906     return n
6907
6908   def ByteSizePartial(self):
6909     n = 0
6910     n += 1 * len(self.allocated_)
6911     for i in xrange(len(self.allocated_)): n += self.lengthString(self.allocated_[i].ByteSizePartial())
6912     return n
6913
6914   def Clear(self):
6915     self.clear_allocated()
6916
6917   def OutputUnchecked(self, out):
6918     for i in xrange(len(self.allocated_)):
6919       out.putVarInt32(10)
6920       out.putVarInt32(self.allocated_[i].ByteSize())
6921       self.allocated_[i].OutputUnchecked(out)
6922
6923   def OutputPartial(self, out):
6924     for i in xrange(len(self.allocated_)):
6925       out.putVarInt32(10)
6926       out.putVarInt32(self.allocated_[i].ByteSizePartial())
6927       self.allocated_[i].OutputPartial(out)
6928
6929   def TryMerge(self, d):
6930     while d.avail() > 0:
6931       tt = d.getVarInt32()
6932       if tt == 10:
6933         length = d.getVarInt32()
6934         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
6935         d.skip(length)
6936         self.add_allocated().TryMerge(tmp)
6937         continue
6938
6939
6940       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
6941       d.skipData(tt)
6942
6943
6944   def __str__(self, prefix="", printElemNumber=0):
6945     res=""
6946     cnt=0
6947     for e in self.allocated_:
6948       elm=""
6949       if printElemNumber: elm="(%d)" % cnt
6950       res+=prefix+("allocated%s <\n" % elm)
6951       res+=e.__str__(prefix + "  ", printElemNumber)
6952       res+=prefix+">\n"
6953       cnt+=1
6954     return res
6955
6956
6957   def _BuildTagLookupTable(sparse, maxtag, default=None):
6958     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
6959
6960   kallocated = 1
6961
6962   _TEXT = _BuildTagLookupTable({
6963     0: "ErrorCode",
6964     1: "allocated",
6965   }, 1)
6966
6967   _TYPES = _BuildTagLookupTable({
6968     0: ProtocolBuffer.Encoder.NUMERIC,
6969     1: ProtocolBuffer.Encoder.STRING,
6970   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
6971
6972
6973   _STYLE = """"""
6974   _STYLE_CONTENT_TYPE = """"""
6975   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.AllocateIdsResponse'
6976   _SERIALIZED_DESCRIPTOR = array.array('B')
6977   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KK2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkFsbG9jYXRlSWRzUmVzcG9uc2UTGglhbGxvY2F0ZWQgASgCMAs4A0obYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuS2V5owGqAQVjdHlwZbIBBnByb3RvMqQBFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
6978   if _net_proto___parse__python is not None:
6979     _net_proto___parse__python.RegisterType(
6980         _SERIALIZED_DESCRIPTOR.tostring())
6981
6982 class WriteRequest(ProtocolBuffer.ProtocolMessage):
6983   has_deprecated_mutation_ = 0
6984
6985   def __init__(self, contents=None):
6986     self.deprecated_mutation_ = DeprecatedMutation()
6987     if contents is not None: self.MergeFromString(contents)
6988
6989   def deprecated_mutation(self): return self.deprecated_mutation_
6990
6991   def mutable_deprecated_mutation(self): self.has_deprecated_mutation_ = 1; return self.deprecated_mutation_
6992
6993   def clear_deprecated_mutation(self):self.has_deprecated_mutation_ = 0; self.deprecated_mutation_.Clear()
6994
6995   def has_deprecated_mutation(self): return self.has_deprecated_mutation_
6996
6997
6998   def MergeFrom(self, x):
6999     assert x is not self
7000     if (x.has_deprecated_mutation()): self.mutable_deprecated_mutation().MergeFrom(x.deprecated_mutation())
7001
7002   if _net_proto___parse__python is not None:
7003     def _CMergeFromString(self, s):
7004       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.WriteRequest', s)
7005
7006   if _net_proto___parse__python is not None:
7007     def _CEncode(self):
7008       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.WriteRequest')
7009
7010   if _net_proto___parse__python is not None:
7011     def _CEncodePartial(self):
7012       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.WriteRequest')
7013
7014   if _net_proto___parse__python is not None:
7015     def _CToASCII(self, output_format):
7016       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.WriteRequest', output_format)
7017
7018
7019   if _net_proto___parse__python is not None:
7020     def ParseASCII(self, s):
7021       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.WriteRequest', s)
7022
7023
7024   if _net_proto___parse__python is not None:
7025     def ParseASCIIIgnoreUnknown(self, s):
7026       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.WriteRequest', s)
7027
7028
7029   def Equals(self, x):
7030     if x is self: return 1
7031     if self.has_deprecated_mutation_ != x.has_deprecated_mutation_: return 0
7032     if self.has_deprecated_mutation_ and self.deprecated_mutation_ != x.deprecated_mutation_: return 0
7033     return 1
7034
7035   def IsInitialized(self, debug_strs=None):
7036     initialized = 1
7037     if (not self.has_deprecated_mutation_):
7038       initialized = 0
7039       if debug_strs is not None:
7040         debug_strs.append('Required field: deprecated_mutation not set.')
7041     elif not self.deprecated_mutation_.IsInitialized(debug_strs): initialized = 0
7042     return initialized
7043
7044   def ByteSize(self):
7045     n = 0
7046     n += self.lengthString(self.deprecated_mutation_.ByteSize())
7047     return n + 1
7048
7049   def ByteSizePartial(self):
7050     n = 0
7051     if (self.has_deprecated_mutation_):
7052       n += 1
7053       n += self.lengthString(self.deprecated_mutation_.ByteSizePartial())
7054     return n
7055
7056   def Clear(self):
7057     self.clear_deprecated_mutation()
7058
7059   def OutputUnchecked(self, out):
7060     out.putVarInt32(10)
7061     out.putVarInt32(self.deprecated_mutation_.ByteSize())
7062     self.deprecated_mutation_.OutputUnchecked(out)
7063
7064   def OutputPartial(self, out):
7065     if (self.has_deprecated_mutation_):
7066       out.putVarInt32(10)
7067       out.putVarInt32(self.deprecated_mutation_.ByteSizePartial())
7068       self.deprecated_mutation_.OutputPartial(out)
7069
7070   def TryMerge(self, d):
7071     while d.avail() > 0:
7072       tt = d.getVarInt32()
7073       if tt == 10:
7074         length = d.getVarInt32()
7075         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
7076         d.skip(length)
7077         self.mutable_deprecated_mutation().TryMerge(tmp)
7078         continue
7079
7080
7081       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
7082       d.skipData(tt)
7083
7084
7085   def __str__(self, prefix="", printElemNumber=0):
7086     res=""
7087     if self.has_deprecated_mutation_:
7088       res+=prefix+"deprecated_mutation <\n"
7089       res+=self.deprecated_mutation_.__str__(prefix + "  ", printElemNumber)
7090       res+=prefix+">\n"
7091     return res
7092
7093
7094   def _BuildTagLookupTable(sparse, maxtag, default=None):
7095     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
7096
7097   kdeprecated_mutation = 1
7098
7099   _TEXT = _BuildTagLookupTable({
7100     0: "ErrorCode",
7101     1: "deprecated_mutation",
7102   }, 1)
7103
7104   _TYPES = _BuildTagLookupTable({
7105     0: ProtocolBuffer.Encoder.NUMERIC,
7106     1: ProtocolBuffer.Encoder.STRING,
7107   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
7108
7109
7110   _STYLE = """"""
7111   _STYLE_CONTENT_TYPE = """"""
7112   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.WriteRequest'
7113   _SERIALIZED_DESCRIPTOR = array.array('B')
7114   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WidhcHBob3N0aW5nL2RhdGFzdG9yZS9kYXRhc3RvcmVfdjQucHJvdG8KJGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LldyaXRlUmVxdWVzdBMaE2RlcHJlY2F0ZWRfbXV0YXRpb24gASgCMAs4AkoqYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRGVwcmVjYXRlZE11dGF0aW9uowGqAQVjdHlwZbIBBnByb3RvMqQBFMIBHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVycm9y"))
7115   if _net_proto___parse__python is not None:
7116     _net_proto___parse__python.RegisterType(
7117         _SERIALIZED_DESCRIPTOR.tostring())
7118
7119
7120
7121 class _DatastoreV4Service_ClientBaseStub(_client_stub_base_class):
7122   """Makes Stubby RPC calls to a DatastoreV4Service server."""
7123
7124   __slots__ = (
7125       '_protorpc_BeginTransaction', '_full_name_BeginTransaction',
7126       '_protorpc_Rollback', '_full_name_Rollback',
7127       '_protorpc_Commit', '_full_name_Commit',
7128       '_protorpc_RunQuery', '_full_name_RunQuery',
7129       '_protorpc_ContinueQuery', '_full_name_ContinueQuery',
7130       '_protorpc_Lookup', '_full_name_Lookup',
7131       '_protorpc_AllocateIds', '_full_name_AllocateIds',
7132       '_protorpc_Get', '_full_name_Get',
7133       '_protorpc_Write', '_full_name_Write',
7134   )
7135
7136   def __init__(self, rpc_stub):
7137     self._stub = rpc_stub
7138
7139     self._protorpc_BeginTransaction = pywraprpc.RPC()
7140     self._full_name_BeginTransaction = self._stub.GetFullMethodName(
7141         'BeginTransaction')
7142
7143     self._protorpc_Rollback = pywraprpc.RPC()
7144     self._full_name_Rollback = self._stub.GetFullMethodName(
7145         'Rollback')
7146
7147     self._protorpc_Commit = pywraprpc.RPC()
7148     self._full_name_Commit = self._stub.GetFullMethodName(
7149         'Commit')
7150
7151     self._protorpc_RunQuery = pywraprpc.RPC()
7152     self._full_name_RunQuery = self._stub.GetFullMethodName(
7153         'RunQuery')
7154
7155     self._protorpc_ContinueQuery = pywraprpc.RPC()
7156     self._full_name_ContinueQuery = self._stub.GetFullMethodName(
7157         'ContinueQuery')
7158
7159     self._protorpc_Lookup = pywraprpc.RPC()
7160     self._full_name_Lookup = self._stub.GetFullMethodName(
7161         'Lookup')
7162
7163     self._protorpc_AllocateIds = pywraprpc.RPC()
7164     self._full_name_AllocateIds = self._stub.GetFullMethodName(
7165         'AllocateIds')
7166
7167     self._protorpc_Get = pywraprpc.RPC()
7168     self._full_name_Get = self._stub.GetFullMethodName(
7169         'Get')
7170
7171     self._protorpc_Write = pywraprpc.RPC()
7172     self._full_name_Write = self._stub.GetFullMethodName(
7173         'Write')
7174
7175   def BeginTransaction(self, request, rpc=None, callback=None, response=None):
7176     """Make a BeginTransaction RPC call.
7177
7178     Args:
7179       request: a BeginTransactionRequest instance.
7180       rpc: Optional RPC instance to use for the call.
7181       callback: Optional final callback. Will be called as
7182           callback(rpc, result) when the rpc completes. If None, the
7183           call is synchronous.
7184       response: Optional ProtocolMessage to be filled in with response.
7185
7186     Returns:
7187       The BeginTransactionResponse if callback is None. Otherwise, returns None.
7188     """
7189
7190     if response is None:
7191       response = BeginTransactionResponse
7192     return self._MakeCall(rpc,
7193                           self._full_name_BeginTransaction,
7194                           'BeginTransaction',
7195                           request,
7196                           response,
7197                           callback,
7198                           self._protorpc_BeginTransaction)
7199
7200   def Rollback(self, request, rpc=None, callback=None, response=None):
7201     """Make a Rollback RPC call.
7202
7203     Args:
7204       request: a RollbackRequest instance.
7205       rpc: Optional RPC instance to use for the call.
7206       callback: Optional final callback. Will be called as
7207           callback(rpc, result) when the rpc completes. If None, the
7208           call is synchronous.
7209       response: Optional ProtocolMessage to be filled in with response.
7210
7211     Returns:
7212       The RollbackResponse if callback is None. Otherwise, returns None.
7213     """
7214
7215     if response is None:
7216       response = RollbackResponse
7217     return self._MakeCall(rpc,
7218                           self._full_name_Rollback,
7219                           'Rollback',
7220                           request,
7221                           response,
7222                           callback,
7223                           self._protorpc_Rollback)
7224
7225   def Commit(self, request, rpc=None, callback=None, response=None):
7226     """Make a Commit RPC call.
7227
7228     Args:
7229       request: a CommitRequest instance.
7230       rpc: Optional RPC instance to use for the call.
7231       callback: Optional final callback. Will be called as
7232           callback(rpc, result) when the rpc completes. If None, the
7233           call is synchronous.
7234       response: Optional ProtocolMessage to be filled in with response.
7235
7236     Returns:
7237       The CommitResponse if callback is None. Otherwise, returns None.
7238     """
7239
7240     if response is None:
7241       response = CommitResponse
7242     return self._MakeCall(rpc,
7243                           self._full_name_Commit,
7244                           'Commit',
7245                           request,
7246                           response,
7247                           callback,
7248                           self._protorpc_Commit)
7249
7250   def RunQuery(self, request, rpc=None, callback=None, response=None):
7251     """Make a RunQuery RPC call.
7252
7253     Args:
7254       request: a RunQueryRequest instance.
7255       rpc: Optional RPC instance to use for the call.
7256       callback: Optional final callback. Will be called as
7257           callback(rpc, result) when the rpc completes. If None, the
7258           call is synchronous.
7259       response: Optional ProtocolMessage to be filled in with response.
7260
7261     Returns:
7262       The RunQueryResponse if callback is None. Otherwise, returns None.
7263     """
7264
7265     if response is None:
7266       response = RunQueryResponse
7267     return self._MakeCall(rpc,
7268                           self._full_name_RunQuery,
7269                           'RunQuery',
7270                           request,
7271                           response,
7272                           callback,
7273                           self._protorpc_RunQuery)
7274
7275   def ContinueQuery(self, request, rpc=None, callback=None, response=None):
7276     """Make a ContinueQuery RPC call.
7277
7278     Args:
7279       request: a ContinueQueryRequest instance.
7280       rpc: Optional RPC instance to use for the call.
7281       callback: Optional final callback. Will be called as
7282           callback(rpc, result) when the rpc completes. If None, the
7283           call is synchronous.
7284       response: Optional ProtocolMessage to be filled in with response.
7285
7286     Returns:
7287       The ContinueQueryResponse if callback is None. Otherwise, returns None.
7288     """
7289
7290     if response is None:
7291       response = ContinueQueryResponse
7292     return self._MakeCall(rpc,
7293                           self._full_name_ContinueQuery,
7294                           'ContinueQuery',
7295                           request,
7296                           response,
7297                           callback,
7298                           self._protorpc_ContinueQuery)
7299
7300   def Lookup(self, request, rpc=None, callback=None, response=None):
7301     """Make a Lookup RPC call.
7302
7303     Args:
7304       request: a LookupRequest instance.
7305       rpc: Optional RPC instance to use for the call.
7306       callback: Optional final callback. Will be called as
7307           callback(rpc, result) when the rpc completes. If None, the
7308           call is synchronous.
7309       response: Optional ProtocolMessage to be filled in with response.
7310
7311     Returns:
7312       The LookupResponse if callback is None. Otherwise, returns None.
7313     """
7314
7315     if response is None:
7316       response = LookupResponse
7317     return self._MakeCall(rpc,
7318                           self._full_name_Lookup,
7319                           'Lookup',
7320                           request,
7321                           response,
7322                           callback,
7323                           self._protorpc_Lookup)
7324
7325   def AllocateIds(self, request, rpc=None, callback=None, response=None):
7326     """Make a AllocateIds RPC call.
7327
7328     Args:
7329       request: a AllocateIdsRequest instance.
7330       rpc: Optional RPC instance to use for the call.
7331       callback: Optional final callback. Will be called as
7332           callback(rpc, result) when the rpc completes. If None, the
7333           call is synchronous.
7334       response: Optional ProtocolMessage to be filled in with response.
7335
7336     Returns:
7337       The AllocateIdsResponse if callback is None. Otherwise, returns None.
7338     """
7339
7340     if response is None:
7341       response = AllocateIdsResponse
7342     return self._MakeCall(rpc,
7343                           self._full_name_AllocateIds,
7344                           'AllocateIds',
7345                           request,
7346                           response,
7347                           callback,
7348                           self._protorpc_AllocateIds)
7349
7350   def Get(self, request, rpc=None, callback=None, response=None):
7351     """Make a Get RPC call.
7352
7353     Args:
7354       request: a LookupRequest instance.
7355       rpc: Optional RPC instance to use for the call.
7356       callback: Optional final callback. Will be called as
7357           callback(rpc, result) when the rpc completes. If None, the
7358           call is synchronous.
7359       response: Optional ProtocolMessage to be filled in with response.
7360
7361     Returns:
7362       The LookupResponse if callback is None. Otherwise, returns None.
7363     """
7364
7365     if response is None:
7366       response = LookupResponse
7367     return self._MakeCall(rpc,
7368                           self._full_name_Get,
7369                           'Get',
7370                           request,
7371                           response,
7372                           callback,
7373                           self._protorpc_Get)
7374
7375   def Write(self, request, rpc=None, callback=None, response=None):
7376     """Make a Write RPC call.
7377
7378     Args:
7379       request: a WriteRequest instance.
7380       rpc: Optional RPC instance to use for the call.
7381       callback: Optional final callback. Will be called as
7382           callback(rpc, result) when the rpc completes. If None, the
7383           call is synchronous.
7384       response: Optional ProtocolMessage to be filled in with response.
7385
7386     Returns:
7387       The CommitResponse if callback is None. Otherwise, returns None.
7388     """
7389
7390     if response is None:
7391       response = CommitResponse
7392     return self._MakeCall(rpc,
7393                           self._full_name_Write,
7394                           'Write',
7395                           request,
7396                           response,
7397                           callback,
7398                           self._protorpc_Write)
7399
7400
7401 class _DatastoreV4Service_ClientStub(_DatastoreV4Service_ClientBaseStub):
7402   __slots__ = ('_params',)
7403   def __init__(self, rpc_stub_parameters, service_name):
7404     if service_name is None:
7405       service_name = 'DatastoreV4Service'
7406     _DatastoreV4Service_ClientBaseStub.__init__(self, pywraprpc.RPC_GenericStub(service_name, rpc_stub_parameters))
7407     self._params = rpc_stub_parameters
7408
7409
7410 class _DatastoreV4Service_RPC2ClientStub(_DatastoreV4Service_ClientBaseStub):
7411   __slots__ = ()
7412   def __init__(self, server, channel, service_name):
7413     if service_name is None:
7414       service_name = 'DatastoreV4Service'
7415     if channel is not None:
7416       if channel.version() == 1:
7417         raise RuntimeError('Expecting an RPC2 channel to create the stub')
7418       _DatastoreV4Service_ClientBaseStub.__init__(self, pywraprpc.RPC_GenericStub(service_name, channel))
7419     elif server is not None:
7420       _DatastoreV4Service_ClientBaseStub.__init__(self, pywraprpc.RPC_GenericStub(service_name, pywraprpc.NewClientChannel(server)))
7421     else:
7422       raise RuntimeError('Invalid argument combination to create a stub')
7423
7424
7425 class DatastoreV4Service(_server_stub_base_class):
7426   """Base class for DatastoreV4Service Stubby servers."""
7427
7428   @classmethod
7429   def _MethodSignatures(cls):
7430     """Returns a dict of {<method-name>: (<request-type>, <response-type>)}."""
7431     return {
7432       'BeginTransaction': (BeginTransactionRequest, BeginTransactionResponse),
7433       'Rollback': (RollbackRequest, RollbackResponse),
7434       'Commit': (CommitRequest, CommitResponse),
7435       'RunQuery': (RunQueryRequest, RunQueryResponse),
7436       'ContinueQuery': (ContinueQueryRequest, ContinueQueryResponse),
7437       'Lookup': (LookupRequest, LookupResponse),
7438       'AllocateIds': (AllocateIdsRequest, AllocateIdsResponse),
7439       'Get': (LookupRequest, LookupResponse),
7440       'Write': (WriteRequest, CommitResponse),
7441       }
7442
7443   @classmethod
7444   def _StreamMethodSignatures(cls):
7445     """Returns a dict of {<method-name>: (<request-type>, <stream-type>, <response-type>)}."""
7446     return {
7447       }
7448
7449   def __init__(self, *args, **kwargs):
7450     """Creates a Stubby RPC server.
7451
7452     See BaseRpcServer.__init__ in rpcserver.py for detail on arguments.
7453     """
7454     if _server_stub_base_class is object:
7455       raise NotImplementedError('Add //net/rpc/python:rpcserver as a '
7456                                 'dependency for Stubby server support.')
7457     _server_stub_base_class.__init__(self, 'apphosting.datastore.v4.DatastoreV4Service', *args, **kwargs)
7458
7459   @staticmethod
7460   def NewStub(rpc_stub_parameters, service_name=None):
7461     """Creates a new DatastoreV4Service Stubby client stub.
7462
7463     Args:
7464       rpc_stub_parameters: an RPC_StubParameter instance.
7465       service_name: the service name used by the Stubby server.
7466     """
7467
7468     if _client_stub_base_class is object:
7469       raise RuntimeError('Add //net/rpc/python as a dependency to use Stubby')
7470     return _DatastoreV4Service_ClientStub(rpc_stub_parameters, service_name)
7471
7472   @staticmethod
7473   def NewRPC2Stub(server=None, channel=None, service_name=None):
7474     """Creates a new DatastoreV4Service Stubby2 client stub.
7475
7476     Args:
7477       server: host:port or bns address.
7478       channel: directly use a channel to create a stub. Will ignore server
7479           argument if this is specified.
7480       service_name: the service name used by the Stubby server.
7481     """
7482
7483     if _client_stub_base_class is object:
7484       raise RuntimeError('Add //net/rpc/python as a dependency to use Stubby')
7485     return _DatastoreV4Service_RPC2ClientStub(server, channel, service_name)
7486
7487   def BeginTransaction(self, rpc, request, response):
7488     """Handles a BeginTransaction RPC call. You should override this.
7489
7490     Args:
7491       rpc: a Stubby RPC object
7492       request: a BeginTransactionRequest that contains the client request
7493       response: a BeginTransactionResponse that should be modified to send the response
7494     """
7495     raise NotImplementedError
7496
7497
7498   def Rollback(self, rpc, request, response):
7499     """Handles a Rollback RPC call. You should override this.
7500
7501     Args:
7502       rpc: a Stubby RPC object
7503       request: a RollbackRequest that contains the client request
7504       response: a RollbackResponse that should be modified to send the response
7505     """
7506     raise NotImplementedError
7507
7508
7509   def Commit(self, rpc, request, response):
7510     """Handles a Commit RPC call. You should override this.
7511
7512     Args:
7513       rpc: a Stubby RPC object
7514       request: a CommitRequest that contains the client request
7515       response: a CommitResponse that should be modified to send the response
7516     """
7517     raise NotImplementedError
7518
7519
7520   def RunQuery(self, rpc, request, response):
7521     """Handles a RunQuery RPC call. You should override this.
7522
7523     Args:
7524       rpc: a Stubby RPC object
7525       request: a RunQueryRequest that contains the client request
7526       response: a RunQueryResponse that should be modified to send the response
7527     """
7528     raise NotImplementedError
7529
7530
7531   def ContinueQuery(self, rpc, request, response):
7532     """Handles a ContinueQuery RPC call. You should override this.
7533
7534     Args:
7535       rpc: a Stubby RPC object
7536       request: a ContinueQueryRequest that contains the client request
7537       response: a ContinueQueryResponse that should be modified to send the response
7538     """
7539     raise NotImplementedError
7540
7541
7542   def Lookup(self, rpc, request, response):
7543     """Handles a Lookup RPC call. You should override this.
7544
7545     Args:
7546       rpc: a Stubby RPC object
7547       request: a LookupRequest that contains the client request
7548       response: a LookupResponse that should be modified to send the response
7549     """
7550     raise NotImplementedError
7551
7552
7553   def AllocateIds(self, rpc, request, response):
7554     """Handles a AllocateIds RPC call. You should override this.
7555
7556     Args:
7557       rpc: a Stubby RPC object
7558       request: a AllocateIdsRequest that contains the client request
7559       response: a AllocateIdsResponse that should be modified to send the response
7560     """
7561     raise NotImplementedError
7562
7563
7564   def Get(self, rpc, request, response):
7565     """Handles a Get RPC call. You should override this.
7566
7567     Args:
7568       rpc: a Stubby RPC object
7569       request: a LookupRequest that contains the client request
7570       response: a LookupResponse that should be modified to send the response
7571     """
7572     raise NotImplementedError
7573
7574
7575   def Write(self, rpc, request, response):
7576     """Handles a Write RPC call. You should override this.
7577
7578     Args:
7579       rpc: a Stubby RPC object
7580       request: a WriteRequest that contains the client request
7581       response: a CommitResponse that should be modified to send the response
7582     """
7583     raise NotImplementedError
7584
7585   def _AddMethodAttributes(self):
7586     """Sets attributes on Python RPC handlers.
7587
7588     See BaseRpcServer in rpcserver.py for details.
7589     """
7590     rpcserver._GetHandlerDecorator(
7591         getattr(self.BeginTransaction, 'im_func' if str is bytes else '__func__'),
7592         BeginTransactionRequest,
7593         BeginTransactionResponse,
7594         None,
7595         'INTEGRITY')
7596     rpcserver._GetHandlerDecorator(
7597         getattr(self.Rollback, 'im_func' if str is bytes else '__func__'),
7598         RollbackRequest,
7599         RollbackResponse,
7600         None,
7601         'INTEGRITY')
7602     rpcserver._GetHandlerDecorator(
7603         getattr(self.Commit, 'im_func' if str is bytes else '__func__'),
7604         CommitRequest,
7605         CommitResponse,
7606         None,
7607         'INTEGRITY')
7608     rpcserver._GetHandlerDecorator(
7609         getattr(self.RunQuery, 'im_func' if str is bytes else '__func__'),
7610         RunQueryRequest,
7611         RunQueryResponse,
7612         None,
7613         'INTEGRITY')
7614     rpcserver._GetHandlerDecorator(
7615         getattr(self.ContinueQuery, 'im_func' if str is bytes else '__func__'),
7616         ContinueQueryRequest,
7617         ContinueQueryResponse,
7618         None,
7619         'INTEGRITY')
7620     rpcserver._GetHandlerDecorator(
7621         getattr(self.Lookup, 'im_func' if str is bytes else '__func__'),
7622         LookupRequest,
7623         LookupResponse,
7624         None,
7625         'INTEGRITY')
7626     rpcserver._GetHandlerDecorator(
7627         getattr(self.AllocateIds, 'im_func' if str is bytes else '__func__'),
7628         AllocateIdsRequest,
7629         AllocateIdsResponse,
7630         None,
7631         'INTEGRITY')
7632     rpcserver._GetHandlerDecorator(
7633         getattr(self.Get, 'im_func' if str is bytes else '__func__'),
7634         LookupRequest,
7635         LookupResponse,
7636         None,
7637         'INTEGRITY')
7638     rpcserver._GetHandlerDecorator(
7639         getattr(self.Write, 'im_func' if str is bytes else '__func__'),
7640         WriteRequest,
7641         CommitResponse,
7642         None,
7643         'INTEGRITY')
7644
7645 if _extension_runtime:
7646   pass
7647
7648 __all__ = ['Error','EntityResult','Query','KindExpression','PropertyReference','PropertyExpression','PropertyOrder','Filter','CompositeFilter','PropertyFilter','GqlQuery','GqlQueryArg','QueryResultBatch','Mutation','MutationResult','DeprecatedMutation','DeprecatedMutationResult','ReadOptions','LookupRequest','LookupResponse','RunQueryRequest','RunQueryResponse','ContinueQueryRequest','ContinueQueryResponse','BeginTransactionRequest','BeginTransactionResponse','RollbackRequest','RollbackResponse','CommitRequest','CommitResponse','AllocateIdsRequest','AllocateIdsResponse','WriteRequest','DatastoreV4Service']