python/google/appengine/datastore/entity_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
  29 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  30                    unusednames=printElemNumber,debug_strs no-special"""
  31
  32 if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'):
  33   _extension_runtime = True
  34   _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
  35 else:
  36   _extension_runtime = False
  37   _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
  38
  39 class PartitionId(ProtocolBuffer.ProtocolMessage):
  40
  41
  42   MAX_DIMENSION_TAG =  100
  43
  44   _Constants_NAMES = {
  45     100: "MAX_DIMENSION_TAG",
  46   }
  47
  48   def Constants_Name(cls, x): return cls._Constants_NAMES.get(x, "")
  49   Constants_Name = classmethod(Constants_Name)
  50
  51   has_dataset_id_ = 0
  52   dataset_id_ = ""
  53   has_namespace_ = 0
  54   namespace_ = ""
  55
  56   def __init__(self, contents=None):
  57     if contents is not None: self.MergeFromString(contents)
  58
  59   def dataset_id(self): return self.dataset_id_
  60
  61   def set_dataset_id(self, x):
  62     self.has_dataset_id_ = 1
  63     self.dataset_id_ = x
  64
  65   def clear_dataset_id(self):
  66     if self.has_dataset_id_:
  67       self.has_dataset_id_ = 0
  68       self.dataset_id_ = ""
  69
  70   def has_dataset_id(self): return self.has_dataset_id_
  71
  72   def namespace(self): return self.namespace_
  73
  74   def set_namespace(self, x):
  75     self.has_namespace_ = 1
  76     self.namespace_ = x
  77
  78   def clear_namespace(self):
  79     if self.has_namespace_:
  80       self.has_namespace_ = 0
  81       self.namespace_ = ""
  82
  83   def has_namespace(self): return self.has_namespace_
  84
  85
  86   def MergeFrom(self, x):
  87     assert x is not self
  88     if (x.has_dataset_id()): self.set_dataset_id(x.dataset_id())
  89     if (x.has_namespace()): self.set_namespace(x.namespace())
  90
  91   if _net_proto___parse__python is not None:
  92     def _CMergeFromString(self, s):
  93       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.PartitionId', s)
  94
  95   if _net_proto___parse__python is not None:
  96     def _CEncode(self):
  97       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.PartitionId')
  98
  99   if _net_proto___parse__python is not None:
 100     def _CEncodePartial(self):
 101       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.PartitionId')
 102
 103   if _net_proto___parse__python is not None:
 104     def _CToASCII(self, output_format):
 105       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.PartitionId', output_format)
 106
 107
 108   if _net_proto___parse__python is not None:
 109     def ParseASCII(self, s):
 110       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.PartitionId', s)
 111
 112
 113   if _net_proto___parse__python is not None:
 114     def ParseASCIIIgnoreUnknown(self, s):
 115       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.PartitionId', s)
 116
 117
 118   def Equals(self, x):
 119     if x is self: return 1
 120     if self.has_dataset_id_ != x.has_dataset_id_: return 0
 121     if self.has_dataset_id_ and self.dataset_id_ != x.dataset_id_: return 0
 122     if self.has_namespace_ != x.has_namespace_: return 0
 123     if self.has_namespace_ and self.namespace_ != x.namespace_: return 0
 124     return 1
 125
 126   def IsInitialized(self, debug_strs=None):
 127     initialized = 1
 128     return initialized
 129
 130   def ByteSize(self):
 131     n = 0
 132     if (self.has_dataset_id_): n += 1 + self.lengthString(len(self.dataset_id_))
 133     if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
 134     return n
 135
 136   def ByteSizePartial(self):
 137     n = 0
 138     if (self.has_dataset_id_): n += 1 + self.lengthString(len(self.dataset_id_))
 139     if (self.has_namespace_): n += 1 + self.lengthString(len(self.namespace_))
 140     return n
 141
 142   def Clear(self):
 143     self.clear_dataset_id()
 144     self.clear_namespace()
 145
 146   def OutputUnchecked(self, out):
 147     if (self.has_dataset_id_):
 148       out.putVarInt32(26)
 149       out.putPrefixedString(self.dataset_id_)
 150     if (self.has_namespace_):
 151       out.putVarInt32(34)
 152       out.putPrefixedString(self.namespace_)
 153
 154   def OutputPartial(self, out):
 155     if (self.has_dataset_id_):
 156       out.putVarInt32(26)
 157       out.putPrefixedString(self.dataset_id_)
 158     if (self.has_namespace_):
 159       out.putVarInt32(34)
 160       out.putPrefixedString(self.namespace_)
 161
 162   def TryMerge(self, d):
 163     while d.avail() > 0:
 164       tt = d.getVarInt32()
 165       if tt == 26:
 166         self.set_dataset_id(d.getPrefixedString())
 167         continue
 168       if tt == 34:
 169         self.set_namespace(d.getPrefixedString())
 170         continue
 171
 172
 173       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 174       d.skipData(tt)
 175
 176
 177   def __str__(self, prefix="", printElemNumber=0):
 178     res=""
 179     if self.has_dataset_id_: res+=prefix+("dataset_id: %s\n" % self.DebugFormatString(self.dataset_id_))
 180     if self.has_namespace_: res+=prefix+("namespace: %s\n" % self.DebugFormatString(self.namespace_))
 181     return res
 182
 183
 184   def _BuildTagLookupTable(sparse, maxtag, default=None):
 185     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 186
 187   kdataset_id = 3
 188   knamespace = 4
 189
 190   _TEXT = _BuildTagLookupTable({
 191     0: "ErrorCode",
 192     3: "dataset_id",
 193     4: "namespace",
 194   }, 4)
 195
 196   _TYPES = _BuildTagLookupTable({
 197     0: ProtocolBuffer.Encoder.NUMERIC,
 198     3: ProtocolBuffer.Encoder.STRING,
 199     4: ProtocolBuffer.Encoder.STRING,
 200   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
 201
 202
 203   _STYLE = """"""
 204   _STYLE_CONTENT_TYPE = """"""
 205   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.PartitionId'
 206   _SERIALIZED_DESCRIPTOR = array.array('B')
 207   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WiRhcHBob3N0aW5nL2RhdGFzdG9yZS9lbnRpdHlfdjQucHJvdG8KI2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlBhcnRpdGlvbklkExoKZGF0YXNldF9pZCADKAIwCTgBFBMaCW5hbWVzcGFjZSAEKAIwCTgBFHN6CUNvbnN0YW50c4sBkgERTUFYX0RJTUVOU0lPTl9UQUeYAWSMAXS6AYIICiRhcHBob3N0aW5nL2RhdGFzdG9yZS9lbnRpdHlfdjQucHJvdG8SF2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0IlgKC1BhcnRpdGlvbklkEhIKCmRhdGFzZXRfaWQYAyABKAkSEQoJbmFtZXNwYWNlGAQgASgJIiIKCUNvbnN0YW50cxIVChFNQVhfRElNRU5TSU9OX1RBRxBkIrgBCgNLZXkSOgoMcGFydGl0aW9uX2lkGAEgASgLMiQuYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUGFydGl0aW9uSWQSPgoMcGF0aF9lbGVtZW50GAIgAygLMiguYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuS2V5LlBhdGhFbGVtZW50GjUKC1BhdGhFbGVtZW50EgwKBGtpbmQYASACKAkSCgoCaWQYAiABKAMSDAoEbmFtZRgDIAEoCSL3AgoFVmFsdWUSFQoNYm9vbGVhbl92YWx1ZRgBIAEoCBIVCg1pbnRlZ2VyX3ZhbHVlGAIgASgDEhQKDGRvdWJsZV92YWx1ZRgDIAEoARIkChx0aW1lc3RhbXBfbWljcm9zZWNvbmRzX3ZhbHVlGAQgASgDEi8KCWtleV92YWx1ZRgFIAEoCzIcLmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleRIWCg5ibG9iX2tleV92YWx1ZRgQIAEoCRIUCgxzdHJpbmdfdmFsdWUYESABKAkSEgoKYmxvYl92YWx1ZRgSIAEoDBI1CgxlbnRpdHlfdmFsdWUYBiABKAsyHy5hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5FbnRpdHkSMgoKbGlzdF92YWx1ZRgHIAMoCzIeLmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlZhbHVlEg8KB21lYW5pbmcYDiABKAUSFQoHaW5kZXhlZBgPIAEoCDoEdHJ1ZSKiAQoIUHJvcGVydHkSDAoEbmFtZRgBIAIoCRIfChBkZXByZWNhdGVkX211bHRpGAIgASgIOgVmYWxzZRI4ChBkZXByZWNhdGVkX3ZhbHVlGAMgAygLMh4uYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuVmFsdWUSLQoFdmFsdWUYBCABKAsyHi5hcHBob3N0aW5nLmRhdGFzdG9yZS52NC5WYWx1ZSJoCgZFbnRpdHkSKQoDa2V5GAEgASgLMhwuYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuS2V5EjMKCHByb3BlcnR5GAIgAygLMiEuYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUHJvcGVydHlCIwofY29tLmdvb2dsZS5hcHBob3N0aW5nLmRhdGFzdG9yZSAB"))
 208   if _net_proto___parse__python is not None:
 209     _net_proto___parse__python.RegisterType(
 210         _SERIALIZED_DESCRIPTOR.tostring())
 211
 212 class Key_PathElement(ProtocolBuffer.ProtocolMessage):
 213   has_kind_ = 0
 214   kind_ = ""
 215   has_id_ = 0
 216   id_ = 0
 217   has_name_ = 0
 218   name_ = ""
 219
 220   def __init__(self, contents=None):
 221     if contents is not None: self.MergeFromString(contents)
 222
 223   def kind(self): return self.kind_
 224
 225   def set_kind(self, x):
 226     self.has_kind_ = 1
 227     self.kind_ = x
 228
 229   def clear_kind(self):
 230     if self.has_kind_:
 231       self.has_kind_ = 0
 232       self.kind_ = ""
 233
 234   def has_kind(self): return self.has_kind_
 235
 236   def id(self): return self.id_
 237
 238   def set_id(self, x):
 239     self.has_id_ = 1
 240     self.id_ = x
 241
 242   def clear_id(self):
 243     if self.has_id_:
 244       self.has_id_ = 0
 245       self.id_ = 0
 246
 247   def has_id(self): return self.has_id_
 248
 249   def name(self): return self.name_
 250
 251   def set_name(self, x):
 252     self.has_name_ = 1
 253     self.name_ = x
 254
 255   def clear_name(self):
 256     if self.has_name_:
 257       self.has_name_ = 0
 258       self.name_ = ""
 259
 260   def has_name(self): return self.has_name_
 261
 262
 263   def MergeFrom(self, x):
 264     assert x is not self
 265     if (x.has_kind()): self.set_kind(x.kind())
 266     if (x.has_id()): self.set_id(x.id())
 267     if (x.has_name()): self.set_name(x.name())
 268
 269   if _net_proto___parse__python is not None:
 270     def _CMergeFromString(self, s):
 271       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Key_PathElement', s)
 272
 273   if _net_proto___parse__python is not None:
 274     def _CEncode(self):
 275       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Key_PathElement')
 276
 277   if _net_proto___parse__python is not None:
 278     def _CEncodePartial(self):
 279       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Key_PathElement')
 280
 281   if _net_proto___parse__python is not None:
 282     def _CToASCII(self, output_format):
 283       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Key_PathElement', output_format)
 284
 285
 286   if _net_proto___parse__python is not None:
 287     def ParseASCII(self, s):
 288       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Key_PathElement', s)
 289
 290
 291   if _net_proto___parse__python is not None:
 292     def ParseASCIIIgnoreUnknown(self, s):
 293       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Key_PathElement', s)
 294
 295
 296   def Equals(self, x):
 297     if x is self: return 1
 298     if self.has_kind_ != x.has_kind_: return 0
 299     if self.has_kind_ and self.kind_ != x.kind_: return 0
 300     if self.has_id_ != x.has_id_: return 0
 301     if self.has_id_ and self.id_ != x.id_: return 0
 302     if self.has_name_ != x.has_name_: return 0
 303     if self.has_name_ and self.name_ != x.name_: return 0
 304     return 1
 305
 306   def IsInitialized(self, debug_strs=None):
 307     initialized = 1
 308     if (not self.has_kind_):
 309       initialized = 0
 310       if debug_strs is not None:
 311         debug_strs.append('Required field: kind not set.')
 312     return initialized
 313
 314   def ByteSize(self):
 315     n = 0
 316     n += self.lengthString(len(self.kind_))
 317     if (self.has_id_): n += 1 + self.lengthVarInt64(self.id_)
 318     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
 319     return n + 1
 320
 321   def ByteSizePartial(self):
 322     n = 0
 323     if (self.has_kind_):
 324       n += 1
 325       n += self.lengthString(len(self.kind_))
 326     if (self.has_id_): n += 1 + self.lengthVarInt64(self.id_)
 327     if (self.has_name_): n += 1 + self.lengthString(len(self.name_))
 328     return n
 329
 330   def Clear(self):
 331     self.clear_kind()
 332     self.clear_id()
 333     self.clear_name()
 334
 335   def OutputUnchecked(self, out):
 336     out.putVarInt32(10)
 337     out.putPrefixedString(self.kind_)
 338     if (self.has_id_):
 339       out.putVarInt32(16)
 340       out.putVarInt64(self.id_)
 341     if (self.has_name_):
 342       out.putVarInt32(26)
 343       out.putPrefixedString(self.name_)
 344
 345   def OutputPartial(self, out):
 346     if (self.has_kind_):
 347       out.putVarInt32(10)
 348       out.putPrefixedString(self.kind_)
 349     if (self.has_id_):
 350       out.putVarInt32(16)
 351       out.putVarInt64(self.id_)
 352     if (self.has_name_):
 353       out.putVarInt32(26)
 354       out.putPrefixedString(self.name_)
 355
 356   def TryMerge(self, d):
 357     while d.avail() > 0:
 358       tt = d.getVarInt32()
 359       if tt == 10:
 360         self.set_kind(d.getPrefixedString())
 361         continue
 362       if tt == 16:
 363         self.set_id(d.getVarInt64())
 364         continue
 365       if tt == 26:
 366         self.set_name(d.getPrefixedString())
 367         continue
 368
 369
 370       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 371       d.skipData(tt)
 372
 373
 374   def __str__(self, prefix="", printElemNumber=0):
 375     res=""
 376     if self.has_kind_: res+=prefix+("kind: %s\n" % self.DebugFormatString(self.kind_))
 377     if self.has_id_: res+=prefix+("id: %s\n" % self.DebugFormatInt64(self.id_))
 378     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
 379     return res
 380
 381
 382   def _BuildTagLookupTable(sparse, maxtag, default=None):
 383     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 384
 385   kkind = 1
 386   kid = 2
 387   kname = 3
 388
 389   _TEXT = _BuildTagLookupTable({
 390     0: "ErrorCode",
 391     1: "kind",
 392     2: "id",
 393     3: "name",
 394   }, 3)
 395
 396   _TYPES = _BuildTagLookupTable({
 397     0: ProtocolBuffer.Encoder.NUMERIC,
 398     1: ProtocolBuffer.Encoder.STRING,
 399     2: ProtocolBuffer.Encoder.NUMERIC,
 400     3: ProtocolBuffer.Encoder.STRING,
 401   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
 402
 403
 404   _STYLE = """"""
 405   _STYLE_CONTENT_TYPE = """"""
 406   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Key_PathElement'
 407   _SERIALIZED_DESCRIPTOR = array.array('B')
 408   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WiRhcHBob3N0aW5nL2RhdGFzdG9yZS9lbnRpdHlfdjQucHJvdG8KJ2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleV9QYXRoRWxlbWVudBMaBGtpbmQgASgCMAk4AhQTGgJpZCACKAAwAzgBFBMaBG5hbWUgAygCMAk4ARTCASNhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5QYXJ0aXRpb25JZMoBJ2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleS5QYXRoRWxlbWVudA=="))
 409   if _net_proto___parse__python is not None:
 410     _net_proto___parse__python.RegisterType(
 411         _SERIALIZED_DESCRIPTOR.tostring())
 412
 413 class Key(ProtocolBuffer.ProtocolMessage):
 414   has_partition_id_ = 0
 415   partition_id_ = None
 416
 417   def __init__(self, contents=None):
 418     self.path_element_ = []
 419     self.lazy_init_lock_ = thread.allocate_lock()
 420     if contents is not None: self.MergeFromString(contents)
 421
 422   def partition_id(self):
 423     if self.partition_id_ is None:
 424       self.lazy_init_lock_.acquire()
 425       try:
 426         if self.partition_id_ is None: self.partition_id_ = PartitionId()
 427       finally:
 428         self.lazy_init_lock_.release()
 429     return self.partition_id_
 430
 431   def mutable_partition_id(self): self.has_partition_id_ = 1; return self.partition_id()
 432
 433   def clear_partition_id(self):
 434
 435     if self.has_partition_id_:
 436       self.has_partition_id_ = 0;
 437       if self.partition_id_ is not None: self.partition_id_.Clear()
 438
 439   def has_partition_id(self): return self.has_partition_id_
 440
 441   def path_element_size(self): return len(self.path_element_)
 442   def path_element_list(self): return self.path_element_
 443
 444   def path_element(self, i):
 445     return self.path_element_[i]
 446
 447   def mutable_path_element(self, i):
 448     return self.path_element_[i]
 449
 450   def add_path_element(self):
 451     x = Key_PathElement()
 452     self.path_element_.append(x)
 453     return x
 454
 455   def clear_path_element(self):
 456     self.path_element_ = []
 457
 458   def MergeFrom(self, x):
 459     assert x is not self
 460     if (x.has_partition_id()): self.mutable_partition_id().MergeFrom(x.partition_id())
 461     for i in xrange(x.path_element_size()): self.add_path_element().CopyFrom(x.path_element(i))
 462
 463   if _net_proto___parse__python is not None:
 464     def _CMergeFromString(self, s):
 465       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Key', s)
 466
 467   if _net_proto___parse__python is not None:
 468     def _CEncode(self):
 469       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Key')
 470
 471   if _net_proto___parse__python is not None:
 472     def _CEncodePartial(self):
 473       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Key')
 474
 475   if _net_proto___parse__python is not None:
 476     def _CToASCII(self, output_format):
 477       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Key', output_format)
 478
 479
 480   if _net_proto___parse__python is not None:
 481     def ParseASCII(self, s):
 482       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Key', s)
 483
 484
 485   if _net_proto___parse__python is not None:
 486     def ParseASCIIIgnoreUnknown(self, s):
 487       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Key', s)
 488
 489
 490   def Equals(self, x):
 491     if x is self: return 1
 492     if self.has_partition_id_ != x.has_partition_id_: return 0
 493     if self.has_partition_id_ and self.partition_id_ != x.partition_id_: return 0
 494     if len(self.path_element_) != len(x.path_element_): return 0
 495     for e1, e2 in zip(self.path_element_, x.path_element_):
 496       if e1 != e2: return 0
 497     return 1
 498
 499   def IsInitialized(self, debug_strs=None):
 500     initialized = 1
 501     if (self.has_partition_id_ and not self.partition_id_.IsInitialized(debug_strs)): initialized = 0
 502     for p in self.path_element_:
 503       if not p.IsInitialized(debug_strs): initialized=0
 504     return initialized
 505
 506   def ByteSize(self):
 507     n = 0
 508     if (self.has_partition_id_): n += 1 + self.lengthString(self.partition_id_.ByteSize())
 509     n += 1 * len(self.path_element_)
 510     for i in xrange(len(self.path_element_)): n += self.lengthString(self.path_element_[i].ByteSize())
 511     return n
 512
 513   def ByteSizePartial(self):
 514     n = 0
 515     if (self.has_partition_id_): n += 1 + self.lengthString(self.partition_id_.ByteSizePartial())
 516     n += 1 * len(self.path_element_)
 517     for i in xrange(len(self.path_element_)): n += self.lengthString(self.path_element_[i].ByteSizePartial())
 518     return n
 519
 520   def Clear(self):
 521     self.clear_partition_id()
 522     self.clear_path_element()
 523
 524   def OutputUnchecked(self, out):
 525     if (self.has_partition_id_):
 526       out.putVarInt32(10)
 527       out.putVarInt32(self.partition_id_.ByteSize())
 528       self.partition_id_.OutputUnchecked(out)
 529     for i in xrange(len(self.path_element_)):
 530       out.putVarInt32(18)
 531       out.putVarInt32(self.path_element_[i].ByteSize())
 532       self.path_element_[i].OutputUnchecked(out)
 533
 534   def OutputPartial(self, out):
 535     if (self.has_partition_id_):
 536       out.putVarInt32(10)
 537       out.putVarInt32(self.partition_id_.ByteSizePartial())
 538       self.partition_id_.OutputPartial(out)
 539     for i in xrange(len(self.path_element_)):
 540       out.putVarInt32(18)
 541       out.putVarInt32(self.path_element_[i].ByteSizePartial())
 542       self.path_element_[i].OutputPartial(out)
 543
 544   def TryMerge(self, d):
 545     while d.avail() > 0:
 546       tt = d.getVarInt32()
 547       if tt == 10:
 548         length = d.getVarInt32()
 549         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 550         d.skip(length)
 551         self.mutable_partition_id().TryMerge(tmp)
 552         continue
 553       if tt == 18:
 554         length = d.getVarInt32()
 555         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
 556         d.skip(length)
 557         self.add_path_element().TryMerge(tmp)
 558         continue
 559
 560
 561       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 562       d.skipData(tt)
 563
 564
 565   def __str__(self, prefix="", printElemNumber=0):
 566     res=""
 567     if self.has_partition_id_:
 568       res+=prefix+"partition_id <\n"
 569       res+=self.partition_id_.__str__(prefix + "  ", printElemNumber)
 570       res+=prefix+">\n"
 571     cnt=0
 572     for e in self.path_element_:
 573       elm=""
 574       if printElemNumber: elm="(%d)" % cnt
 575       res+=prefix+("path_element%s <\n" % elm)
 576       res+=e.__str__(prefix + "  ", printElemNumber)
 577       res+=prefix+">\n"
 578       cnt+=1
 579     return res
 580
 581
 582   def _BuildTagLookupTable(sparse, maxtag, default=None):
 583     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 584
 585   kpartition_id = 1
 586   kpath_element = 2
 587
 588   _TEXT = _BuildTagLookupTable({
 589     0: "ErrorCode",
 590     1: "partition_id",
 591     2: "path_element",
 592   }, 2)
 593
 594   _TYPES = _BuildTagLookupTable({
 595     0: ProtocolBuffer.Encoder.NUMERIC,
 596     1: ProtocolBuffer.Encoder.STRING,
 597     2: ProtocolBuffer.Encoder.STRING,
 598   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 599
 600
 601   _STYLE = """"""
 602   _STYLE_CONTENT_TYPE = """"""
 603   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Key'
 604   _SERIALIZED_DESCRIPTOR = array.array('B')
 605   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WiRhcHBob3N0aW5nL2RhdGFzdG9yZS9lbnRpdHlfdjQucHJvdG8KG2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleRMaDHBhcnRpdGlvbl9pZCABKAIwCzgBSiNhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5QYXJ0aXRpb25JZKMBqgEFY3R5cGWyAQZwcm90bzKkARQTGgxwYXRoX2VsZW1lbnQgAigCMAs4A0onYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuS2V5X1BhdGhFbGVtZW50owGqAQVjdHlwZbIBBnByb3RvMqQBFMIBI2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlBhcnRpdGlvbklk"))
 606   if _net_proto___parse__python is not None:
 607     _net_proto___parse__python.RegisterType(
 608         _SERIALIZED_DESCRIPTOR.tostring())
 609
 610 class Value(ProtocolBuffer.ProtocolMessage):
 611   has_boolean_value_ = 0
 612   boolean_value_ = 0
 613   has_integer_value_ = 0
 614   integer_value_ = 0
 615   has_double_value_ = 0
 616   double_value_ = 0.0
 617   has_timestamp_microseconds_value_ = 0
 618   timestamp_microseconds_value_ = 0
 619   has_key_value_ = 0
 620   key_value_ = None
 621   has_blob_key_value_ = 0
 622   blob_key_value_ = ""
 623   has_string_value_ = 0
 624   string_value_ = ""
 625   has_blob_value_ = 0
 626   blob_value_ = ""
 627   has_entity_value_ = 0
 628   entity_value_ = None
 629   has_meaning_ = 0
 630   meaning_ = 0
 631   has_indexed_ = 0
 632   indexed_ = 1
 633
 634   def __init__(self, contents=None):
 635     self.list_value_ = []
 636     self.lazy_init_lock_ = thread.allocate_lock()
 637     if contents is not None: self.MergeFromString(contents)
 638
 639   def boolean_value(self): return self.boolean_value_
 640
 641   def set_boolean_value(self, x):
 642     self.has_boolean_value_ = 1
 643     self.boolean_value_ = x
 644
 645   def clear_boolean_value(self):
 646     if self.has_boolean_value_:
 647       self.has_boolean_value_ = 0
 648       self.boolean_value_ = 0
 649
 650   def has_boolean_value(self): return self.has_boolean_value_
 651
 652   def integer_value(self): return self.integer_value_
 653
 654   def set_integer_value(self, x):
 655     self.has_integer_value_ = 1
 656     self.integer_value_ = x
 657
 658   def clear_integer_value(self):
 659     if self.has_integer_value_:
 660       self.has_integer_value_ = 0
 661       self.integer_value_ = 0
 662
 663   def has_integer_value(self): return self.has_integer_value_
 664
 665   def double_value(self): return self.double_value_
 666
 667   def set_double_value(self, x):
 668     self.has_double_value_ = 1
 669     self.double_value_ = x
 670
 671   def clear_double_value(self):
 672     if self.has_double_value_:
 673       self.has_double_value_ = 0
 674       self.double_value_ = 0.0
 675
 676   def has_double_value(self): return self.has_double_value_
 677
 678   def timestamp_microseconds_value(self): return self.timestamp_microseconds_value_
 679
 680   def set_timestamp_microseconds_value(self, x):
 681     self.has_timestamp_microseconds_value_ = 1
 682     self.timestamp_microseconds_value_ = x
 683
 684   def clear_timestamp_microseconds_value(self):
 685     if self.has_timestamp_microseconds_value_:
 686       self.has_timestamp_microseconds_value_ = 0
 687       self.timestamp_microseconds_value_ = 0
 688
 689   def has_timestamp_microseconds_value(self): return self.has_timestamp_microseconds_value_
 690
 691   def key_value(self):
 692     if self.key_value_ is None:
 693       self.lazy_init_lock_.acquire()
 694       try:
 695         if self.key_value_ is None: self.key_value_ = Key()
 696       finally:
 697         self.lazy_init_lock_.release()
 698     return self.key_value_
 699
 700   def mutable_key_value(self): self.has_key_value_ = 1; return self.key_value()
 701
 702   def clear_key_value(self):
 703
 704     if self.has_key_value_:
 705       self.has_key_value_ = 0;
 706       if self.key_value_ is not None: self.key_value_.Clear()
 707
 708   def has_key_value(self): return self.has_key_value_
 709
 710   def blob_key_value(self): return self.blob_key_value_
 711
 712   def set_blob_key_value(self, x):
 713     self.has_blob_key_value_ = 1
 714     self.blob_key_value_ = x
 715
 716   def clear_blob_key_value(self):
 717     if self.has_blob_key_value_:
 718       self.has_blob_key_value_ = 0
 719       self.blob_key_value_ = ""
 720
 721   def has_blob_key_value(self): return self.has_blob_key_value_
 722
 723   def string_value(self): return self.string_value_
 724
 725   def set_string_value(self, x):
 726     self.has_string_value_ = 1
 727     self.string_value_ = x
 728
 729   def clear_string_value(self):
 730     if self.has_string_value_:
 731       self.has_string_value_ = 0
 732       self.string_value_ = ""
 733
 734   def has_string_value(self): return self.has_string_value_
 735
 736   def blob_value(self): return self.blob_value_
 737
 738   def set_blob_value(self, x):
 739     self.has_blob_value_ = 1
 740     self.blob_value_ = x
 741
 742   def clear_blob_value(self):
 743     if self.has_blob_value_:
 744       self.has_blob_value_ = 0
 745       self.blob_value_ = ""
 746
 747   def has_blob_value(self): return self.has_blob_value_
 748
 749   def entity_value(self):
 750     if self.entity_value_ is None:
 751       self.lazy_init_lock_.acquire()
 752       try:
 753         if self.entity_value_ is None: self.entity_value_ = Entity()
 754       finally:
 755         self.lazy_init_lock_.release()
 756     return self.entity_value_
 757
 758   def mutable_entity_value(self): self.has_entity_value_ = 1; return self.entity_value()
 759
 760   def clear_entity_value(self):
 761
 762     if self.has_entity_value_:
 763       self.has_entity_value_ = 0;
 764       if self.entity_value_ is not None: self.entity_value_.Clear()
 765
 766   def has_entity_value(self): return self.has_entity_value_
 767
 768   def list_value_size(self): return len(self.list_value_)
 769   def list_value_list(self): return self.list_value_
 770
 771   def list_value(self, i):
 772     return self.list_value_[i]
 773
 774   def mutable_list_value(self, i):
 775     return self.list_value_[i]
 776
 777   def add_list_value(self):
 778     x = Value()
 779     self.list_value_.append(x)
 780     return x
 781
 782   def clear_list_value(self):
 783     self.list_value_ = []
 784   def meaning(self): return self.meaning_
 785
 786   def set_meaning(self, x):
 787     self.has_meaning_ = 1
 788     self.meaning_ = x
 789
 790   def clear_meaning(self):
 791     if self.has_meaning_:
 792       self.has_meaning_ = 0
 793       self.meaning_ = 0
 794
 795   def has_meaning(self): return self.has_meaning_
 796
 797   def indexed(self): return self.indexed_
 798
 799   def set_indexed(self, x):
 800     self.has_indexed_ = 1
 801     self.indexed_ = x
 802
 803   def clear_indexed(self):
 804     if self.has_indexed_:
 805       self.has_indexed_ = 0
 806       self.indexed_ = 1
 807
 808   def has_indexed(self): return self.has_indexed_
 809
 810
 811   def MergeFrom(self, x):
 812     assert x is not self
 813     if (x.has_boolean_value()): self.set_boolean_value(x.boolean_value())
 814     if (x.has_integer_value()): self.set_integer_value(x.integer_value())
 815     if (x.has_double_value()): self.set_double_value(x.double_value())
 816     if (x.has_timestamp_microseconds_value()): self.set_timestamp_microseconds_value(x.timestamp_microseconds_value())
 817     if (x.has_key_value()): self.mutable_key_value().MergeFrom(x.key_value())
 818     if (x.has_blob_key_value()): self.set_blob_key_value(x.blob_key_value())
 819     if (x.has_string_value()): self.set_string_value(x.string_value())
 820     if (x.has_blob_value()): self.set_blob_value(x.blob_value())
 821     if (x.has_entity_value()): self.mutable_entity_value().MergeFrom(x.entity_value())
 822     for i in xrange(x.list_value_size()): self.add_list_value().CopyFrom(x.list_value(i))
 823     if (x.has_meaning()): self.set_meaning(x.meaning())
 824     if (x.has_indexed()): self.set_indexed(x.indexed())
 825
 826   if _net_proto___parse__python is not None:
 827     def _CMergeFromString(self, s):
 828       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Value', s)
 829
 830   if _net_proto___parse__python is not None:
 831     def _CEncode(self):
 832       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Value')
 833
 834   if _net_proto___parse__python is not None:
 835     def _CEncodePartial(self):
 836       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Value')
 837
 838   if _net_proto___parse__python is not None:
 839     def _CToASCII(self, output_format):
 840       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Value', output_format)
 841
 842
 843   if _net_proto___parse__python is not None:
 844     def ParseASCII(self, s):
 845       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Value', s)
 846
 847
 848   if _net_proto___parse__python is not None:
 849     def ParseASCIIIgnoreUnknown(self, s):
 850       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Value', s)
 851
 852
 853   def Equals(self, x):
 854     if x is self: return 1
 855     if self.has_boolean_value_ != x.has_boolean_value_: return 0
 856     if self.has_boolean_value_ and self.boolean_value_ != x.boolean_value_: return 0
 857     if self.has_integer_value_ != x.has_integer_value_: return 0
 858     if self.has_integer_value_ and self.integer_value_ != x.integer_value_: return 0
 859     if self.has_double_value_ != x.has_double_value_: return 0
 860     if self.has_double_value_ and self.double_value_ != x.double_value_: return 0
 861     if self.has_timestamp_microseconds_value_ != x.has_timestamp_microseconds_value_: return 0
 862     if self.has_timestamp_microseconds_value_ and self.timestamp_microseconds_value_ != x.timestamp_microseconds_value_: return 0
 863     if self.has_key_value_ != x.has_key_value_: return 0
 864     if self.has_key_value_ and self.key_value_ != x.key_value_: return 0
 865     if self.has_blob_key_value_ != x.has_blob_key_value_: return 0
 866     if self.has_blob_key_value_ and self.blob_key_value_ != x.blob_key_value_: return 0
 867     if self.has_string_value_ != x.has_string_value_: return 0
 868     if self.has_string_value_ and self.string_value_ != x.string_value_: return 0
 869     if self.has_blob_value_ != x.has_blob_value_: return 0
 870     if self.has_blob_value_ and self.blob_value_ != x.blob_value_: return 0
 871     if self.has_entity_value_ != x.has_entity_value_: return 0
 872     if self.has_entity_value_ and self.entity_value_ != x.entity_value_: return 0
 873     if len(self.list_value_) != len(x.list_value_): return 0
 874     for e1, e2 in zip(self.list_value_, x.list_value_):
 875       if e1 != e2: return 0
 876     if self.has_meaning_ != x.has_meaning_: return 0
 877     if self.has_meaning_ and self.meaning_ != x.meaning_: return 0
 878     if self.has_indexed_ != x.has_indexed_: return 0
 879     if self.has_indexed_ and self.indexed_ != x.indexed_: return 0
 880     return 1
 881
 882   def IsInitialized(self, debug_strs=None):
 883     initialized = 1
 884     if (self.has_key_value_ and not self.key_value_.IsInitialized(debug_strs)): initialized = 0
 885     if (self.has_entity_value_ and not self.entity_value_.IsInitialized(debug_strs)): initialized = 0
 886     for p in self.list_value_:
 887       if not p.IsInitialized(debug_strs): initialized=0
 888     return initialized
 889
 890   def ByteSize(self):
 891     n = 0
 892     if (self.has_boolean_value_): n += 2
 893     if (self.has_integer_value_): n += 1 + self.lengthVarInt64(self.integer_value_)
 894     if (self.has_double_value_): n += 9
 895     if (self.has_timestamp_microseconds_value_): n += 1 + self.lengthVarInt64(self.timestamp_microseconds_value_)
 896     if (self.has_key_value_): n += 1 + self.lengthString(self.key_value_.ByteSize())
 897     if (self.has_blob_key_value_): n += 2 + self.lengthString(len(self.blob_key_value_))
 898     if (self.has_string_value_): n += 2 + self.lengthString(len(self.string_value_))
 899     if (self.has_blob_value_): n += 2 + self.lengthString(len(self.blob_value_))
 900     if (self.has_entity_value_): n += 1 + self.lengthString(self.entity_value_.ByteSize())
 901     n += 1 * len(self.list_value_)
 902     for i in xrange(len(self.list_value_)): n += self.lengthString(self.list_value_[i].ByteSize())
 903     if (self.has_meaning_): n += 1 + self.lengthVarInt64(self.meaning_)
 904     if (self.has_indexed_): n += 2
 905     return n
 906
 907   def ByteSizePartial(self):
 908     n = 0
 909     if (self.has_boolean_value_): n += 2
 910     if (self.has_integer_value_): n += 1 + self.lengthVarInt64(self.integer_value_)
 911     if (self.has_double_value_): n += 9
 912     if (self.has_timestamp_microseconds_value_): n += 1 + self.lengthVarInt64(self.timestamp_microseconds_value_)
 913     if (self.has_key_value_): n += 1 + self.lengthString(self.key_value_.ByteSizePartial())
 914     if (self.has_blob_key_value_): n += 2 + self.lengthString(len(self.blob_key_value_))
 915     if (self.has_string_value_): n += 2 + self.lengthString(len(self.string_value_))
 916     if (self.has_blob_value_): n += 2 + self.lengthString(len(self.blob_value_))
 917     if (self.has_entity_value_): n += 1 + self.lengthString(self.entity_value_.ByteSizePartial())
 918     n += 1 * len(self.list_value_)
 919     for i in xrange(len(self.list_value_)): n += self.lengthString(self.list_value_[i].ByteSizePartial())
 920     if (self.has_meaning_): n += 1 + self.lengthVarInt64(self.meaning_)
 921     if (self.has_indexed_): n += 2
 922     return n
 923
 924   def Clear(self):
 925     self.clear_boolean_value()
 926     self.clear_integer_value()
 927     self.clear_double_value()
 928     self.clear_timestamp_microseconds_value()
 929     self.clear_key_value()
 930     self.clear_blob_key_value()
 931     self.clear_string_value()
 932     self.clear_blob_value()
 933     self.clear_entity_value()
 934     self.clear_list_value()
 935     self.clear_meaning()
 936     self.clear_indexed()
 937
 938   def OutputUnchecked(self, out):
 939     if (self.has_boolean_value_):
 940       out.putVarInt32(8)
 941       out.putBoolean(self.boolean_value_)
 942     if (self.has_integer_value_):
 943       out.putVarInt32(16)
 944       out.putVarInt64(self.integer_value_)
 945     if (self.has_double_value_):
 946       out.putVarInt32(25)
 947       out.putDouble(self.double_value_)
 948     if (self.has_timestamp_microseconds_value_):
 949       out.putVarInt32(32)
 950       out.putVarInt64(self.timestamp_microseconds_value_)
 951     if (self.has_key_value_):
 952       out.putVarInt32(42)
 953       out.putVarInt32(self.key_value_.ByteSize())
 954       self.key_value_.OutputUnchecked(out)
 955     if (self.has_entity_value_):
 956       out.putVarInt32(50)
 957       out.putVarInt32(self.entity_value_.ByteSize())
 958       self.entity_value_.OutputUnchecked(out)
 959     for i in xrange(len(self.list_value_)):
 960       out.putVarInt32(58)
 961       out.putVarInt32(self.list_value_[i].ByteSize())
 962       self.list_value_[i].OutputUnchecked(out)
 963     if (self.has_meaning_):
 964       out.putVarInt32(112)
 965       out.putVarInt32(self.meaning_)
 966     if (self.has_indexed_):
 967       out.putVarInt32(120)
 968       out.putBoolean(self.indexed_)
 969     if (self.has_blob_key_value_):
 970       out.putVarInt32(130)
 971       out.putPrefixedString(self.blob_key_value_)
 972     if (self.has_string_value_):
 973       out.putVarInt32(138)
 974       out.putPrefixedString(self.string_value_)
 975     if (self.has_blob_value_):
 976       out.putVarInt32(146)
 977       out.putPrefixedString(self.blob_value_)
 978
 979   def OutputPartial(self, out):
 980     if (self.has_boolean_value_):
 981       out.putVarInt32(8)
 982       out.putBoolean(self.boolean_value_)
 983     if (self.has_integer_value_):
 984       out.putVarInt32(16)
 985       out.putVarInt64(self.integer_value_)
 986     if (self.has_double_value_):
 987       out.putVarInt32(25)
 988       out.putDouble(self.double_value_)
 989     if (self.has_timestamp_microseconds_value_):
 990       out.putVarInt32(32)
 991       out.putVarInt64(self.timestamp_microseconds_value_)
 992     if (self.has_key_value_):
 993       out.putVarInt32(42)
 994       out.putVarInt32(self.key_value_.ByteSizePartial())
 995       self.key_value_.OutputPartial(out)
 996     if (self.has_entity_value_):
 997       out.putVarInt32(50)
 998       out.putVarInt32(self.entity_value_.ByteSizePartial())
 999       self.entity_value_.OutputPartial(out)
1000     for i in xrange(len(self.list_value_)):
1001       out.putVarInt32(58)
1002       out.putVarInt32(self.list_value_[i].ByteSizePartial())
1003       self.list_value_[i].OutputPartial(out)
1004     if (self.has_meaning_):
1005       out.putVarInt32(112)
1006       out.putVarInt32(self.meaning_)
1007     if (self.has_indexed_):
1008       out.putVarInt32(120)
1009       out.putBoolean(self.indexed_)
1010     if (self.has_blob_key_value_):
1011       out.putVarInt32(130)
1012       out.putPrefixedString(self.blob_key_value_)
1013     if (self.has_string_value_):
1014       out.putVarInt32(138)
1015       out.putPrefixedString(self.string_value_)
1016     if (self.has_blob_value_):
1017       out.putVarInt32(146)
1018       out.putPrefixedString(self.blob_value_)
1019
1020   def TryMerge(self, d):
1021     while d.avail() > 0:
1022       tt = d.getVarInt32()
1023       if tt == 8:
1024         self.set_boolean_value(d.getBoolean())
1025         continue
1026       if tt == 16:
1027         self.set_integer_value(d.getVarInt64())
1028         continue
1029       if tt == 25:
1030         self.set_double_value(d.getDouble())
1031         continue
1032       if tt == 32:
1033         self.set_timestamp_microseconds_value(d.getVarInt64())
1034         continue
1035       if tt == 42:
1036         length = d.getVarInt32()
1037         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1038         d.skip(length)
1039         self.mutable_key_value().TryMerge(tmp)
1040         continue
1041       if tt == 50:
1042         length = d.getVarInt32()
1043         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1044         d.skip(length)
1045         self.mutable_entity_value().TryMerge(tmp)
1046         continue
1047       if tt == 58:
1048         length = d.getVarInt32()
1049         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1050         d.skip(length)
1051         self.add_list_value().TryMerge(tmp)
1052         continue
1053       if tt == 112:
1054         self.set_meaning(d.getVarInt32())
1055         continue
1056       if tt == 120:
1057         self.set_indexed(d.getBoolean())
1058         continue
1059       if tt == 130:
1060         self.set_blob_key_value(d.getPrefixedString())
1061         continue
1062       if tt == 138:
1063         self.set_string_value(d.getPrefixedString())
1064         continue
1065       if tt == 146:
1066         self.set_blob_value(d.getPrefixedString())
1067         continue
1068
1069
1070       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1071       d.skipData(tt)
1072
1073
1074   def __str__(self, prefix="", printElemNumber=0):
1075     res=""
1076     if self.has_boolean_value_: res+=prefix+("boolean_value: %s\n" % self.DebugFormatBool(self.boolean_value_))
1077     if self.has_integer_value_: res+=prefix+("integer_value: %s\n" % self.DebugFormatInt64(self.integer_value_))
1078     if self.has_double_value_: res+=prefix+("double_value: %s\n" % self.DebugFormat(self.double_value_))
1079     if self.has_timestamp_microseconds_value_: res+=prefix+("timestamp_microseconds_value: %s\n" % self.DebugFormatInt64(self.timestamp_microseconds_value_))
1080     if self.has_key_value_:
1081       res+=prefix+"key_value <\n"
1082       res+=self.key_value_.__str__(prefix + "  ", printElemNumber)
1083       res+=prefix+">\n"
1084     if self.has_blob_key_value_: res+=prefix+("blob_key_value: %s\n" % self.DebugFormatString(self.blob_key_value_))
1085     if self.has_string_value_: res+=prefix+("string_value: %s\n" % self.DebugFormatString(self.string_value_))
1086     if self.has_blob_value_: res+=prefix+("blob_value: %s\n" % self.DebugFormatString(self.blob_value_))
1087     if self.has_entity_value_:
1088       res+=prefix+"entity_value <\n"
1089       res+=self.entity_value_.__str__(prefix + "  ", printElemNumber)
1090       res+=prefix+">\n"
1091     cnt=0
1092     for e in self.list_value_:
1093       elm=""
1094       if printElemNumber: elm="(%d)" % cnt
1095       res+=prefix+("list_value%s <\n" % elm)
1096       res+=e.__str__(prefix + "  ", printElemNumber)
1097       res+=prefix+">\n"
1098       cnt+=1
1099     if self.has_meaning_: res+=prefix+("meaning: %s\n" % self.DebugFormatInt32(self.meaning_))
1100     if self.has_indexed_: res+=prefix+("indexed: %s\n" % self.DebugFormatBool(self.indexed_))
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   kboolean_value = 1
1108   kinteger_value = 2
1109   kdouble_value = 3
1110   ktimestamp_microseconds_value = 4
1111   kkey_value = 5
1112   kblob_key_value = 16
1113   kstring_value = 17
1114   kblob_value = 18
1115   kentity_value = 6
1116   klist_value = 7
1117   kmeaning = 14
1118   kindexed = 15
1119
1120   _TEXT = _BuildTagLookupTable({
1121     0: "ErrorCode",
1122     1: "boolean_value",
1123     2: "integer_value",
1124     3: "double_value",
1125     4: "timestamp_microseconds_value",
1126     5: "key_value",
1127     6: "entity_value",
1128     7: "list_value",
1129     14: "meaning",
1130     15: "indexed",
1131     16: "blob_key_value",
1132     17: "string_value",
1133     18: "blob_value",
1134   }, 18)
1135
1136   _TYPES = _BuildTagLookupTable({
1137     0: ProtocolBuffer.Encoder.NUMERIC,
1138     1: ProtocolBuffer.Encoder.NUMERIC,
1139     2: ProtocolBuffer.Encoder.NUMERIC,
1140     3: ProtocolBuffer.Encoder.DOUBLE,
1141     4: ProtocolBuffer.Encoder.NUMERIC,
1142     5: ProtocolBuffer.Encoder.STRING,
1143     6: ProtocolBuffer.Encoder.STRING,
1144     7: ProtocolBuffer.Encoder.STRING,
1145     14: ProtocolBuffer.Encoder.NUMERIC,
1146     15: ProtocolBuffer.Encoder.NUMERIC,
1147     16: ProtocolBuffer.Encoder.STRING,
1148     17: ProtocolBuffer.Encoder.STRING,
1149     18: ProtocolBuffer.Encoder.STRING,
1150   }, 18, ProtocolBuffer.Encoder.MAX_TYPE)
1151
1152
1153   _STYLE = """"""
1154   _STYLE_CONTENT_TYPE = """"""
1155   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Value'
1156   _SERIALIZED_DESCRIPTOR = array.array('B')
1157   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WiRhcHBob3N0aW5nL2RhdGFzdG9yZS9lbnRpdHlfdjQucHJvdG8KHWFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlZhbHVlExoNYm9vbGVhbl92YWx1ZSABKAAwCDgBFBMaDWludGVnZXJfdmFsdWUgAigAMAM4ARQTGgxkb3VibGVfdmFsdWUgAygBMAE4ARQTGhx0aW1lc3RhbXBfbWljcm9zZWNvbmRzX3ZhbHVlIAQoADADOAEUExoJa2V5X3ZhbHVlIAUoAjALOAFKG2FwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LktleaMBqgEFY3R5cGWyAQZwcm90bzKkARQTGg5ibG9iX2tleV92YWx1ZSAQKAIwCTgBFBMaDHN0cmluZ192YWx1ZSARKAIwCTgBFBMaCmJsb2JfdmFsdWUgEigCMAk4ARQTGgxlbnRpdHlfdmFsdWUgBigCMAs4AUoeYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuRW50aXR5owGqAQVjdHlwZbIBBnByb3RvMqQBFBMaCmxpc3RfdmFsdWUgBygCMAs4A0odYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuVmFsdWWjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoHbWVhbmluZyAOKAAwBTgBFBMaB2luZGV4ZWQgDygAMAg4AUIEdHJ1ZaMBqgEHZGVmYXVsdLIBBHRydWWkARTCASNhcHBob3N0aW5nLmRhdGFzdG9yZS52NC5QYXJ0aXRpb25JZA=="))
1158   if _net_proto___parse__python is not None:
1159     _net_proto___parse__python.RegisterType(
1160         _SERIALIZED_DESCRIPTOR.tostring())
1161
1162 class Property(ProtocolBuffer.ProtocolMessage):
1163   has_name_ = 0
1164   name_ = ""
1165   has_deprecated_multi_ = 0
1166   deprecated_multi_ = 0
1167   has_value_ = 0
1168   value_ = None
1169
1170   def __init__(self, contents=None):
1171     self.deprecated_value_ = []
1172     self.lazy_init_lock_ = thread.allocate_lock()
1173     if contents is not None: self.MergeFromString(contents)
1174
1175   def name(self): return self.name_
1176
1177   def set_name(self, x):
1178     self.has_name_ = 1
1179     self.name_ = x
1180
1181   def clear_name(self):
1182     if self.has_name_:
1183       self.has_name_ = 0
1184       self.name_ = ""
1185
1186   def has_name(self): return self.has_name_
1187
1188   def deprecated_multi(self): return self.deprecated_multi_
1189
1190   def set_deprecated_multi(self, x):
1191     self.has_deprecated_multi_ = 1
1192     self.deprecated_multi_ = x
1193
1194   def clear_deprecated_multi(self):
1195     if self.has_deprecated_multi_:
1196       self.has_deprecated_multi_ = 0
1197       self.deprecated_multi_ = 0
1198
1199   def has_deprecated_multi(self): return self.has_deprecated_multi_
1200
1201   def deprecated_value_size(self): return len(self.deprecated_value_)
1202   def deprecated_value_list(self): return self.deprecated_value_
1203
1204   def deprecated_value(self, i):
1205     return self.deprecated_value_[i]
1206
1207   def mutable_deprecated_value(self, i):
1208     return self.deprecated_value_[i]
1209
1210   def add_deprecated_value(self):
1211     x = Value()
1212     self.deprecated_value_.append(x)
1213     return x
1214
1215   def clear_deprecated_value(self):
1216     self.deprecated_value_ = []
1217   def value(self):
1218     if self.value_ is None:
1219       self.lazy_init_lock_.acquire()
1220       try:
1221         if self.value_ is None: self.value_ = Value()
1222       finally:
1223         self.lazy_init_lock_.release()
1224     return self.value_
1225
1226   def mutable_value(self): self.has_value_ = 1; return self.value()
1227
1228   def clear_value(self):
1229
1230     if self.has_value_:
1231       self.has_value_ = 0;
1232       if self.value_ is not None: self.value_.Clear()
1233
1234   def has_value(self): return self.has_value_
1235
1236
1237   def MergeFrom(self, x):
1238     assert x is not self
1239     if (x.has_name()): self.set_name(x.name())
1240     if (x.has_deprecated_multi()): self.set_deprecated_multi(x.deprecated_multi())
1241     for i in xrange(x.deprecated_value_size()): self.add_deprecated_value().CopyFrom(x.deprecated_value(i))
1242     if (x.has_value()): self.mutable_value().MergeFrom(x.value())
1243
1244   if _net_proto___parse__python is not None:
1245     def _CMergeFromString(self, s):
1246       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Property', s)
1247
1248   if _net_proto___parse__python is not None:
1249     def _CEncode(self):
1250       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Property')
1251
1252   if _net_proto___parse__python is not None:
1253     def _CEncodePartial(self):
1254       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Property')
1255
1256   if _net_proto___parse__python is not None:
1257     def _CToASCII(self, output_format):
1258       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Property', output_format)
1259
1260
1261   if _net_proto___parse__python is not None:
1262     def ParseASCII(self, s):
1263       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Property', s)
1264
1265
1266   if _net_proto___parse__python is not None:
1267     def ParseASCIIIgnoreUnknown(self, s):
1268       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Property', s)
1269
1270
1271   def Equals(self, x):
1272     if x is self: return 1
1273     if self.has_name_ != x.has_name_: return 0
1274     if self.has_name_ and self.name_ != x.name_: return 0
1275     if self.has_deprecated_multi_ != x.has_deprecated_multi_: return 0
1276     if self.has_deprecated_multi_ and self.deprecated_multi_ != x.deprecated_multi_: return 0
1277     if len(self.deprecated_value_) != len(x.deprecated_value_): return 0
1278     for e1, e2 in zip(self.deprecated_value_, x.deprecated_value_):
1279       if e1 != e2: return 0
1280     if self.has_value_ != x.has_value_: return 0
1281     if self.has_value_ and self.value_ != x.value_: return 0
1282     return 1
1283
1284   def IsInitialized(self, debug_strs=None):
1285     initialized = 1
1286     if (not self.has_name_):
1287       initialized = 0
1288       if debug_strs is not None:
1289         debug_strs.append('Required field: name not set.')
1290     for p in self.deprecated_value_:
1291       if not p.IsInitialized(debug_strs): initialized=0
1292     if (self.has_value_ and not self.value_.IsInitialized(debug_strs)): initialized = 0
1293     return initialized
1294
1295   def ByteSize(self):
1296     n = 0
1297     n += self.lengthString(len(self.name_))
1298     if (self.has_deprecated_multi_): n += 2
1299     n += 1 * len(self.deprecated_value_)
1300     for i in xrange(len(self.deprecated_value_)): n += self.lengthString(self.deprecated_value_[i].ByteSize())
1301     if (self.has_value_): n += 1 + self.lengthString(self.value_.ByteSize())
1302     return n + 1
1303
1304   def ByteSizePartial(self):
1305     n = 0
1306     if (self.has_name_):
1307       n += 1
1308       n += self.lengthString(len(self.name_))
1309     if (self.has_deprecated_multi_): n += 2
1310     n += 1 * len(self.deprecated_value_)
1311     for i in xrange(len(self.deprecated_value_)): n += self.lengthString(self.deprecated_value_[i].ByteSizePartial())
1312     if (self.has_value_): n += 1 + self.lengthString(self.value_.ByteSizePartial())
1313     return n
1314
1315   def Clear(self):
1316     self.clear_name()
1317     self.clear_deprecated_multi()
1318     self.clear_deprecated_value()
1319     self.clear_value()
1320
1321   def OutputUnchecked(self, out):
1322     out.putVarInt32(10)
1323     out.putPrefixedString(self.name_)
1324     if (self.has_deprecated_multi_):
1325       out.putVarInt32(16)
1326       out.putBoolean(self.deprecated_multi_)
1327     for i in xrange(len(self.deprecated_value_)):
1328       out.putVarInt32(26)
1329       out.putVarInt32(self.deprecated_value_[i].ByteSize())
1330       self.deprecated_value_[i].OutputUnchecked(out)
1331     if (self.has_value_):
1332       out.putVarInt32(34)
1333       out.putVarInt32(self.value_.ByteSize())
1334       self.value_.OutputUnchecked(out)
1335
1336   def OutputPartial(self, out):
1337     if (self.has_name_):
1338       out.putVarInt32(10)
1339       out.putPrefixedString(self.name_)
1340     if (self.has_deprecated_multi_):
1341       out.putVarInt32(16)
1342       out.putBoolean(self.deprecated_multi_)
1343     for i in xrange(len(self.deprecated_value_)):
1344       out.putVarInt32(26)
1345       out.putVarInt32(self.deprecated_value_[i].ByteSizePartial())
1346       self.deprecated_value_[i].OutputPartial(out)
1347     if (self.has_value_):
1348       out.putVarInt32(34)
1349       out.putVarInt32(self.value_.ByteSizePartial())
1350       self.value_.OutputPartial(out)
1351
1352   def TryMerge(self, d):
1353     while d.avail() > 0:
1354       tt = d.getVarInt32()
1355       if tt == 10:
1356         self.set_name(d.getPrefixedString())
1357         continue
1358       if tt == 16:
1359         self.set_deprecated_multi(d.getBoolean())
1360         continue
1361       if tt == 26:
1362         length = d.getVarInt32()
1363         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1364         d.skip(length)
1365         self.add_deprecated_value().TryMerge(tmp)
1366         continue
1367       if tt == 34:
1368         length = d.getVarInt32()
1369         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1370         d.skip(length)
1371         self.mutable_value().TryMerge(tmp)
1372         continue
1373
1374
1375       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1376       d.skipData(tt)
1377
1378
1379   def __str__(self, prefix="", printElemNumber=0):
1380     res=""
1381     if self.has_name_: res+=prefix+("name: %s\n" % self.DebugFormatString(self.name_))
1382     if self.has_deprecated_multi_: res+=prefix+("deprecated_multi: %s\n" % self.DebugFormatBool(self.deprecated_multi_))
1383     cnt=0
1384     for e in self.deprecated_value_:
1385       elm=""
1386       if printElemNumber: elm="(%d)" % cnt
1387       res+=prefix+("deprecated_value%s <\n" % elm)
1388       res+=e.__str__(prefix + "  ", printElemNumber)
1389       res+=prefix+">\n"
1390       cnt+=1
1391     if self.has_value_:
1392       res+=prefix+"value <\n"
1393       res+=self.value_.__str__(prefix + "  ", printElemNumber)
1394       res+=prefix+">\n"
1395     return res
1396
1397
1398   def _BuildTagLookupTable(sparse, maxtag, default=None):
1399     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1400
1401   kname = 1
1402   kdeprecated_multi = 2
1403   kdeprecated_value = 3
1404   kvalue = 4
1405
1406   _TEXT = _BuildTagLookupTable({
1407     0: "ErrorCode",
1408     1: "name",
1409     2: "deprecated_multi",
1410     3: "deprecated_value",
1411     4: "value",
1412   }, 4)
1413
1414   _TYPES = _BuildTagLookupTable({
1415     0: ProtocolBuffer.Encoder.NUMERIC,
1416     1: ProtocolBuffer.Encoder.STRING,
1417     2: ProtocolBuffer.Encoder.NUMERIC,
1418     3: ProtocolBuffer.Encoder.STRING,
1419     4: ProtocolBuffer.Encoder.STRING,
1420   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
1421
1422
1423   _STYLE = """"""
1424   _STYLE_CONTENT_TYPE = """"""
1425   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Property'
1426   _SERIALIZED_DESCRIPTOR = array.array('B')
1427   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WiRhcHBob3N0aW5nL2RhdGFzdG9yZS9lbnRpdHlfdjQucHJvdG8KIGFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LlByb3BlcnR5ExoEbmFtZSABKAIwCTgCFBMaEGRlcHJlY2F0ZWRfbXVsdGkgAigAMAg4AUIFZmFsc2WjAaoBB2RlZmF1bHSyAQVmYWxzZaQBFBMaEGRlcHJlY2F0ZWRfdmFsdWUgAygCMAs4A0odYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuVmFsdWWjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoFdmFsdWUgBCgCMAs4AUodYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuVmFsdWWjAaoBBWN0eXBlsgEGcHJvdG8ypAEUwgEjYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUGFydGl0aW9uSWQ="))
1428   if _net_proto___parse__python is not None:
1429     _net_proto___parse__python.RegisterType(
1430         _SERIALIZED_DESCRIPTOR.tostring())
1431
1432 class Entity(ProtocolBuffer.ProtocolMessage):
1433   has_key_ = 0
1434   key_ = None
1435
1436   def __init__(self, contents=None):
1437     self.property_ = []
1438     self.lazy_init_lock_ = thread.allocate_lock()
1439     if contents is not None: self.MergeFromString(contents)
1440
1441   def key(self):
1442     if self.key_ is None:
1443       self.lazy_init_lock_.acquire()
1444       try:
1445         if self.key_ is None: self.key_ = Key()
1446       finally:
1447         self.lazy_init_lock_.release()
1448     return self.key_
1449
1450   def mutable_key(self): self.has_key_ = 1; return self.key()
1451
1452   def clear_key(self):
1453
1454     if self.has_key_:
1455       self.has_key_ = 0;
1456       if self.key_ is not None: self.key_.Clear()
1457
1458   def has_key(self): return self.has_key_
1459
1460   def property_size(self): return len(self.property_)
1461   def property_list(self): return self.property_
1462
1463   def property(self, i):
1464     return self.property_[i]
1465
1466   def mutable_property(self, i):
1467     return self.property_[i]
1468
1469   def add_property(self):
1470     x = Property()
1471     self.property_.append(x)
1472     return x
1473
1474   def clear_property(self):
1475     self.property_ = []
1476
1477   def MergeFrom(self, x):
1478     assert x is not self
1479     if (x.has_key()): self.mutable_key().MergeFrom(x.key())
1480     for i in xrange(x.property_size()): self.add_property().CopyFrom(x.property(i))
1481
1482   if _net_proto___parse__python is not None:
1483     def _CMergeFromString(self, s):
1484       _net_proto___parse__python.MergeFromString(self, 'apphosting.datastore.v4.Entity', s)
1485
1486   if _net_proto___parse__python is not None:
1487     def _CEncode(self):
1488       return _net_proto___parse__python.Encode(self, 'apphosting.datastore.v4.Entity')
1489
1490   if _net_proto___parse__python is not None:
1491     def _CEncodePartial(self):
1492       return _net_proto___parse__python.EncodePartial(self, 'apphosting.datastore.v4.Entity')
1493
1494   if _net_proto___parse__python is not None:
1495     def _CToASCII(self, output_format):
1496       return _net_proto___parse__python.ToASCII(self, 'apphosting.datastore.v4.Entity', output_format)
1497
1498
1499   if _net_proto___parse__python is not None:
1500     def ParseASCII(self, s):
1501       _net_proto___parse__python.ParseASCII(self, 'apphosting.datastore.v4.Entity', s)
1502
1503
1504   if _net_proto___parse__python is not None:
1505     def ParseASCIIIgnoreUnknown(self, s):
1506       _net_proto___parse__python.ParseASCIIIgnoreUnknown(self, 'apphosting.datastore.v4.Entity', s)
1507
1508
1509   def Equals(self, x):
1510     if x is self: return 1
1511     if self.has_key_ != x.has_key_: return 0
1512     if self.has_key_ and self.key_ != x.key_: return 0
1513     if len(self.property_) != len(x.property_): return 0
1514     for e1, e2 in zip(self.property_, x.property_):
1515       if e1 != e2: return 0
1516     return 1
1517
1518   def IsInitialized(self, debug_strs=None):
1519     initialized = 1
1520     if (self.has_key_ and not self.key_.IsInitialized(debug_strs)): initialized = 0
1521     for p in self.property_:
1522       if not p.IsInitialized(debug_strs): initialized=0
1523     return initialized
1524
1525   def ByteSize(self):
1526     n = 0
1527     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSize())
1528     n += 1 * len(self.property_)
1529     for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSize())
1530     return n
1531
1532   def ByteSizePartial(self):
1533     n = 0
1534     if (self.has_key_): n += 1 + self.lengthString(self.key_.ByteSizePartial())
1535     n += 1 * len(self.property_)
1536     for i in xrange(len(self.property_)): n += self.lengthString(self.property_[i].ByteSizePartial())
1537     return n
1538
1539   def Clear(self):
1540     self.clear_key()
1541     self.clear_property()
1542
1543   def OutputUnchecked(self, out):
1544     if (self.has_key_):
1545       out.putVarInt32(10)
1546       out.putVarInt32(self.key_.ByteSize())
1547       self.key_.OutputUnchecked(out)
1548     for i in xrange(len(self.property_)):
1549       out.putVarInt32(18)
1550       out.putVarInt32(self.property_[i].ByteSize())
1551       self.property_[i].OutputUnchecked(out)
1552
1553   def OutputPartial(self, out):
1554     if (self.has_key_):
1555       out.putVarInt32(10)
1556       out.putVarInt32(self.key_.ByteSizePartial())
1557       self.key_.OutputPartial(out)
1558     for i in xrange(len(self.property_)):
1559       out.putVarInt32(18)
1560       out.putVarInt32(self.property_[i].ByteSizePartial())
1561       self.property_[i].OutputPartial(out)
1562
1563   def TryMerge(self, d):
1564     while d.avail() > 0:
1565       tt = d.getVarInt32()
1566       if tt == 10:
1567         length = d.getVarInt32()
1568         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1569         d.skip(length)
1570         self.mutable_key().TryMerge(tmp)
1571         continue
1572       if tt == 18:
1573         length = d.getVarInt32()
1574         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1575         d.skip(length)
1576         self.add_property().TryMerge(tmp)
1577         continue
1578
1579
1580       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1581       d.skipData(tt)
1582
1583
1584   def __str__(self, prefix="", printElemNumber=0):
1585     res=""
1586     if self.has_key_:
1587       res+=prefix+"key <\n"
1588       res+=self.key_.__str__(prefix + "  ", printElemNumber)
1589       res+=prefix+">\n"
1590     cnt=0
1591     for e in self.property_:
1592       elm=""
1593       if printElemNumber: elm="(%d)" % cnt
1594       res+=prefix+("property%s <\n" % elm)
1595       res+=e.__str__(prefix + "  ", printElemNumber)
1596       res+=prefix+">\n"
1597       cnt+=1
1598     return res
1599
1600
1601   def _BuildTagLookupTable(sparse, maxtag, default=None):
1602     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1603
1604   kkey = 1
1605   kproperty = 2
1606
1607   _TEXT = _BuildTagLookupTable({
1608     0: "ErrorCode",
1609     1: "key",
1610     2: "property",
1611   }, 2)
1612
1613   _TYPES = _BuildTagLookupTable({
1614     0: ProtocolBuffer.Encoder.NUMERIC,
1615     1: ProtocolBuffer.Encoder.STRING,
1616     2: ProtocolBuffer.Encoder.STRING,
1617   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1618
1619
1620   _STYLE = """"""
1621   _STYLE_CONTENT_TYPE = """"""
1622   _PROTO_DESCRIPTOR_NAME = 'apphosting.datastore.v4.Entity'
1623   _SERIALIZED_DESCRIPTOR = array.array('B')
1624   _SERIALIZED_DESCRIPTOR.fromstring(base64.decodestring("WiRhcHBob3N0aW5nL2RhdGFzdG9yZS9lbnRpdHlfdjQucHJvdG8KHmFwcGhvc3RpbmcuZGF0YXN0b3JlLnY0LkVudGl0eRMaA2tleSABKAIwCzgBShthcHBob3N0aW5nLmRhdGFzdG9yZS52NC5LZXmjAaoBBWN0eXBlsgEGcHJvdG8ypAEUExoIcHJvcGVydHkgAigCMAs4A0ogYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUHJvcGVydHmjAaoBBWN0eXBlsgEGcHJvdG8ypAEUwgEjYXBwaG9zdGluZy5kYXRhc3RvcmUudjQuUGFydGl0aW9uSWQ="))
1625   if _net_proto___parse__python is not None:
1626     _net_proto___parse__python.RegisterType(
1627         _SERIALIZED_DESCRIPTOR.tostring())
1628
1629 if _extension_runtime:
1630   pass
1631
1632 __all__ = ['PartitionId','Key_PathElement','Key','Value','Property','Entity']