#!/usr/bin/env python # # Copyright 2007 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from google.net.proto import ProtocolBuffer import array import dummy_thread as thread __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit unusednames=printElemNumber,debug_strs no-special""" if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'): _extension_runtime = True _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage else: _extension_runtime = False _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage from google.appengine.api.api_base_pb import * import google.appengine.api.api_base_pb class BlobstoreServiceError(ProtocolBuffer.ProtocolMessage): OK = 0 INTERNAL_ERROR = 1 URL_TOO_LONG = 2 PERMISSION_DENIED = 3 BLOB_NOT_FOUND = 4 DATA_INDEX_OUT_OF_RANGE = 5 BLOB_FETCH_SIZE_TOO_LARGE = 6 ARGUMENT_OUT_OF_RANGE = 8 INVALID_BLOB_KEY = 9 _ErrorCode_NAMES = { 0: "OK", 1: "INTERNAL_ERROR", 2: "URL_TOO_LONG", 3: "PERMISSION_DENIED", 4: "BLOB_NOT_FOUND", 5: "DATA_INDEX_OUT_OF_RANGE", 6: "BLOB_FETCH_SIZE_TOO_LARGE", 8: "ARGUMENT_OUT_OF_RANGE", 9: "INVALID_BLOB_KEY", } def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "") ErrorCode_Name = classmethod(ErrorCode_Name) def __init__(self, contents=None): pass if contents is not None: self.MergeFromString(contents) def MergeFrom(self, x): assert x is not self def Equals(self, x): if x is self: return 1 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 return n def ByteSizePartial(self): n = 0 return n def Clear(self): pass def OutputUnchecked(self, out): pass def OutputPartial(self, out): pass def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", }, 0) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, }, 0, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.BlobstoreServiceError' class CreateUploadURLRequest(ProtocolBuffer.ProtocolMessage): has_success_path_ = 0 success_path_ = "" has_max_upload_size_bytes_ = 0 max_upload_size_bytes_ = 0 has_max_upload_size_per_blob_bytes_ = 0 max_upload_size_per_blob_bytes_ = 0 has_gs_bucket_name_ = 0 gs_bucket_name_ = "" has_url_expiry_time_seconds_ = 0 url_expiry_time_seconds_ = 0 def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def success_path(self): return self.success_path_ def set_success_path(self, x): self.has_success_path_ = 1 self.success_path_ = x def clear_success_path(self): if self.has_success_path_: self.has_success_path_ = 0 self.success_path_ = "" def has_success_path(self): return self.has_success_path_ def max_upload_size_bytes(self): return self.max_upload_size_bytes_ def set_max_upload_size_bytes(self, x): self.has_max_upload_size_bytes_ = 1 self.max_upload_size_bytes_ = x def clear_max_upload_size_bytes(self): if self.has_max_upload_size_bytes_: self.has_max_upload_size_bytes_ = 0 self.max_upload_size_bytes_ = 0 def has_max_upload_size_bytes(self): return self.has_max_upload_size_bytes_ def max_upload_size_per_blob_bytes(self): return self.max_upload_size_per_blob_bytes_ def set_max_upload_size_per_blob_bytes(self, x): self.has_max_upload_size_per_blob_bytes_ = 1 self.max_upload_size_per_blob_bytes_ = x def clear_max_upload_size_per_blob_bytes(self): if self.has_max_upload_size_per_blob_bytes_: self.has_max_upload_size_per_blob_bytes_ = 0 self.max_upload_size_per_blob_bytes_ = 0 def has_max_upload_size_per_blob_bytes(self): return self.has_max_upload_size_per_blob_bytes_ def gs_bucket_name(self): return self.gs_bucket_name_ def set_gs_bucket_name(self, x): self.has_gs_bucket_name_ = 1 self.gs_bucket_name_ = x def clear_gs_bucket_name(self): if self.has_gs_bucket_name_: self.has_gs_bucket_name_ = 0 self.gs_bucket_name_ = "" def has_gs_bucket_name(self): return self.has_gs_bucket_name_ def url_expiry_time_seconds(self): return self.url_expiry_time_seconds_ def set_url_expiry_time_seconds(self, x): self.has_url_expiry_time_seconds_ = 1 self.url_expiry_time_seconds_ = x def clear_url_expiry_time_seconds(self): if self.has_url_expiry_time_seconds_: self.has_url_expiry_time_seconds_ = 0 self.url_expiry_time_seconds_ = 0 def has_url_expiry_time_seconds(self): return self.has_url_expiry_time_seconds_ def MergeFrom(self, x): assert x is not self if (x.has_success_path()): self.set_success_path(x.success_path()) if (x.has_max_upload_size_bytes()): self.set_max_upload_size_bytes(x.max_upload_size_bytes()) if (x.has_max_upload_size_per_blob_bytes()): self.set_max_upload_size_per_blob_bytes(x.max_upload_size_per_blob_bytes()) if (x.has_gs_bucket_name()): self.set_gs_bucket_name(x.gs_bucket_name()) if (x.has_url_expiry_time_seconds()): self.set_url_expiry_time_seconds(x.url_expiry_time_seconds()) def Equals(self, x): if x is self: return 1 if self.has_success_path_ != x.has_success_path_: return 0 if self.has_success_path_ and self.success_path_ != x.success_path_: return 0 if self.has_max_upload_size_bytes_ != x.has_max_upload_size_bytes_: return 0 if self.has_max_upload_size_bytes_ and self.max_upload_size_bytes_ != x.max_upload_size_bytes_: return 0 if self.has_max_upload_size_per_blob_bytes_ != x.has_max_upload_size_per_blob_bytes_: return 0 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 if self.has_gs_bucket_name_ != x.has_gs_bucket_name_: return 0 if self.has_gs_bucket_name_ and self.gs_bucket_name_ != x.gs_bucket_name_: return 0 if self.has_url_expiry_time_seconds_ != x.has_url_expiry_time_seconds_: return 0 if self.has_url_expiry_time_seconds_ and self.url_expiry_time_seconds_ != x.url_expiry_time_seconds_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_success_path_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: success_path not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.success_path_)) if (self.has_max_upload_size_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_bytes_) if (self.has_max_upload_size_per_blob_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_per_blob_bytes_) if (self.has_gs_bucket_name_): n += 1 + self.lengthString(len(self.gs_bucket_name_)) if (self.has_url_expiry_time_seconds_): n += 1 + self.lengthVarInt64(self.url_expiry_time_seconds_) return n + 1 def ByteSizePartial(self): n = 0 if (self.has_success_path_): n += 1 n += self.lengthString(len(self.success_path_)) if (self.has_max_upload_size_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_bytes_) if (self.has_max_upload_size_per_blob_bytes_): n += 1 + self.lengthVarInt64(self.max_upload_size_per_blob_bytes_) if (self.has_gs_bucket_name_): n += 1 + self.lengthString(len(self.gs_bucket_name_)) if (self.has_url_expiry_time_seconds_): n += 1 + self.lengthVarInt64(self.url_expiry_time_seconds_) return n def Clear(self): self.clear_success_path() self.clear_max_upload_size_bytes() self.clear_max_upload_size_per_blob_bytes() self.clear_gs_bucket_name() self.clear_url_expiry_time_seconds() def OutputUnchecked(self, out): out.putVarInt32(10) out.putPrefixedString(self.success_path_) if (self.has_max_upload_size_bytes_): out.putVarInt32(16) out.putVarInt64(self.max_upload_size_bytes_) if (self.has_max_upload_size_per_blob_bytes_): out.putVarInt32(24) out.putVarInt64(self.max_upload_size_per_blob_bytes_) if (self.has_gs_bucket_name_): out.putVarInt32(34) out.putPrefixedString(self.gs_bucket_name_) if (self.has_url_expiry_time_seconds_): out.putVarInt32(40) out.putVarInt32(self.url_expiry_time_seconds_) def OutputPartial(self, out): if (self.has_success_path_): out.putVarInt32(10) out.putPrefixedString(self.success_path_) if (self.has_max_upload_size_bytes_): out.putVarInt32(16) out.putVarInt64(self.max_upload_size_bytes_) if (self.has_max_upload_size_per_blob_bytes_): out.putVarInt32(24) out.putVarInt64(self.max_upload_size_per_blob_bytes_) if (self.has_gs_bucket_name_): out.putVarInt32(34) out.putPrefixedString(self.gs_bucket_name_) if (self.has_url_expiry_time_seconds_): out.putVarInt32(40) out.putVarInt32(self.url_expiry_time_seconds_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_success_path(d.getPrefixedString()) continue if tt == 16: self.set_max_upload_size_bytes(d.getVarInt64()) continue if tt == 24: self.set_max_upload_size_per_blob_bytes(d.getVarInt64()) continue if tt == 34: self.set_gs_bucket_name(d.getPrefixedString()) continue if tt == 40: self.set_url_expiry_time_seconds(d.getVarInt32()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_success_path_: res+=prefix+("success_path: %s\n" % self.DebugFormatString(self.success_path_)) if self.has_max_upload_size_bytes_: res+=prefix+("max_upload_size_bytes: %s\n" % self.DebugFormatInt64(self.max_upload_size_bytes_)) 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_)) if self.has_gs_bucket_name_: res+=prefix+("gs_bucket_name: %s\n" % self.DebugFormatString(self.gs_bucket_name_)) if self.has_url_expiry_time_seconds_: res+=prefix+("url_expiry_time_seconds: %s\n" % self.DebugFormatInt32(self.url_expiry_time_seconds_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) ksuccess_path = 1 kmax_upload_size_bytes = 2 kmax_upload_size_per_blob_bytes = 3 kgs_bucket_name = 4 kurl_expiry_time_seconds = 5 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "success_path", 2: "max_upload_size_bytes", 3: "max_upload_size_per_blob_bytes", 4: "gs_bucket_name", 5: "url_expiry_time_seconds", }, 5) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, 2: ProtocolBuffer.Encoder.NUMERIC, 3: ProtocolBuffer.Encoder.NUMERIC, 4: ProtocolBuffer.Encoder.STRING, 5: ProtocolBuffer.Encoder.NUMERIC, }, 5, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateUploadURLRequest' class CreateUploadURLResponse(ProtocolBuffer.ProtocolMessage): has_url_ = 0 url_ = "" def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def url(self): return self.url_ def set_url(self, x): self.has_url_ = 1 self.url_ = x def clear_url(self): if self.has_url_: self.has_url_ = 0 self.url_ = "" def has_url(self): return self.has_url_ def MergeFrom(self, x): assert x is not self if (x.has_url()): self.set_url(x.url()) def Equals(self, x): if x is self: return 1 if self.has_url_ != x.has_url_: return 0 if self.has_url_ and self.url_ != x.url_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_url_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: url not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.url_)) return n + 1 def ByteSizePartial(self): n = 0 if (self.has_url_): n += 1 n += self.lengthString(len(self.url_)) return n def Clear(self): self.clear_url() def OutputUnchecked(self, out): out.putVarInt32(10) out.putPrefixedString(self.url_) def OutputPartial(self, out): if (self.has_url_): out.putVarInt32(10) out.putPrefixedString(self.url_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_url(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_url_: res+=prefix+("url: %s\n" % self.DebugFormatString(self.url_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kurl = 1 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "url", }, 1) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, }, 1, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateUploadURLResponse' class DeleteBlobRequest(ProtocolBuffer.ProtocolMessage): has_token_ = 0 token_ = "" def __init__(self, contents=None): self.blob_key_ = [] if contents is not None: self.MergeFromString(contents) def blob_key_size(self): return len(self.blob_key_) def blob_key_list(self): return self.blob_key_ def blob_key(self, i): return self.blob_key_[i] def set_blob_key(self, i, x): self.blob_key_[i] = x def add_blob_key(self, x): self.blob_key_.append(x) def clear_blob_key(self): self.blob_key_ = [] def token(self): return self.token_ def set_token(self, x): self.has_token_ = 1 self.token_ = x def clear_token(self): if self.has_token_: self.has_token_ = 0 self.token_ = "" def has_token(self): return self.has_token_ def MergeFrom(self, x): assert x is not self for i in xrange(x.blob_key_size()): self.add_blob_key(x.blob_key(i)) if (x.has_token()): self.set_token(x.token()) def Equals(self, x): if x is self: return 1 if len(self.blob_key_) != len(x.blob_key_): return 0 for e1, e2 in zip(self.blob_key_, x.blob_key_): if e1 != e2: return 0 if self.has_token_ != x.has_token_: return 0 if self.has_token_ and self.token_ != x.token_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 n += 1 * len(self.blob_key_) for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i])) if (self.has_token_): n += 1 + self.lengthString(len(self.token_)) return n def ByteSizePartial(self): n = 0 n += 1 * len(self.blob_key_) for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i])) if (self.has_token_): n += 1 + self.lengthString(len(self.token_)) return n def Clear(self): self.clear_blob_key() self.clear_token() def OutputUnchecked(self, out): for i in xrange(len(self.blob_key_)): out.putVarInt32(10) out.putPrefixedString(self.blob_key_[i]) if (self.has_token_): out.putVarInt32(18) out.putPrefixedString(self.token_) def OutputPartial(self, out): for i in xrange(len(self.blob_key_)): out.putVarInt32(10) out.putPrefixedString(self.blob_key_[i]) if (self.has_token_): out.putVarInt32(18) out.putPrefixedString(self.token_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.add_blob_key(d.getPrefixedString()) continue if tt == 18: self.set_token(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" cnt=0 for e in self.blob_key_: elm="" if printElemNumber: elm="(%d)" % cnt res+=prefix+("blob_key%s: %s\n" % (elm, self.DebugFormatString(e))) cnt+=1 if self.has_token_: res+=prefix+("token: %s\n" % self.DebugFormatString(self.token_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kblob_key = 1 ktoken = 2 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "blob_key", 2: "token", }, 2) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, 2: ProtocolBuffer.Encoder.STRING, }, 2, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.DeleteBlobRequest' class FetchDataRequest(ProtocolBuffer.ProtocolMessage): has_blob_key_ = 0 blob_key_ = "" has_start_index_ = 0 start_index_ = 0 has_end_index_ = 0 end_index_ = 0 def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def blob_key(self): return self.blob_key_ def set_blob_key(self, x): self.has_blob_key_ = 1 self.blob_key_ = x def clear_blob_key(self): if self.has_blob_key_: self.has_blob_key_ = 0 self.blob_key_ = "" def has_blob_key(self): return self.has_blob_key_ def start_index(self): return self.start_index_ def set_start_index(self, x): self.has_start_index_ = 1 self.start_index_ = x def clear_start_index(self): if self.has_start_index_: self.has_start_index_ = 0 self.start_index_ = 0 def has_start_index(self): return self.has_start_index_ def end_index(self): return self.end_index_ def set_end_index(self, x): self.has_end_index_ = 1 self.end_index_ = x def clear_end_index(self): if self.has_end_index_: self.has_end_index_ = 0 self.end_index_ = 0 def has_end_index(self): return self.has_end_index_ def MergeFrom(self, x): assert x is not self if (x.has_blob_key()): self.set_blob_key(x.blob_key()) if (x.has_start_index()): self.set_start_index(x.start_index()) if (x.has_end_index()): self.set_end_index(x.end_index()) def Equals(self, x): if x is self: return 1 if self.has_blob_key_ != x.has_blob_key_: return 0 if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0 if self.has_start_index_ != x.has_start_index_: return 0 if self.has_start_index_ and self.start_index_ != x.start_index_: return 0 if self.has_end_index_ != x.has_end_index_: return 0 if self.has_end_index_ and self.end_index_ != x.end_index_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_blob_key_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: blob_key not set.') if (not self.has_start_index_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: start_index not set.') if (not self.has_end_index_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: end_index not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.blob_key_)) n += self.lengthVarInt64(self.start_index_) n += self.lengthVarInt64(self.end_index_) return n + 3 def ByteSizePartial(self): n = 0 if (self.has_blob_key_): n += 1 n += self.lengthString(len(self.blob_key_)) if (self.has_start_index_): n += 1 n += self.lengthVarInt64(self.start_index_) if (self.has_end_index_): n += 1 n += self.lengthVarInt64(self.end_index_) return n def Clear(self): self.clear_blob_key() self.clear_start_index() self.clear_end_index() def OutputUnchecked(self, out): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) out.putVarInt32(16) out.putVarInt64(self.start_index_) out.putVarInt32(24) out.putVarInt64(self.end_index_) def OutputPartial(self, out): if (self.has_blob_key_): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) if (self.has_start_index_): out.putVarInt32(16) out.putVarInt64(self.start_index_) if (self.has_end_index_): out.putVarInt32(24) out.putVarInt64(self.end_index_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_blob_key(d.getPrefixedString()) continue if tt == 16: self.set_start_index(d.getVarInt64()) continue if tt == 24: self.set_end_index(d.getVarInt64()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_)) if self.has_start_index_: res+=prefix+("start_index: %s\n" % self.DebugFormatInt64(self.start_index_)) if self.has_end_index_: res+=prefix+("end_index: %s\n" % self.DebugFormatInt64(self.end_index_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kblob_key = 1 kstart_index = 2 kend_index = 3 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "blob_key", 2: "start_index", 3: "end_index", }, 3) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, 2: ProtocolBuffer.Encoder.NUMERIC, 3: ProtocolBuffer.Encoder.NUMERIC, }, 3, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.FetchDataRequest' class FetchDataResponse(ProtocolBuffer.ProtocolMessage): has_data_ = 0 data_ = "" def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def data(self): return self.data_ def set_data(self, x): self.has_data_ = 1 self.data_ = x def clear_data(self): if self.has_data_: self.has_data_ = 0 self.data_ = "" def has_data(self): return self.has_data_ def MergeFrom(self, x): assert x is not self if (x.has_data()): self.set_data(x.data()) def Equals(self, x): if x is self: return 1 if self.has_data_ != x.has_data_: return 0 if self.has_data_ and self.data_ != x.data_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_data_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: data not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.data_)) return n + 2 def ByteSizePartial(self): n = 0 if (self.has_data_): n += 2 n += self.lengthString(len(self.data_)) return n def Clear(self): self.clear_data() def OutputUnchecked(self, out): out.putVarInt32(8002) out.putPrefixedString(self.data_) def OutputPartial(self, out): if (self.has_data_): out.putVarInt32(8002) out.putPrefixedString(self.data_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 8002: self.set_data(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_data_: res+=prefix+("data: %s\n" % self.DebugFormatString(self.data_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kdata = 1000 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1000: "data", }, 1000) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1000: ProtocolBuffer.Encoder.STRING, }, 1000, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.FetchDataResponse' class CloneBlobRequest(ProtocolBuffer.ProtocolMessage): has_blob_key_ = 0 blob_key_ = "" has_mime_type_ = 0 mime_type_ = "" has_target_app_id_ = 0 target_app_id_ = "" def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def blob_key(self): return self.blob_key_ def set_blob_key(self, x): self.has_blob_key_ = 1 self.blob_key_ = x def clear_blob_key(self): if self.has_blob_key_: self.has_blob_key_ = 0 self.blob_key_ = "" def has_blob_key(self): return self.has_blob_key_ def mime_type(self): return self.mime_type_ def set_mime_type(self, x): self.has_mime_type_ = 1 self.mime_type_ = x def clear_mime_type(self): if self.has_mime_type_: self.has_mime_type_ = 0 self.mime_type_ = "" def has_mime_type(self): return self.has_mime_type_ def target_app_id(self): return self.target_app_id_ def set_target_app_id(self, x): self.has_target_app_id_ = 1 self.target_app_id_ = x def clear_target_app_id(self): if self.has_target_app_id_: self.has_target_app_id_ = 0 self.target_app_id_ = "" def has_target_app_id(self): return self.has_target_app_id_ def MergeFrom(self, x): assert x is not self if (x.has_blob_key()): self.set_blob_key(x.blob_key()) if (x.has_mime_type()): self.set_mime_type(x.mime_type()) if (x.has_target_app_id()): self.set_target_app_id(x.target_app_id()) def Equals(self, x): if x is self: return 1 if self.has_blob_key_ != x.has_blob_key_: return 0 if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0 if self.has_mime_type_ != x.has_mime_type_: return 0 if self.has_mime_type_ and self.mime_type_ != x.mime_type_: return 0 if self.has_target_app_id_ != x.has_target_app_id_: return 0 if self.has_target_app_id_ and self.target_app_id_ != x.target_app_id_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_blob_key_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: blob_key not set.') if (not self.has_mime_type_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: mime_type not set.') if (not self.has_target_app_id_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: target_app_id not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.blob_key_)) n += self.lengthString(len(self.mime_type_)) n += self.lengthString(len(self.target_app_id_)) return n + 3 def ByteSizePartial(self): n = 0 if (self.has_blob_key_): n += 1 n += self.lengthString(len(self.blob_key_)) if (self.has_mime_type_): n += 1 n += self.lengthString(len(self.mime_type_)) if (self.has_target_app_id_): n += 1 n += self.lengthString(len(self.target_app_id_)) return n def Clear(self): self.clear_blob_key() self.clear_mime_type() self.clear_target_app_id() def OutputUnchecked(self, out): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) out.putVarInt32(18) out.putPrefixedString(self.mime_type_) out.putVarInt32(26) out.putPrefixedString(self.target_app_id_) def OutputPartial(self, out): if (self.has_blob_key_): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) if (self.has_mime_type_): out.putVarInt32(18) out.putPrefixedString(self.mime_type_) if (self.has_target_app_id_): out.putVarInt32(26) out.putPrefixedString(self.target_app_id_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_blob_key(d.getPrefixedString()) continue if tt == 18: self.set_mime_type(d.getPrefixedString()) continue if tt == 26: self.set_target_app_id(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_)) if self.has_mime_type_: res+=prefix+("mime_type: %s\n" % self.DebugFormatString(self.mime_type_)) if self.has_target_app_id_: res+=prefix+("target_app_id: %s\n" % self.DebugFormatString(self.target_app_id_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kblob_key = 1 kmime_type = 2 ktarget_app_id = 3 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "blob_key", 2: "mime_type", 3: "target_app_id", }, 3) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, 2: ProtocolBuffer.Encoder.STRING, 3: ProtocolBuffer.Encoder.STRING, }, 3, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.CloneBlobRequest' class CloneBlobResponse(ProtocolBuffer.ProtocolMessage): has_blob_key_ = 0 blob_key_ = "" def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def blob_key(self): return self.blob_key_ def set_blob_key(self, x): self.has_blob_key_ = 1 self.blob_key_ = x def clear_blob_key(self): if self.has_blob_key_: self.has_blob_key_ = 0 self.blob_key_ = "" def has_blob_key(self): return self.has_blob_key_ def MergeFrom(self, x): assert x is not self if (x.has_blob_key()): self.set_blob_key(x.blob_key()) def Equals(self, x): if x is self: return 1 if self.has_blob_key_ != x.has_blob_key_: return 0 if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_blob_key_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: blob_key not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.blob_key_)) return n + 1 def ByteSizePartial(self): n = 0 if (self.has_blob_key_): n += 1 n += self.lengthString(len(self.blob_key_)) return n def Clear(self): self.clear_blob_key() def OutputUnchecked(self, out): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) def OutputPartial(self, out): if (self.has_blob_key_): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_blob_key(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kblob_key = 1 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "blob_key", }, 1) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, }, 1, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.CloneBlobResponse' class DecodeBlobKeyRequest(ProtocolBuffer.ProtocolMessage): def __init__(self, contents=None): self.blob_key_ = [] if contents is not None: self.MergeFromString(contents) def blob_key_size(self): return len(self.blob_key_) def blob_key_list(self): return self.blob_key_ def blob_key(self, i): return self.blob_key_[i] def set_blob_key(self, i, x): self.blob_key_[i] = x def add_blob_key(self, x): self.blob_key_.append(x) def clear_blob_key(self): self.blob_key_ = [] def MergeFrom(self, x): assert x is not self for i in xrange(x.blob_key_size()): self.add_blob_key(x.blob_key(i)) def Equals(self, x): if x is self: return 1 if len(self.blob_key_) != len(x.blob_key_): return 0 for e1, e2 in zip(self.blob_key_, x.blob_key_): if e1 != e2: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 n += 1 * len(self.blob_key_) for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i])) return n def ByteSizePartial(self): n = 0 n += 1 * len(self.blob_key_) for i in xrange(len(self.blob_key_)): n += self.lengthString(len(self.blob_key_[i])) return n def Clear(self): self.clear_blob_key() def OutputUnchecked(self, out): for i in xrange(len(self.blob_key_)): out.putVarInt32(10) out.putPrefixedString(self.blob_key_[i]) def OutputPartial(self, out): for i in xrange(len(self.blob_key_)): out.putVarInt32(10) out.putPrefixedString(self.blob_key_[i]) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.add_blob_key(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" cnt=0 for e in self.blob_key_: elm="" if printElemNumber: elm="(%d)" % cnt res+=prefix+("blob_key%s: %s\n" % (elm, self.DebugFormatString(e))) cnt+=1 return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kblob_key = 1 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "blob_key", }, 1) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, }, 1, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.DecodeBlobKeyRequest' class DecodeBlobKeyResponse(ProtocolBuffer.ProtocolMessage): def __init__(self, contents=None): self.decoded_ = [] if contents is not None: self.MergeFromString(contents) def decoded_size(self): return len(self.decoded_) def decoded_list(self): return self.decoded_ def decoded(self, i): return self.decoded_[i] def set_decoded(self, i, x): self.decoded_[i] = x def add_decoded(self, x): self.decoded_.append(x) def clear_decoded(self): self.decoded_ = [] def MergeFrom(self, x): assert x is not self for i in xrange(x.decoded_size()): self.add_decoded(x.decoded(i)) def Equals(self, x): if x is self: return 1 if len(self.decoded_) != len(x.decoded_): return 0 for e1, e2 in zip(self.decoded_, x.decoded_): if e1 != e2: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 n += 1 * len(self.decoded_) for i in xrange(len(self.decoded_)): n += self.lengthString(len(self.decoded_[i])) return n def ByteSizePartial(self): n = 0 n += 1 * len(self.decoded_) for i in xrange(len(self.decoded_)): n += self.lengthString(len(self.decoded_[i])) return n def Clear(self): self.clear_decoded() def OutputUnchecked(self, out): for i in xrange(len(self.decoded_)): out.putVarInt32(10) out.putPrefixedString(self.decoded_[i]) def OutputPartial(self, out): for i in xrange(len(self.decoded_)): out.putVarInt32(10) out.putPrefixedString(self.decoded_[i]) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.add_decoded(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" cnt=0 for e in self.decoded_: elm="" if printElemNumber: elm="(%d)" % cnt res+=prefix+("decoded%s: %s\n" % (elm, self.DebugFormatString(e))) cnt+=1 return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kdecoded = 1 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "decoded", }, 1) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, }, 1, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.DecodeBlobKeyResponse' class CreateEncodedGoogleStorageKeyRequest(ProtocolBuffer.ProtocolMessage): has_filename_ = 0 filename_ = "" def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def filename(self): return self.filename_ def set_filename(self, x): self.has_filename_ = 1 self.filename_ = x def clear_filename(self): if self.has_filename_: self.has_filename_ = 0 self.filename_ = "" def has_filename(self): return self.has_filename_ def MergeFrom(self, x): assert x is not self if (x.has_filename()): self.set_filename(x.filename()) def Equals(self, x): if x is self: return 1 if self.has_filename_ != x.has_filename_: return 0 if self.has_filename_ and self.filename_ != x.filename_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_filename_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: filename not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.filename_)) return n + 1 def ByteSizePartial(self): n = 0 if (self.has_filename_): n += 1 n += self.lengthString(len(self.filename_)) return n def Clear(self): self.clear_filename() def OutputUnchecked(self, out): out.putVarInt32(10) out.putPrefixedString(self.filename_) def OutputPartial(self, out): if (self.has_filename_): out.putVarInt32(10) out.putPrefixedString(self.filename_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_filename(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_filename_: res+=prefix+("filename: %s\n" % self.DebugFormatString(self.filename_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kfilename = 1 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "filename", }, 1) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, }, 1, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateEncodedGoogleStorageKeyRequest' class CreateEncodedGoogleStorageKeyResponse(ProtocolBuffer.ProtocolMessage): has_blob_key_ = 0 blob_key_ = "" def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def blob_key(self): return self.blob_key_ def set_blob_key(self, x): self.has_blob_key_ = 1 self.blob_key_ = x def clear_blob_key(self): if self.has_blob_key_: self.has_blob_key_ = 0 self.blob_key_ = "" def has_blob_key(self): return self.has_blob_key_ def MergeFrom(self, x): assert x is not self if (x.has_blob_key()): self.set_blob_key(x.blob_key()) def Equals(self, x): if x is self: return 1 if self.has_blob_key_ != x.has_blob_key_: return 0 if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (not self.has_blob_key_): initialized = 0 if debug_strs is not None: debug_strs.append('Required field: blob_key not set.') return initialized def ByteSize(self): n = 0 n += self.lengthString(len(self.blob_key_)) return n + 1 def ByteSizePartial(self): n = 0 if (self.has_blob_key_): n += 1 n += self.lengthString(len(self.blob_key_)) return n def Clear(self): self.clear_blob_key() def OutputUnchecked(self, out): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) def OutputPartial(self, out): if (self.has_blob_key_): out.putVarInt32(10) out.putPrefixedString(self.blob_key_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_blob_key(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kblob_key = 1 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "blob_key", }, 1) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, }, 1, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.CreateEncodedGoogleStorageKeyResponse' if _extension_runtime: pass __all__ = ['BlobstoreServiceError','CreateUploadURLRequest','CreateUploadURLResponse','DeleteBlobRequest','FetchDataRequest','FetchDataResponse','CloneBlobRequest','CloneBlobResponse','DecodeBlobKeyRequest','DecodeBlobKeyResponse','CreateEncodedGoogleStorageKeyRequest','CreateEncodedGoogleStorageKeyResponse']