python/google/appengine/api/blobstore/blobstore_service_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 dummy_thread as thread
  23
  24 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit
  25                    unusednames=printElemNumber,debug_strs no-special"""
  26
  27 if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'):
  28   _extension_runtime = True
  29   _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage
  30 else:
  31   _extension_runtime = False
  32   _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage
  33
  34 from google.appengine.api.api_base_pb import *
  35 import google.appengine.api.api_base_pb
  36 class BlobstoreServiceError(ProtocolBuffer.ProtocolMessage):
  37
  38
  39   OK           =    0
  40   INTERNAL_ERROR =    1
  41   URL_TOO_LONG =    2
  42   PERMISSION_DENIED =    3
  43   BLOB_NOT_FOUND =    4
  44   DATA_INDEX_OUT_OF_RANGE =    5
  45   BLOB_FETCH_SIZE_TOO_LARGE =    6
  46   ARGUMENT_OUT_OF_RANGE =    8
  47   INVALID_BLOB_KEY =    9
  48
  49   _ErrorCode_NAMES = {
  50     0: "OK",
  51     1: "INTERNAL_ERROR",
  52     2: "URL_TOO_LONG",
  53     3: "PERMISSION_DENIED",
  54     4: "BLOB_NOT_FOUND",
  55     5: "DATA_INDEX_OUT_OF_RANGE",
  56     6: "BLOB_FETCH_SIZE_TOO_LARGE",
  57     8: "ARGUMENT_OUT_OF_RANGE",
  58     9: "INVALID_BLOB_KEY",
  59   }
  60
  61   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  62   ErrorCode_Name = classmethod(ErrorCode_Name)
  63
  64
  65   def __init__(self, contents=None):
  66     pass
  67     if contents is not None: self.MergeFromString(contents)
  68
  69
  70   def MergeFrom(self, x):
  71     assert x is not self
  72
  73   def Equals(self, x):
  74     if x is self: return 1
  75     return 1
  76
  77   def IsInitialized(self, debug_strs=None):
  78     initialized = 1
  79     return initialized
  80
  81   def ByteSize(self):
  82     n = 0
  83     return n
  84
  85   def ByteSizePartial(self):
  86     n = 0
  87     return n
  88
  89   def Clear(self):
  90     pass
  91
  92   def OutputUnchecked(self, out):
  93     pass
  94
  95   def OutputPartial(self, out):
  96     pass
  97
  98   def TryMerge(self, d):
  99     while d.avail() > 0:
 100       tt = d.getVarInt32()
 101
 102
 103       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 104       d.skipData(tt)
 105
 106
 107   def __str__(self, prefix="", printElemNumber=0):
 108     res=""
 109     return res
 110
 111
 112   def _BuildTagLookupTable(sparse, maxtag, default=None):
 113     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 114
 115
 116   _TEXT = _BuildTagLookupTable({
 117     0: "ErrorCode",
 118   }, 0)
 119
 120   _TYPES = _BuildTagLookupTable({
 121     0: ProtocolBuffer.Encoder.NUMERIC,
 122   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
 123
 124
 125   _STYLE = """"""
 126   _STYLE_CONTENT_TYPE = """"""
 127   _PROTO_DESCRIPTOR_NAME = 'apphosting.BlobstoreServiceError'
 128 class CreateUploadURLRequest(ProtocolBuffer.ProtocolMessage):
 129   has_success_path_ = 0
 130   success_path_ = ""
 131   has_max_upload_size_bytes_ = 0
 132   max_upload_size_bytes_ = 0
 133   has_max_upload_size_per_blob_bytes_ = 0
 134   max_upload_size_per_blob_bytes_ = 0
 135   has_gs_bucket_name_ = 0
 136   gs_bucket_name_ = ""
 137
 138   def __init__(self, contents=None):
 139     if contents is not None: self.MergeFromString(contents)
 140
 141   def success_path(self): return self.success_path_
 142
 143   def set_success_path(self, x):
 144     self.has_success_path_ = 1
 145     self.success_path_ = x
 146
 147   def clear_success_path(self):
 148     if self.has_success_path_:
 149       self.has_success_path_ = 0
 150       self.success_path_ = ""
 151
 152   def has_success_path(self): return self.has_success_path_
 153
 154   def max_upload_size_bytes(self): return self.max_upload_size_bytes_
 155
 156   def set_max_upload_size_bytes(self, x):
 157     self.has_max_upload_size_bytes_ = 1
 158     self.max_upload_size_bytes_ = x
 159
 160   def clear_max_upload_size_bytes(self):
 161     if self.has_max_upload_size_bytes_:
 162       self.has_max_upload_size_bytes_ = 0
 163       self.max_upload_size_bytes_ = 0
 164
 165   def has_max_upload_size_bytes(self): return self.has_max_upload_size_bytes_
 166
 167   def max_upload_size_per_blob_bytes(self): return self.max_upload_size_per_blob_bytes_
 168
 169   def set_max_upload_size_per_blob_bytes(self, x):
 170     self.has_max_upload_size_per_blob_bytes_ = 1
 171     self.max_upload_size_per_blob_bytes_ = x
 172
 173   def clear_max_upload_size_per_blob_bytes(self):
 174     if self.has_max_upload_size_per_blob_bytes_:
 175       self.has_max_upload_size_per_blob_bytes_ = 0
 176       self.max_upload_size_per_blob_bytes_ = 0
 177
 178   def has_max_upload_size_per_blob_bytes(self): return self.has_max_upload_size_per_blob_bytes_
 179
 180   def gs_bucket_name(self): return self.gs_bucket_name_
 181
 182   def set_gs_bucket_name(self, x):
 183     self.has_gs_bucket_name_ = 1
 184     self.gs_bucket_name_ = x
 185
 186   def clear_gs_bucket_name(self):
 187     if self.has_gs_bucket_name_:
 188       self.has_gs_bucket_name_ = 0
 189       self.gs_bucket_name_ = ""
 190
 191   def has_gs_bucket_name(self): return self.has_gs_bucket_name_
 192
 193
 194   def MergeFrom(self, x):
 195     assert x is not self
 196     if (x.has_success_path()): self.set_success_path(x.success_path())
 197     if (x.has_max_upload_size_bytes()): self.set_max_upload_size_bytes(x.max_upload_size_bytes())
 198     if (x.has_max_upload_size_per_blob_bytes()): self.set_max_upload_size_per_blob_bytes(x.max_upload_size_per_blob_bytes())
 199     if (x.has_gs_bucket_name()): self.set_gs_bucket_name(x.gs_bucket_name())
 200
 201   def Equals(self, x):
 202     if x is self: return 1
 203     if self.has_success_path_ != x.has_success_path_: return 0
 204     if self.has_success_path_ and self.success_path_ != x.success_path_: return 0
 205     if self.has_max_upload_size_bytes_ != x.has_max_upload_size_bytes_: return 0
 206     if self.has_max_upload_size_bytes_ and self.max_upload_size_bytes_ != x.max_upload_size_bytes_: return 0
 207     if self.has_max_upload_size_per_blob_bytes_ != x.has_max_upload_size_per_blob_bytes_: return 0
 208     if self.has_max_upload_size_per_blob_bytes_ and self.max_upload_size_per_blob_bytes_ != x.max_upload_size_per_blob_bytes_: return 0
 209     if self.has_gs_bucket_name_ != x.has_gs_bucket_name_: return 0
 210     if self.has_gs_bucket_name_ and self.gs_bucket_name_ != x.gs_bucket_name_: return 0
 211     return 1
 212
 213   def IsInitialized(self, debug_strs=None):
 214     initialized = 1
 215     if (not self.has_success_path_):
 216       initialized = 0
 217       if debug_strs is not None:
 218         debug_strs.append('Required field: success_path not set.')
 219     return initialized
 220
 221   def ByteSize(self):
 222     n = 0
 223     n += self.lengthString(len(self.success_path_))
 224     if (self.has_max_upload_size_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_bytes_)
 225     if (self.has_max_upload_size_per_blob_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_per_blob_bytes_)
 226     if (self.has_gs_bucket_name_): n += 1 + self.lengthString(len(self.gs_bucket_name_))
 227     return n + 1
 228
 229   def ByteSizePartial(self):
 230     n = 0
 231     if (self.has_success_path_):
 232       n += 1
 233       n += self.lengthString(len(self.success_path_))
 234     if (self.has_max_upload_size_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_bytes_)
 235     if (self.has_max_upload_size_per_blob_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_per_blob_bytes_)
 236     if (self.has_gs_bucket_name_): n += 1 + self.lengthString(len(self.gs_bucket_name_))
 237     return n
 238
 239   def Clear(self):
 240     self.clear_success_path()
 241     self.clear_max_upload_size_bytes()
 242     self.clear_max_upload_size_per_blob_bytes()
 243     self.clear_gs_bucket_name()
 244
 245   def OutputUnchecked(self, out):
 246     out.putVarInt32(10)
 247     out.putPrefixedString(self.success_path_)
 248     if (self.has_max_upload_size_bytes_):
 249       out.putVarInt32(16)
 250       out.putVarInt64(self.max_upload_size_bytes_)
 251     if (self.has_max_upload_size_per_blob_bytes_):
 252       out.putVarInt32(24)
 253       out.putVarInt64(self.max_upload_size_per_blob_bytes_)
 254     if (self.has_gs_bucket_name_):
 255       out.putVarInt32(34)
 256       out.putPrefixedString(self.gs_bucket_name_)
 257
 258   def OutputPartial(self, out):
 259     if (self.has_success_path_):
 260       out.putVarInt32(10)
 261       out.putPrefixedString(self.success_path_)
 262     if (self.has_max_upload_size_bytes_):
 263       out.putVarInt32(16)
 264       out.putVarInt64(self.max_upload_size_bytes_)
 265     if (self.has_max_upload_size_per_blob_bytes_):
 266       out.putVarInt32(24)
 267       out.putVarInt64(self.max_upload_size_per_blob_bytes_)
 268     if (self.has_gs_bucket_name_):
 269       out.putVarInt32(34)
 270       out.putPrefixedString(self.gs_bucket_name_)
 271
 272   def TryMerge(self, d):
 273     while d.avail() > 0:
 274       tt = d.getVarInt32()
 275       if tt == 10:
 276         self.set_success_path(d.getPrefixedString())
 277         continue
 278       if tt == 16:
 279         self.set_max_upload_size_bytes(d.getVarInt64())
 280         continue
 281       if tt == 24:
 282         self.set_max_upload_size_per_blob_bytes(d.getVarInt64())
 283         continue
 284       if tt == 34:
 285         self.set_gs_bucket_name(d.getPrefixedString())
 286         continue
 287
 288
 289       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 290       d.skipData(tt)
 291
 292
 293   def __str__(self, prefix="", printElemNumber=0):
 294     res=""
 295     if self.has_success_path_: res+=prefix+("success_path: %s\n" % self.DebugFormatString(self.success_path_))
 296     if self.has_max_upload_size_bytes_: res+=prefix+("max_upload_size_bytes: %s\n" % self.DebugFormatInt64(self.max_upload_size_bytes_))
 297     if self.has_max_upload_size_per_blob_bytes_: res+=prefix+("max_upload_size_per_blob_bytes: %s\n" % self.DebugFormatInt64(self.max_upload_size_per_blob_bytes_))
 298     if self.has_gs_bucket_name_: res+=prefix+("gs_bucket_name: %s\n" % self.DebugFormatString(self.gs_bucket_name_))
 299     return res
 300
 301
 302   def _BuildTagLookupTable(sparse, maxtag, default=None):
 303     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 304
 305   ksuccess_path = 1
 306   kmax_upload_size_bytes = 2
 307   kmax_upload_size_per_blob_bytes = 3
 308   kgs_bucket_name = 4
 309
 310   _TEXT = _BuildTagLookupTable({
 311     0: "ErrorCode",
 312     1: "success_path",
 313     2: "max_upload_size_bytes",
 314     3: "max_upload_size_per_blob_bytes",
 315     4: "gs_bucket_name",
 316   }, 4)
 317
 318   _TYPES = _BuildTagLookupTable({
 319     0: ProtocolBuffer.Encoder.NUMERIC,
 320     1: ProtocolBuffer.Encoder.STRING,
 321     2: ProtocolBuffer.Encoder.NUMERIC,
 322     3: ProtocolBuffer.Encoder.NUMERIC,
 323     4: ProtocolBuffer.Encoder.STRING,
 324   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
 325
 326
 327   _STYLE = """"""
 328   _STYLE_CONTENT_TYPE = """"""
 329   _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateUploadURLRequest'
 330 class CreateUploadURLResponse(ProtocolBuffer.ProtocolMessage):
 331   has_url_ = 0
 332   url_ = ""
 333
 334   def __init__(self, contents=None):
 335     if contents is not None: self.MergeFromString(contents)
 336
 337   def url(self): return self.url_
 338
 339   def set_url(self, x):
 340     self.has_url_ = 1
 341     self.url_ = x
 342
 343   def clear_url(self):
 344     if self.has_url_:
 345       self.has_url_ = 0
 346       self.url_ = ""
 347
 348   def has_url(self): return self.has_url_
 349
 350
 351   def MergeFrom(self, x):
 352     assert x is not self
 353     if (x.has_url()): self.set_url(x.url())
 354
 355   def Equals(self, x):
 356     if x is self: return 1
 357     if self.has_url_ != x.has_url_: return 0
 358     if self.has_url_ and self.url_ != x.url_: return 0
 359     return 1
 360
 361   def IsInitialized(self, debug_strs=None):
 362     initialized = 1
 363     if (not self.has_url_):
 364       initialized = 0
 365       if debug_strs is not None:
 366         debug_strs.append('Required field: url not set.')
 367     return initialized
 368
 369   def ByteSize(self):
 370     n = 0
 371     n += self.lengthString(len(self.url_))
 372     return n + 1
 373
 374   def ByteSizePartial(self):
 375     n = 0
 376     if (self.has_url_):
 377       n += 1
 378       n += self.lengthString(len(self.url_))
 379     return n
 380
 381   def Clear(self):
 382     self.clear_url()
 383
 384   def OutputUnchecked(self, out):
 385     out.putVarInt32(10)
 386     out.putPrefixedString(self.url_)
 387
 388   def OutputPartial(self, out):
 389     if (self.has_url_):
 390       out.putVarInt32(10)
 391       out.putPrefixedString(self.url_)
 392
 393   def TryMerge(self, d):
 394     while d.avail() > 0:
 395       tt = d.getVarInt32()
 396       if tt == 10:
 397         self.set_url(d.getPrefixedString())
 398         continue
 399
 400
 401       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 402       d.skipData(tt)
 403
 404
 405   def __str__(self, prefix="", printElemNumber=0):
 406     res=""
 407     if self.has_url_: res+=prefix+("url: %s\n" % self.DebugFormatString(self.url_))
 408     return res
 409
 410
 411   def _BuildTagLookupTable(sparse, maxtag, default=None):
 412     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 413
 414   kurl = 1
 415
 416   _TEXT = _BuildTagLookupTable({
 417     0: "ErrorCode",
 418     1: "url",
 419   }, 1)
 420
 421   _TYPES = _BuildTagLookupTable({
 422     0: ProtocolBuffer.Encoder.NUMERIC,
 423     1: ProtocolBuffer.Encoder.STRING,
 424   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
 425
 426
 427   _STYLE = """"""
 428   _STYLE_CONTENT_TYPE = """"""
 429   _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateUploadURLResponse'
 430 class DeleteBlobRequest(ProtocolBuffer.ProtocolMessage):
 431   has_token_ = 0
 432   token_ = ""
 433
 434   def __init__(self, contents=None):
 435     self.blob_key_ = []
 436     if contents is not None: self.MergeFromString(contents)
 437
 438   def blob_key_size(self): return len(self.blob_key_)
 439   def blob_key_list(self): return self.blob_key_
 440
 441   def blob_key(self, i):
 442     return self.blob_key_[i]
 443
 444   def set_blob_key(self, i, x):
 445     self.blob_key_[i] = x
 446
 447   def add_blob_key(self, x):
 448     self.blob_key_.append(x)
 449
 450   def clear_blob_key(self):
 451     self.blob_key_ = []
 452
 453   def token(self): return self.token_
 454
 455   def set_token(self, x):
 456     self.has_token_ = 1
 457     self.token_ = x
 458
 459   def clear_token(self):
 460     if self.has_token_:
 461       self.has_token_ = 0
 462       self.token_ = ""
 463
 464   def has_token(self): return self.has_token_
 465
 466
 467   def MergeFrom(self, x):
 468     assert x is not self
 469     for i in xrange(x.blob_key_size()): self.add_blob_key(x.blob_key(i))
 470     if (x.has_token()): self.set_token(x.token())
 471
 472   def Equals(self, x):
 473     if x is self: return 1
 474     if len(self.blob_key_) != len(x.blob_key_): return 0
 475     for e1, e2 in zip(self.blob_key_, x.blob_key_):
 476       if e1 != e2: return 0
 477     if self.has_token_ != x.has_token_: return 0
 478     if self.has_token_ and self.token_ != x.token_: return 0
 479     return 1
 480
 481   def IsInitialized(self, debug_strs=None):
 482     initialized = 1
 483     return initialized
 484
 485   def ByteSize(self):
 486     n = 0
 487     n += 1 * len(self.blob_key_)
 488     for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i]))
 489     if (self.has_token_): n += 1 + self.lengthString(len(self.token_))
 490     return n
 491
 492   def ByteSizePartial(self):
 493     n = 0
 494     n += 1 * len(self.blob_key_)
 495     for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i]))
 496     if (self.has_token_): n += 1 + self.lengthString(len(self.token_))
 497     return n
 498
 499   def Clear(self):
 500     self.clear_blob_key()
 501     self.clear_token()
 502
 503   def OutputUnchecked(self, out):
 504     for i in xrange(len(self.blob_key_)):
 505       out.putVarInt32(10)
 506       out.putPrefixedString(self.blob_key_[i])
 507     if (self.has_token_):
 508       out.putVarInt32(18)
 509       out.putPrefixedString(self.token_)
 510
 511   def OutputPartial(self, out):
 512     for i in xrange(len(self.blob_key_)):
 513       out.putVarInt32(10)
 514       out.putPrefixedString(self.blob_key_[i])
 515     if (self.has_token_):
 516       out.putVarInt32(18)
 517       out.putPrefixedString(self.token_)
 518
 519   def TryMerge(self, d):
 520     while d.avail() > 0:
 521       tt = d.getVarInt32()
 522       if tt == 10:
 523         self.add_blob_key(d.getPrefixedString())
 524         continue
 525       if tt == 18:
 526         self.set_token(d.getPrefixedString())
 527         continue
 528
 529
 530       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 531       d.skipData(tt)
 532
 533
 534   def __str__(self, prefix="", printElemNumber=0):
 535     res=""
 536     cnt=0
 537     for e in self.blob_key_:
 538       elm=""
 539       if printElemNumber: elm="(%d)" % cnt
 540       res+=prefix+("blob_key%s: %s\n" % (elm, self.DebugFormatString(e)))
 541       cnt+=1
 542     if self.has_token_: res+=prefix+("token: %s\n" % self.DebugFormatString(self.token_))
 543     return res
 544
 545
 546   def _BuildTagLookupTable(sparse, maxtag, default=None):
 547     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 548
 549   kblob_key = 1
 550   ktoken = 2
 551
 552   _TEXT = _BuildTagLookupTable({
 553     0: "ErrorCode",
 554     1: "blob_key",
 555     2: "token",
 556   }, 2)
 557
 558   _TYPES = _BuildTagLookupTable({
 559     0: ProtocolBuffer.Encoder.NUMERIC,
 560     1: ProtocolBuffer.Encoder.STRING,
 561     2: ProtocolBuffer.Encoder.STRING,
 562   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
 563
 564
 565   _STYLE = """"""
 566   _STYLE_CONTENT_TYPE = """"""
 567   _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteBlobRequest'
 568 class FetchDataRequest(ProtocolBuffer.ProtocolMessage):
 569   has_blob_key_ = 0
 570   blob_key_ = ""
 571   has_start_index_ = 0
 572   start_index_ = 0
 573   has_end_index_ = 0
 574   end_index_ = 0
 575
 576   def __init__(self, contents=None):
 577     if contents is not None: self.MergeFromString(contents)
 578
 579   def blob_key(self): return self.blob_key_
 580
 581   def set_blob_key(self, x):
 582     self.has_blob_key_ = 1
 583     self.blob_key_ = x
 584
 585   def clear_blob_key(self):
 586     if self.has_blob_key_:
 587       self.has_blob_key_ = 0
 588       self.blob_key_ = ""
 589
 590   def has_blob_key(self): return self.has_blob_key_
 591
 592   def start_index(self): return self.start_index_
 593
 594   def set_start_index(self, x):
 595     self.has_start_index_ = 1
 596     self.start_index_ = x
 597
 598   def clear_start_index(self):
 599     if self.has_start_index_:
 600       self.has_start_index_ = 0
 601       self.start_index_ = 0
 602
 603   def has_start_index(self): return self.has_start_index_
 604
 605   def end_index(self): return self.end_index_
 606
 607   def set_end_index(self, x):
 608     self.has_end_index_ = 1
 609     self.end_index_ = x
 610
 611   def clear_end_index(self):
 612     if self.has_end_index_:
 613       self.has_end_index_ = 0
 614       self.end_index_ = 0
 615
 616   def has_end_index(self): return self.has_end_index_
 617
 618
 619   def MergeFrom(self, x):
 620     assert x is not self
 621     if (x.has_blob_key()): self.set_blob_key(x.blob_key())
 622     if (x.has_start_index()): self.set_start_index(x.start_index())
 623     if (x.has_end_index()): self.set_end_index(x.end_index())
 624
 625   def Equals(self, x):
 626     if x is self: return 1
 627     if self.has_blob_key_ != x.has_blob_key_: return 0
 628     if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0
 629     if self.has_start_index_ != x.has_start_index_: return 0
 630     if self.has_start_index_ and self.start_index_ != x.start_index_: return 0
 631     if self.has_end_index_ != x.has_end_index_: return 0
 632     if self.has_end_index_ and self.end_index_ != x.end_index_: return 0
 633     return 1
 634
 635   def IsInitialized(self, debug_strs=None):
 636     initialized = 1
 637     if (not self.has_blob_key_):
 638       initialized = 0
 639       if debug_strs is not None:
 640         debug_strs.append('Required field: blob_key not set.')
 641     if (not self.has_start_index_):
 642       initialized = 0
 643       if debug_strs is not None:
 644         debug_strs.append('Required field: start_index not set.')
 645     if (not self.has_end_index_):
 646       initialized = 0
 647       if debug_strs is not None:
 648         debug_strs.append('Required field: end_index not set.')
 649     return initialized
 650
 651   def ByteSize(self):
 652     n = 0
 653     n += self.lengthString(len(self.blob_key_))
 654     n += self.lengthVarInt64(self.start_index_)
 655     n += self.lengthVarInt64(self.end_index_)
 656     return n + 3
 657
 658   def ByteSizePartial(self):
 659     n = 0
 660     if (self.has_blob_key_):
 661       n += 1
 662       n += self.lengthString(len(self.blob_key_))
 663     if (self.has_start_index_):
 664       n += 1
 665       n += self.lengthVarInt64(self.start_index_)
 666     if (self.has_end_index_):
 667       n += 1
 668       n += self.lengthVarInt64(self.end_index_)
 669     return n
 670
 671   def Clear(self):
 672     self.clear_blob_key()
 673     self.clear_start_index()
 674     self.clear_end_index()
 675
 676   def OutputUnchecked(self, out):
 677     out.putVarInt32(10)
 678     out.putPrefixedString(self.blob_key_)
 679     out.putVarInt32(16)
 680     out.putVarInt64(self.start_index_)
 681     out.putVarInt32(24)
 682     out.putVarInt64(self.end_index_)
 683
 684   def OutputPartial(self, out):
 685     if (self.has_blob_key_):
 686       out.putVarInt32(10)
 687       out.putPrefixedString(self.blob_key_)
 688     if (self.has_start_index_):
 689       out.putVarInt32(16)
 690       out.putVarInt64(self.start_index_)
 691     if (self.has_end_index_):
 692       out.putVarInt32(24)
 693       out.putVarInt64(self.end_index_)
 694
 695   def TryMerge(self, d):
 696     while d.avail() > 0:
 697       tt = d.getVarInt32()
 698       if tt == 10:
 699         self.set_blob_key(d.getPrefixedString())
 700         continue
 701       if tt == 16:
 702         self.set_start_index(d.getVarInt64())
 703         continue
 704       if tt == 24:
 705         self.set_end_index(d.getVarInt64())
 706         continue
 707
 708
 709       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 710       d.skipData(tt)
 711
 712
 713   def __str__(self, prefix="", printElemNumber=0):
 714     res=""
 715     if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_))
 716     if self.has_start_index_: res+=prefix+("start_index: %s\n" % self.DebugFormatInt64(self.start_index_))
 717     if self.has_end_index_: res+=prefix+("end_index: %s\n" % self.DebugFormatInt64(self.end_index_))
 718     return res
 719
 720
 721   def _BuildTagLookupTable(sparse, maxtag, default=None):
 722     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 723
 724   kblob_key = 1
 725   kstart_index = 2
 726   kend_index = 3
 727
 728   _TEXT = _BuildTagLookupTable({
 729     0: "ErrorCode",
 730     1: "blob_key",
 731     2: "start_index",
 732     3: "end_index",
 733   }, 3)
 734
 735   _TYPES = _BuildTagLookupTable({
 736     0: ProtocolBuffer.Encoder.NUMERIC,
 737     1: ProtocolBuffer.Encoder.STRING,
 738     2: ProtocolBuffer.Encoder.NUMERIC,
 739     3: ProtocolBuffer.Encoder.NUMERIC,
 740   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
 741
 742
 743   _STYLE = """"""
 744   _STYLE_CONTENT_TYPE = """"""
 745   _PROTO_DESCRIPTOR_NAME = 'apphosting.FetchDataRequest'
 746 class FetchDataResponse(ProtocolBuffer.ProtocolMessage):
 747   has_data_ = 0
 748   data_ = ""
 749
 750   def __init__(self, contents=None):
 751     if contents is not None: self.MergeFromString(contents)
 752
 753   def data(self): return self.data_
 754
 755   def set_data(self, x):
 756     self.has_data_ = 1
 757     self.data_ = x
 758
 759   def clear_data(self):
 760     if self.has_data_:
 761       self.has_data_ = 0
 762       self.data_ = ""
 763
 764   def has_data(self): return self.has_data_
 765
 766
 767   def MergeFrom(self, x):
 768     assert x is not self
 769     if (x.has_data()): self.set_data(x.data())
 770
 771   def Equals(self, x):
 772     if x is self: return 1
 773     if self.has_data_ != x.has_data_: return 0
 774     if self.has_data_ and self.data_ != x.data_: return 0
 775     return 1
 776
 777   def IsInitialized(self, debug_strs=None):
 778     initialized = 1
 779     if (not self.has_data_):
 780       initialized = 0
 781       if debug_strs is not None:
 782         debug_strs.append('Required field: data not set.')
 783     return initialized
 784
 785   def ByteSize(self):
 786     n = 0
 787     n += self.lengthString(len(self.data_))
 788     return n + 2
 789
 790   def ByteSizePartial(self):
 791     n = 0
 792     if (self.has_data_):
 793       n += 2
 794       n += self.lengthString(len(self.data_))
 795     return n
 796
 797   def Clear(self):
 798     self.clear_data()
 799
 800   def OutputUnchecked(self, out):
 801     out.putVarInt32(8002)
 802     out.putPrefixedString(self.data_)
 803
 804   def OutputPartial(self, out):
 805     if (self.has_data_):
 806       out.putVarInt32(8002)
 807       out.putPrefixedString(self.data_)
 808
 809   def TryMerge(self, d):
 810     while d.avail() > 0:
 811       tt = d.getVarInt32()
 812       if tt == 8002:
 813         self.set_data(d.getPrefixedString())
 814         continue
 815
 816
 817       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 818       d.skipData(tt)
 819
 820
 821   def __str__(self, prefix="", printElemNumber=0):
 822     res=""
 823     if self.has_data_: res+=prefix+("data: %s\n" % self.DebugFormatString(self.data_))
 824     return res
 825
 826
 827   def _BuildTagLookupTable(sparse, maxtag, default=None):
 828     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 829
 830   kdata = 1000
 831
 832   _TEXT = _BuildTagLookupTable({
 833     0: "ErrorCode",
 834     1000: "data",
 835   }, 1000)
 836
 837   _TYPES = _BuildTagLookupTable({
 838     0: ProtocolBuffer.Encoder.NUMERIC,
 839     1000: ProtocolBuffer.Encoder.STRING,
 840   }, 1000, ProtocolBuffer.Encoder.MAX_TYPE)
 841
 842
 843   _STYLE = """"""
 844   _STYLE_CONTENT_TYPE = """"""
 845   _PROTO_DESCRIPTOR_NAME = 'apphosting.FetchDataResponse'
 846 class CloneBlobRequest(ProtocolBuffer.ProtocolMessage):
 847   has_blob_key_ = 0
 848   blob_key_ = ""
 849   has_mime_type_ = 0
 850   mime_type_ = ""
 851   has_target_app_id_ = 0
 852   target_app_id_ = ""
 853
 854   def __init__(self, contents=None):
 855     if contents is not None: self.MergeFromString(contents)
 856
 857   def blob_key(self): return self.blob_key_
 858
 859   def set_blob_key(self, x):
 860     self.has_blob_key_ = 1
 861     self.blob_key_ = x
 862
 863   def clear_blob_key(self):
 864     if self.has_blob_key_:
 865       self.has_blob_key_ = 0
 866       self.blob_key_ = ""
 867
 868   def has_blob_key(self): return self.has_blob_key_
 869
 870   def mime_type(self): return self.mime_type_
 871
 872   def set_mime_type(self, x):
 873     self.has_mime_type_ = 1
 874     self.mime_type_ = x
 875
 876   def clear_mime_type(self):
 877     if self.has_mime_type_:
 878       self.has_mime_type_ = 0
 879       self.mime_type_ = ""
 880
 881   def has_mime_type(self): return self.has_mime_type_
 882
 883   def target_app_id(self): return self.target_app_id_
 884
 885   def set_target_app_id(self, x):
 886     self.has_target_app_id_ = 1
 887     self.target_app_id_ = x
 888
 889   def clear_target_app_id(self):
 890     if self.has_target_app_id_:
 891       self.has_target_app_id_ = 0
 892       self.target_app_id_ = ""
 893
 894   def has_target_app_id(self): return self.has_target_app_id_
 895
 896
 897   def MergeFrom(self, x):
 898     assert x is not self
 899     if (x.has_blob_key()): self.set_blob_key(x.blob_key())
 900     if (x.has_mime_type()): self.set_mime_type(x.mime_type())
 901     if (x.has_target_app_id()): self.set_target_app_id(x.target_app_id())
 902
 903   def Equals(self, x):
 904     if x is self: return 1
 905     if self.has_blob_key_ != x.has_blob_key_: return 0
 906     if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0
 907     if self.has_mime_type_ != x.has_mime_type_: return 0
 908     if self.has_mime_type_ and self.mime_type_ != x.mime_type_: return 0
 909     if self.has_target_app_id_ != x.has_target_app_id_: return 0
 910     if self.has_target_app_id_ and self.target_app_id_ != x.target_app_id_: return 0
 911     return 1
 912
 913   def IsInitialized(self, debug_strs=None):
 914     initialized = 1
 915     if (not self.has_blob_key_):
 916       initialized = 0
 917       if debug_strs is not None:
 918         debug_strs.append('Required field: blob_key not set.')
 919     if (not self.has_mime_type_):
 920       initialized = 0
 921       if debug_strs is not None:
 922         debug_strs.append('Required field: mime_type not set.')
 923     if (not self.has_target_app_id_):
 924       initialized = 0
 925       if debug_strs is not None:
 926         debug_strs.append('Required field: target_app_id not set.')
 927     return initialized
 928
 929   def ByteSize(self):
 930     n = 0
 931     n += self.lengthString(len(self.blob_key_))
 932     n += self.lengthString(len(self.mime_type_))
 933     n += self.lengthString(len(self.target_app_id_))
 934     return n + 3
 935
 936   def ByteSizePartial(self):
 937     n = 0
 938     if (self.has_blob_key_):
 939       n += 1
 940       n += self.lengthString(len(self.blob_key_))
 941     if (self.has_mime_type_):
 942       n += 1
 943       n += self.lengthString(len(self.mime_type_))
 944     if (self.has_target_app_id_):
 945       n += 1
 946       n += self.lengthString(len(self.target_app_id_))
 947     return n
 948
 949   def Clear(self):
 950     self.clear_blob_key()
 951     self.clear_mime_type()
 952     self.clear_target_app_id()
 953
 954   def OutputUnchecked(self, out):
 955     out.putVarInt32(10)
 956     out.putPrefixedString(self.blob_key_)
 957     out.putVarInt32(18)
 958     out.putPrefixedString(self.mime_type_)
 959     out.putVarInt32(26)
 960     out.putPrefixedString(self.target_app_id_)
 961
 962   def OutputPartial(self, out):
 963     if (self.has_blob_key_):
 964       out.putVarInt32(10)
 965       out.putPrefixedString(self.blob_key_)
 966     if (self.has_mime_type_):
 967       out.putVarInt32(18)
 968       out.putPrefixedString(self.mime_type_)
 969     if (self.has_target_app_id_):
 970       out.putVarInt32(26)
 971       out.putPrefixedString(self.target_app_id_)
 972
 973   def TryMerge(self, d):
 974     while d.avail() > 0:
 975       tt = d.getVarInt32()
 976       if tt == 10:
 977         self.set_blob_key(d.getPrefixedString())
 978         continue
 979       if tt == 18:
 980         self.set_mime_type(d.getPrefixedString())
 981         continue
 982       if tt == 26:
 983         self.set_target_app_id(d.getPrefixedString())
 984         continue
 985
 986
 987       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 988       d.skipData(tt)
 989
 990
 991   def __str__(self, prefix="", printElemNumber=0):
 992     res=""
 993     if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_))
 994     if self.has_mime_type_: res+=prefix+("mime_type: %s\n" % self.DebugFormatString(self.mime_type_))
 995     if self.has_target_app_id_: res+=prefix+("target_app_id: %s\n" % self.DebugFormatString(self.target_app_id_))
 996     return res
 997
 998
 999   def _BuildTagLookupTable(sparse, maxtag, default=None):
1000     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1001
1002   kblob_key = 1
1003   kmime_type = 2
1004   ktarget_app_id = 3
1005
1006   _TEXT = _BuildTagLookupTable({
1007     0: "ErrorCode",
1008     1: "blob_key",
1009     2: "mime_type",
1010     3: "target_app_id",
1011   }, 3)
1012
1013   _TYPES = _BuildTagLookupTable({
1014     0: ProtocolBuffer.Encoder.NUMERIC,
1015     1: ProtocolBuffer.Encoder.STRING,
1016     2: ProtocolBuffer.Encoder.STRING,
1017     3: ProtocolBuffer.Encoder.STRING,
1018   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
1019
1020
1021   _STYLE = """"""
1022   _STYLE_CONTENT_TYPE = """"""
1023   _PROTO_DESCRIPTOR_NAME = 'apphosting.CloneBlobRequest'
1024 class CloneBlobResponse(ProtocolBuffer.ProtocolMessage):
1025   has_blob_key_ = 0
1026   blob_key_ = ""
1027
1028   def __init__(self, contents=None):
1029     if contents is not None: self.MergeFromString(contents)
1030
1031   def blob_key(self): return self.blob_key_
1032
1033   def set_blob_key(self, x):
1034     self.has_blob_key_ = 1
1035     self.blob_key_ = x
1036
1037   def clear_blob_key(self):
1038     if self.has_blob_key_:
1039       self.has_blob_key_ = 0
1040       self.blob_key_ = ""
1041
1042   def has_blob_key(self): return self.has_blob_key_
1043
1044
1045   def MergeFrom(self, x):
1046     assert x is not self
1047     if (x.has_blob_key()): self.set_blob_key(x.blob_key())
1048
1049   def Equals(self, x):
1050     if x is self: return 1
1051     if self.has_blob_key_ != x.has_blob_key_: return 0
1052     if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0
1053     return 1
1054
1055   def IsInitialized(self, debug_strs=None):
1056     initialized = 1
1057     if (not self.has_blob_key_):
1058       initialized = 0
1059       if debug_strs is not None:
1060         debug_strs.append('Required field: blob_key not set.')
1061     return initialized
1062
1063   def ByteSize(self):
1064     n = 0
1065     n += self.lengthString(len(self.blob_key_))
1066     return n + 1
1067
1068   def ByteSizePartial(self):
1069     n = 0
1070     if (self.has_blob_key_):
1071       n += 1
1072       n += self.lengthString(len(self.blob_key_))
1073     return n
1074
1075   def Clear(self):
1076     self.clear_blob_key()
1077
1078   def OutputUnchecked(self, out):
1079     out.putVarInt32(10)
1080     out.putPrefixedString(self.blob_key_)
1081
1082   def OutputPartial(self, out):
1083     if (self.has_blob_key_):
1084       out.putVarInt32(10)
1085       out.putPrefixedString(self.blob_key_)
1086
1087   def TryMerge(self, d):
1088     while d.avail() > 0:
1089       tt = d.getVarInt32()
1090       if tt == 10:
1091         self.set_blob_key(d.getPrefixedString())
1092         continue
1093
1094
1095       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1096       d.skipData(tt)
1097
1098
1099   def __str__(self, prefix="", printElemNumber=0):
1100     res=""
1101     if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_))
1102     return res
1103
1104
1105   def _BuildTagLookupTable(sparse, maxtag, default=None):
1106     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1107
1108   kblob_key = 1
1109
1110   _TEXT = _BuildTagLookupTable({
1111     0: "ErrorCode",
1112     1: "blob_key",
1113   }, 1)
1114
1115   _TYPES = _BuildTagLookupTable({
1116     0: ProtocolBuffer.Encoder.NUMERIC,
1117     1: ProtocolBuffer.Encoder.STRING,
1118   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1119
1120
1121   _STYLE = """"""
1122   _STYLE_CONTENT_TYPE = """"""
1123   _PROTO_DESCRIPTOR_NAME = 'apphosting.CloneBlobResponse'
1124 class DecodeBlobKeyRequest(ProtocolBuffer.ProtocolMessage):
1125
1126   def __init__(self, contents=None):
1127     self.blob_key_ = []
1128     if contents is not None: self.MergeFromString(contents)
1129
1130   def blob_key_size(self): return len(self.blob_key_)
1131   def blob_key_list(self): return self.blob_key_
1132
1133   def blob_key(self, i):
1134     return self.blob_key_[i]
1135
1136   def set_blob_key(self, i, x):
1137     self.blob_key_[i] = x
1138
1139   def add_blob_key(self, x):
1140     self.blob_key_.append(x)
1141
1142   def clear_blob_key(self):
1143     self.blob_key_ = []
1144
1145
1146   def MergeFrom(self, x):
1147     assert x is not self
1148     for i in xrange(x.blob_key_size()): self.add_blob_key(x.blob_key(i))
1149
1150   def Equals(self, x):
1151     if x is self: return 1
1152     if len(self.blob_key_) != len(x.blob_key_): return 0
1153     for e1, e2 in zip(self.blob_key_, x.blob_key_):
1154       if e1 != e2: return 0
1155     return 1
1156
1157   def IsInitialized(self, debug_strs=None):
1158     initialized = 1
1159     return initialized
1160
1161   def ByteSize(self):
1162     n = 0
1163     n += 1 * len(self.blob_key_)
1164     for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i]))
1165     return n
1166
1167   def ByteSizePartial(self):
1168     n = 0
1169     n += 1 * len(self.blob_key_)
1170     for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i]))
1171     return n
1172
1173   def Clear(self):
1174     self.clear_blob_key()
1175
1176   def OutputUnchecked(self, out):
1177     for i in xrange(len(self.blob_key_)):
1178       out.putVarInt32(10)
1179       out.putPrefixedString(self.blob_key_[i])
1180
1181   def OutputPartial(self, out):
1182     for i in xrange(len(self.blob_key_)):
1183       out.putVarInt32(10)
1184       out.putPrefixedString(self.blob_key_[i])
1185
1186   def TryMerge(self, d):
1187     while d.avail() > 0:
1188       tt = d.getVarInt32()
1189       if tt == 10:
1190         self.add_blob_key(d.getPrefixedString())
1191         continue
1192
1193
1194       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1195       d.skipData(tt)
1196
1197
1198   def __str__(self, prefix="", printElemNumber=0):
1199     res=""
1200     cnt=0
1201     for e in self.blob_key_:
1202       elm=""
1203       if printElemNumber: elm="(%d)" % cnt
1204       res+=prefix+("blob_key%s: %s\n" % (elm, self.DebugFormatString(e)))
1205       cnt+=1
1206     return res
1207
1208
1209   def _BuildTagLookupTable(sparse, maxtag, default=None):
1210     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1211
1212   kblob_key = 1
1213
1214   _TEXT = _BuildTagLookupTable({
1215     0: "ErrorCode",
1216     1: "blob_key",
1217   }, 1)
1218
1219   _TYPES = _BuildTagLookupTable({
1220     0: ProtocolBuffer.Encoder.NUMERIC,
1221     1: ProtocolBuffer.Encoder.STRING,
1222   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1223
1224
1225   _STYLE = """"""
1226   _STYLE_CONTENT_TYPE = """"""
1227   _PROTO_DESCRIPTOR_NAME = 'apphosting.DecodeBlobKeyRequest'
1228 class DecodeBlobKeyResponse(ProtocolBuffer.ProtocolMessage):
1229
1230   def __init__(self, contents=None):
1231     self.decoded_ = []
1232     if contents is not None: self.MergeFromString(contents)
1233
1234   def decoded_size(self): return len(self.decoded_)
1235   def decoded_list(self): return self.decoded_
1236
1237   def decoded(self, i):
1238     return self.decoded_[i]
1239
1240   def set_decoded(self, i, x):
1241     self.decoded_[i] = x
1242
1243   def add_decoded(self, x):
1244     self.decoded_.append(x)
1245
1246   def clear_decoded(self):
1247     self.decoded_ = []
1248
1249
1250   def MergeFrom(self, x):
1251     assert x is not self
1252     for i in xrange(x.decoded_size()): self.add_decoded(x.decoded(i))
1253
1254   def Equals(self, x):
1255     if x is self: return 1
1256     if len(self.decoded_) != len(x.decoded_): return 0
1257     for e1, e2 in zip(self.decoded_, x.decoded_):
1258       if e1 != e2: return 0
1259     return 1
1260
1261   def IsInitialized(self, debug_strs=None):
1262     initialized = 1
1263     return initialized
1264
1265   def ByteSize(self):
1266     n = 0
1267     n += 1 * len(self.decoded_)
1268     for i in xrange(len(self.decoded_)): n += self.lengthString(len(self.decoded_[i]))
1269     return n
1270
1271   def ByteSizePartial(self):
1272     n = 0
1273     n += 1 * len(self.decoded_)
1274     for i in xrange(len(self.decoded_)): n += self.lengthString(len(self.decoded_[i]))
1275     return n
1276
1277   def Clear(self):
1278     self.clear_decoded()
1279
1280   def OutputUnchecked(self, out):
1281     for i in xrange(len(self.decoded_)):
1282       out.putVarInt32(10)
1283       out.putPrefixedString(self.decoded_[i])
1284
1285   def OutputPartial(self, out):
1286     for i in xrange(len(self.decoded_)):
1287       out.putVarInt32(10)
1288       out.putPrefixedString(self.decoded_[i])
1289
1290   def TryMerge(self, d):
1291     while d.avail() > 0:
1292       tt = d.getVarInt32()
1293       if tt == 10:
1294         self.add_decoded(d.getPrefixedString())
1295         continue
1296
1297
1298       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1299       d.skipData(tt)
1300
1301
1302   def __str__(self, prefix="", printElemNumber=0):
1303     res=""
1304     cnt=0
1305     for e in self.decoded_:
1306       elm=""
1307       if printElemNumber: elm="(%d)" % cnt
1308       res+=prefix+("decoded%s: %s\n" % (elm, self.DebugFormatString(e)))
1309       cnt+=1
1310     return res
1311
1312
1313   def _BuildTagLookupTable(sparse, maxtag, default=None):
1314     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1315
1316   kdecoded = 1
1317
1318   _TEXT = _BuildTagLookupTable({
1319     0: "ErrorCode",
1320     1: "decoded",
1321   }, 1)
1322
1323   _TYPES = _BuildTagLookupTable({
1324     0: ProtocolBuffer.Encoder.NUMERIC,
1325     1: ProtocolBuffer.Encoder.STRING,
1326   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1327
1328
1329   _STYLE = """"""
1330   _STYLE_CONTENT_TYPE = """"""
1331   _PROTO_DESCRIPTOR_NAME = 'apphosting.DecodeBlobKeyResponse'
1332 class CreateEncodedGoogleStorageKeyRequest(ProtocolBuffer.ProtocolMessage):
1333   has_filename_ = 0
1334   filename_ = ""
1335
1336   def __init__(self, contents=None):
1337     if contents is not None: self.MergeFromString(contents)
1338
1339   def filename(self): return self.filename_
1340
1341   def set_filename(self, x):
1342     self.has_filename_ = 1
1343     self.filename_ = x
1344
1345   def clear_filename(self):
1346     if self.has_filename_:
1347       self.has_filename_ = 0
1348       self.filename_ = ""
1349
1350   def has_filename(self): return self.has_filename_
1351
1352
1353   def MergeFrom(self, x):
1354     assert x is not self
1355     if (x.has_filename()): self.set_filename(x.filename())
1356
1357   def Equals(self, x):
1358     if x is self: return 1
1359     if self.has_filename_ != x.has_filename_: return 0
1360     if self.has_filename_ and self.filename_ != x.filename_: return 0
1361     return 1
1362
1363   def IsInitialized(self, debug_strs=None):
1364     initialized = 1
1365     if (not self.has_filename_):
1366       initialized = 0
1367       if debug_strs is not None:
1368         debug_strs.append('Required field: filename not set.')
1369     return initialized
1370
1371   def ByteSize(self):
1372     n = 0
1373     n += self.lengthString(len(self.filename_))
1374     return n + 1
1375
1376   def ByteSizePartial(self):
1377     n = 0
1378     if (self.has_filename_):
1379       n += 1
1380       n += self.lengthString(len(self.filename_))
1381     return n
1382
1383   def Clear(self):
1384     self.clear_filename()
1385
1386   def OutputUnchecked(self, out):
1387     out.putVarInt32(10)
1388     out.putPrefixedString(self.filename_)
1389
1390   def OutputPartial(self, out):
1391     if (self.has_filename_):
1392       out.putVarInt32(10)
1393       out.putPrefixedString(self.filename_)
1394
1395   def TryMerge(self, d):
1396     while d.avail() > 0:
1397       tt = d.getVarInt32()
1398       if tt == 10:
1399         self.set_filename(d.getPrefixedString())
1400         continue
1401
1402
1403       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1404       d.skipData(tt)
1405
1406
1407   def __str__(self, prefix="", printElemNumber=0):
1408     res=""
1409     if self.has_filename_: res+=prefix+("filename: %s\n" % self.DebugFormatString(self.filename_))
1410     return res
1411
1412
1413   def _BuildTagLookupTable(sparse, maxtag, default=None):
1414     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1415
1416   kfilename = 1
1417
1418   _TEXT = _BuildTagLookupTable({
1419     0: "ErrorCode",
1420     1: "filename",
1421   }, 1)
1422
1423   _TYPES = _BuildTagLookupTable({
1424     0: ProtocolBuffer.Encoder.NUMERIC,
1425     1: ProtocolBuffer.Encoder.STRING,
1426   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1427
1428
1429   _STYLE = """"""
1430   _STYLE_CONTENT_TYPE = """"""
1431   _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateEncodedGoogleStorageKeyRequest'
1432 class CreateEncodedGoogleStorageKeyResponse(ProtocolBuffer.ProtocolMessage):
1433   has_blob_key_ = 0
1434   blob_key_ = ""
1435
1436   def __init__(self, contents=None):
1437     if contents is not None: self.MergeFromString(contents)
1438
1439   def blob_key(self): return self.blob_key_
1440
1441   def set_blob_key(self, x):
1442     self.has_blob_key_ = 1
1443     self.blob_key_ = x
1444
1445   def clear_blob_key(self):
1446     if self.has_blob_key_:
1447       self.has_blob_key_ = 0
1448       self.blob_key_ = ""
1449
1450   def has_blob_key(self): return self.has_blob_key_
1451
1452
1453   def MergeFrom(self, x):
1454     assert x is not self
1455     if (x.has_blob_key()): self.set_blob_key(x.blob_key())
1456
1457   def Equals(self, x):
1458     if x is self: return 1
1459     if self.has_blob_key_ != x.has_blob_key_: return 0
1460     if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0
1461     return 1
1462
1463   def IsInitialized(self, debug_strs=None):
1464     initialized = 1
1465     if (not self.has_blob_key_):
1466       initialized = 0
1467       if debug_strs is not None:
1468         debug_strs.append('Required field: blob_key not set.')
1469     return initialized
1470
1471   def ByteSize(self):
1472     n = 0
1473     n += self.lengthString(len(self.blob_key_))
1474     return n + 1
1475
1476   def ByteSizePartial(self):
1477     n = 0
1478     if (self.has_blob_key_):
1479       n += 1
1480       n += self.lengthString(len(self.blob_key_))
1481     return n
1482
1483   def Clear(self):
1484     self.clear_blob_key()
1485
1486   def OutputUnchecked(self, out):
1487     out.putVarInt32(10)
1488     out.putPrefixedString(self.blob_key_)
1489
1490   def OutputPartial(self, out):
1491     if (self.has_blob_key_):
1492       out.putVarInt32(10)
1493       out.putPrefixedString(self.blob_key_)
1494
1495   def TryMerge(self, d):
1496     while d.avail() > 0:
1497       tt = d.getVarInt32()
1498       if tt == 10:
1499         self.set_blob_key(d.getPrefixedString())
1500         continue
1501
1502
1503       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1504       d.skipData(tt)
1505
1506
1507   def __str__(self, prefix="", printElemNumber=0):
1508     res=""
1509     if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_))
1510     return res
1511
1512
1513   def _BuildTagLookupTable(sparse, maxtag, default=None):
1514     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1515
1516   kblob_key = 1
1517
1518   _TEXT = _BuildTagLookupTable({
1519     0: "ErrorCode",
1520     1: "blob_key",
1521   }, 1)
1522
1523   _TYPES = _BuildTagLookupTable({
1524     0: ProtocolBuffer.Encoder.NUMERIC,
1525     1: ProtocolBuffer.Encoder.STRING,
1526   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
1527
1528
1529   _STYLE = """"""
1530   _STYLE_CONTENT_TYPE = """"""
1531   _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateEncodedGoogleStorageKeyResponse'
1532 if _extension_runtime:
1533   pass
1534
1535 __all__ = ['BlobstoreServiceError','CreateUploadURLRequest','CreateUploadURLResponse','DeleteBlobRequest','FetchDataRequest','FetchDataResponse','CloneBlobRequest','CloneBlobResponse','DecodeBlobKeyRequest','DecodeBlobKeyResponse','CreateEncodedGoogleStorageKeyRequest','CreateEncodedGoogleStorageKeyResponse']