python/google/appengine/api/images/images_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 class ImagesServiceError(ProtocolBuffer.ProtocolMessage):
  35
  36
  37   UNSPECIFIED_ERROR =    1
  38   BAD_TRANSFORM_DATA =    2
  39   NOT_IMAGE    =    3
  40   BAD_IMAGE_DATA =    4
  41   IMAGE_TOO_LARGE =    5
  42   INVALID_BLOB_KEY =    6
  43   ACCESS_DENIED =    7
  44   OBJECT_NOT_FOUND =    8
  45
  46   _ErrorCode_NAMES = {
  47     1: "UNSPECIFIED_ERROR",
  48     2: "BAD_TRANSFORM_DATA",
  49     3: "NOT_IMAGE",
  50     4: "BAD_IMAGE_DATA",
  51     5: "IMAGE_TOO_LARGE",
  52     6: "INVALID_BLOB_KEY",
  53     7: "ACCESS_DENIED",
  54     8: "OBJECT_NOT_FOUND",
  55   }
  56
  57   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  58   ErrorCode_Name = classmethod(ErrorCode_Name)
  59
  60
  61   def __init__(self, contents=None):
  62     pass
  63     if contents is not None: self.MergeFromString(contents)
  64
  65
  66   def MergeFrom(self, x):
  67     assert x is not self
  68
  69   def Equals(self, x):
  70     if x is self: return 1
  71     return 1
  72
  73   def IsInitialized(self, debug_strs=None):
  74     initialized = 1
  75     return initialized
  76
  77   def ByteSize(self):
  78     n = 0
  79     return n
  80
  81   def ByteSizePartial(self):
  82     n = 0
  83     return n
  84
  85   def Clear(self):
  86     pass
  87
  88   def OutputUnchecked(self, out):
  89     pass
  90
  91   def OutputPartial(self, out):
  92     pass
  93
  94   def TryMerge(self, d):
  95     while d.avail() > 0:
  96       tt = d.getVarInt32()
  97
  98
  99       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 100       d.skipData(tt)
 101
 102
 103   def __str__(self, prefix="", printElemNumber=0):
 104     res=""
 105     return res
 106
 107
 108   def _BuildTagLookupTable(sparse, maxtag, default=None):
 109     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 110
 111
 112   _TEXT = _BuildTagLookupTable({
 113     0: "ErrorCode",
 114   }, 0)
 115
 116   _TYPES = _BuildTagLookupTable({
 117     0: ProtocolBuffer.Encoder.NUMERIC,
 118   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
 119
 120
 121   _STYLE = """"""
 122   _STYLE_CONTENT_TYPE = """"""
 123   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesServiceError'
 124 class ImagesServiceTransform(ProtocolBuffer.ProtocolMessage):
 125
 126
 127   RESIZE       =    1
 128   ROTATE       =    2
 129   HORIZONTAL_FLIP =    3
 130   VERTICAL_FLIP =    4
 131   CROP         =    5
 132   IM_FEELING_LUCKY =    6
 133
 134   _Type_NAMES = {
 135     1: "RESIZE",
 136     2: "ROTATE",
 137     3: "HORIZONTAL_FLIP",
 138     4: "VERTICAL_FLIP",
 139     5: "CROP",
 140     6: "IM_FEELING_LUCKY",
 141   }
 142
 143   def Type_Name(cls, x): return cls._Type_NAMES.get(x, "")
 144   Type_Name = classmethod(Type_Name)
 145
 146
 147   def __init__(self, contents=None):
 148     pass
 149     if contents is not None: self.MergeFromString(contents)
 150
 151
 152   def MergeFrom(self, x):
 153     assert x is not self
 154
 155   def Equals(self, x):
 156     if x is self: return 1
 157     return 1
 158
 159   def IsInitialized(self, debug_strs=None):
 160     initialized = 1
 161     return initialized
 162
 163   def ByteSize(self):
 164     n = 0
 165     return n
 166
 167   def ByteSizePartial(self):
 168     n = 0
 169     return n
 170
 171   def Clear(self):
 172     pass
 173
 174   def OutputUnchecked(self, out):
 175     pass
 176
 177   def OutputPartial(self, out):
 178     pass
 179
 180   def TryMerge(self, d):
 181     while d.avail() > 0:
 182       tt = d.getVarInt32()
 183
 184
 185       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 186       d.skipData(tt)
 187
 188
 189   def __str__(self, prefix="", printElemNumber=0):
 190     res=""
 191     return res
 192
 193
 194   def _BuildTagLookupTable(sparse, maxtag, default=None):
 195     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 196
 197
 198   _TEXT = _BuildTagLookupTable({
 199     0: "ErrorCode",
 200   }, 0)
 201
 202   _TYPES = _BuildTagLookupTable({
 203     0: ProtocolBuffer.Encoder.NUMERIC,
 204   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
 205
 206
 207   _STYLE = """"""
 208   _STYLE_CONTENT_TYPE = """"""
 209   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesServiceTransform'
 210 class Transform(ProtocolBuffer.ProtocolMessage):
 211   has_width_ = 0
 212   width_ = 0
 213   has_height_ = 0
 214   height_ = 0
 215   has_crop_to_fit_ = 0
 216   crop_to_fit_ = 0
 217   has_crop_offset_x_ = 0
 218   crop_offset_x_ = 0.5
 219   has_crop_offset_y_ = 0
 220   crop_offset_y_ = 0.5
 221   has_rotate_ = 0
 222   rotate_ = 0
 223   has_horizontal_flip_ = 0
 224   horizontal_flip_ = 0
 225   has_vertical_flip_ = 0
 226   vertical_flip_ = 0
 227   has_crop_left_x_ = 0
 228   crop_left_x_ = 0.0
 229   has_crop_top_y_ = 0
 230   crop_top_y_ = 0.0
 231   has_crop_right_x_ = 0
 232   crop_right_x_ = 1.0
 233   has_crop_bottom_y_ = 0
 234   crop_bottom_y_ = 1.0
 235   has_autolevels_ = 0
 236   autolevels_ = 0
 237   has_allow_stretch_ = 0
 238   allow_stretch_ = 0
 239
 240   def __init__(self, contents=None):
 241     if contents is not None: self.MergeFromString(contents)
 242
 243   def width(self): return self.width_
 244
 245   def set_width(self, x):
 246     self.has_width_ = 1
 247     self.width_ = x
 248
 249   def clear_width(self):
 250     if self.has_width_:
 251       self.has_width_ = 0
 252       self.width_ = 0
 253
 254   def has_width(self): return self.has_width_
 255
 256   def height(self): return self.height_
 257
 258   def set_height(self, x):
 259     self.has_height_ = 1
 260     self.height_ = x
 261
 262   def clear_height(self):
 263     if self.has_height_:
 264       self.has_height_ = 0
 265       self.height_ = 0
 266
 267   def has_height(self): return self.has_height_
 268
 269   def crop_to_fit(self): return self.crop_to_fit_
 270
 271   def set_crop_to_fit(self, x):
 272     self.has_crop_to_fit_ = 1
 273     self.crop_to_fit_ = x
 274
 275   def clear_crop_to_fit(self):
 276     if self.has_crop_to_fit_:
 277       self.has_crop_to_fit_ = 0
 278       self.crop_to_fit_ = 0
 279
 280   def has_crop_to_fit(self): return self.has_crop_to_fit_
 281
 282   def crop_offset_x(self): return self.crop_offset_x_
 283
 284   def set_crop_offset_x(self, x):
 285     self.has_crop_offset_x_ = 1
 286     self.crop_offset_x_ = x
 287
 288   def clear_crop_offset_x(self):
 289     if self.has_crop_offset_x_:
 290       self.has_crop_offset_x_ = 0
 291       self.crop_offset_x_ = 0.5
 292
 293   def has_crop_offset_x(self): return self.has_crop_offset_x_
 294
 295   def crop_offset_y(self): return self.crop_offset_y_
 296
 297   def set_crop_offset_y(self, x):
 298     self.has_crop_offset_y_ = 1
 299     self.crop_offset_y_ = x
 300
 301   def clear_crop_offset_y(self):
 302     if self.has_crop_offset_y_:
 303       self.has_crop_offset_y_ = 0
 304       self.crop_offset_y_ = 0.5
 305
 306   def has_crop_offset_y(self): return self.has_crop_offset_y_
 307
 308   def rotate(self): return self.rotate_
 309
 310   def set_rotate(self, x):
 311     self.has_rotate_ = 1
 312     self.rotate_ = x
 313
 314   def clear_rotate(self):
 315     if self.has_rotate_:
 316       self.has_rotate_ = 0
 317       self.rotate_ = 0
 318
 319   def has_rotate(self): return self.has_rotate_
 320
 321   def horizontal_flip(self): return self.horizontal_flip_
 322
 323   def set_horizontal_flip(self, x):
 324     self.has_horizontal_flip_ = 1
 325     self.horizontal_flip_ = x
 326
 327   def clear_horizontal_flip(self):
 328     if self.has_horizontal_flip_:
 329       self.has_horizontal_flip_ = 0
 330       self.horizontal_flip_ = 0
 331
 332   def has_horizontal_flip(self): return self.has_horizontal_flip_
 333
 334   def vertical_flip(self): return self.vertical_flip_
 335
 336   def set_vertical_flip(self, x):
 337     self.has_vertical_flip_ = 1
 338     self.vertical_flip_ = x
 339
 340   def clear_vertical_flip(self):
 341     if self.has_vertical_flip_:
 342       self.has_vertical_flip_ = 0
 343       self.vertical_flip_ = 0
 344
 345   def has_vertical_flip(self): return self.has_vertical_flip_
 346
 347   def crop_left_x(self): return self.crop_left_x_
 348
 349   def set_crop_left_x(self, x):
 350     self.has_crop_left_x_ = 1
 351     self.crop_left_x_ = x
 352
 353   def clear_crop_left_x(self):
 354     if self.has_crop_left_x_:
 355       self.has_crop_left_x_ = 0
 356       self.crop_left_x_ = 0.0
 357
 358   def has_crop_left_x(self): return self.has_crop_left_x_
 359
 360   def crop_top_y(self): return self.crop_top_y_
 361
 362   def set_crop_top_y(self, x):
 363     self.has_crop_top_y_ = 1
 364     self.crop_top_y_ = x
 365
 366   def clear_crop_top_y(self):
 367     if self.has_crop_top_y_:
 368       self.has_crop_top_y_ = 0
 369       self.crop_top_y_ = 0.0
 370
 371   def has_crop_top_y(self): return self.has_crop_top_y_
 372
 373   def crop_right_x(self): return self.crop_right_x_
 374
 375   def set_crop_right_x(self, x):
 376     self.has_crop_right_x_ = 1
 377     self.crop_right_x_ = x
 378
 379   def clear_crop_right_x(self):
 380     if self.has_crop_right_x_:
 381       self.has_crop_right_x_ = 0
 382       self.crop_right_x_ = 1.0
 383
 384   def has_crop_right_x(self): return self.has_crop_right_x_
 385
 386   def crop_bottom_y(self): return self.crop_bottom_y_
 387
 388   def set_crop_bottom_y(self, x):
 389     self.has_crop_bottom_y_ = 1
 390     self.crop_bottom_y_ = x
 391
 392   def clear_crop_bottom_y(self):
 393     if self.has_crop_bottom_y_:
 394       self.has_crop_bottom_y_ = 0
 395       self.crop_bottom_y_ = 1.0
 396
 397   def has_crop_bottom_y(self): return self.has_crop_bottom_y_
 398
 399   def autolevels(self): return self.autolevels_
 400
 401   def set_autolevels(self, x):
 402     self.has_autolevels_ = 1
 403     self.autolevels_ = x
 404
 405   def clear_autolevels(self):
 406     if self.has_autolevels_:
 407       self.has_autolevels_ = 0
 408       self.autolevels_ = 0
 409
 410   def has_autolevels(self): return self.has_autolevels_
 411
 412   def allow_stretch(self): return self.allow_stretch_
 413
 414   def set_allow_stretch(self, x):
 415     self.has_allow_stretch_ = 1
 416     self.allow_stretch_ = x
 417
 418   def clear_allow_stretch(self):
 419     if self.has_allow_stretch_:
 420       self.has_allow_stretch_ = 0
 421       self.allow_stretch_ = 0
 422
 423   def has_allow_stretch(self): return self.has_allow_stretch_
 424
 425
 426   def MergeFrom(self, x):
 427     assert x is not self
 428     if (x.has_width()): self.set_width(x.width())
 429     if (x.has_height()): self.set_height(x.height())
 430     if (x.has_crop_to_fit()): self.set_crop_to_fit(x.crop_to_fit())
 431     if (x.has_crop_offset_x()): self.set_crop_offset_x(x.crop_offset_x())
 432     if (x.has_crop_offset_y()): self.set_crop_offset_y(x.crop_offset_y())
 433     if (x.has_rotate()): self.set_rotate(x.rotate())
 434     if (x.has_horizontal_flip()): self.set_horizontal_flip(x.horizontal_flip())
 435     if (x.has_vertical_flip()): self.set_vertical_flip(x.vertical_flip())
 436     if (x.has_crop_left_x()): self.set_crop_left_x(x.crop_left_x())
 437     if (x.has_crop_top_y()): self.set_crop_top_y(x.crop_top_y())
 438     if (x.has_crop_right_x()): self.set_crop_right_x(x.crop_right_x())
 439     if (x.has_crop_bottom_y()): self.set_crop_bottom_y(x.crop_bottom_y())
 440     if (x.has_autolevels()): self.set_autolevels(x.autolevels())
 441     if (x.has_allow_stretch()): self.set_allow_stretch(x.allow_stretch())
 442
 443   def Equals(self, x):
 444     if x is self: return 1
 445     if self.has_width_ != x.has_width_: return 0
 446     if self.has_width_ and self.width_ != x.width_: return 0
 447     if self.has_height_ != x.has_height_: return 0
 448     if self.has_height_ and self.height_ != x.height_: return 0
 449     if self.has_crop_to_fit_ != x.has_crop_to_fit_: return 0
 450     if self.has_crop_to_fit_ and self.crop_to_fit_ != x.crop_to_fit_: return 0
 451     if self.has_crop_offset_x_ != x.has_crop_offset_x_: return 0
 452     if self.has_crop_offset_x_ and self.crop_offset_x_ != x.crop_offset_x_: return 0
 453     if self.has_crop_offset_y_ != x.has_crop_offset_y_: return 0
 454     if self.has_crop_offset_y_ and self.crop_offset_y_ != x.crop_offset_y_: return 0
 455     if self.has_rotate_ != x.has_rotate_: return 0
 456     if self.has_rotate_ and self.rotate_ != x.rotate_: return 0
 457     if self.has_horizontal_flip_ != x.has_horizontal_flip_: return 0
 458     if self.has_horizontal_flip_ and self.horizontal_flip_ != x.horizontal_flip_: return 0
 459     if self.has_vertical_flip_ != x.has_vertical_flip_: return 0
 460     if self.has_vertical_flip_ and self.vertical_flip_ != x.vertical_flip_: return 0
 461     if self.has_crop_left_x_ != x.has_crop_left_x_: return 0
 462     if self.has_crop_left_x_ and self.crop_left_x_ != x.crop_left_x_: return 0
 463     if self.has_crop_top_y_ != x.has_crop_top_y_: return 0
 464     if self.has_crop_top_y_ and self.crop_top_y_ != x.crop_top_y_: return 0
 465     if self.has_crop_right_x_ != x.has_crop_right_x_: return 0
 466     if self.has_crop_right_x_ and self.crop_right_x_ != x.crop_right_x_: return 0
 467     if self.has_crop_bottom_y_ != x.has_crop_bottom_y_: return 0
 468     if self.has_crop_bottom_y_ and self.crop_bottom_y_ != x.crop_bottom_y_: return 0
 469     if self.has_autolevels_ != x.has_autolevels_: return 0
 470     if self.has_autolevels_ and self.autolevels_ != x.autolevels_: return 0
 471     if self.has_allow_stretch_ != x.has_allow_stretch_: return 0
 472     if self.has_allow_stretch_ and self.allow_stretch_ != x.allow_stretch_: return 0
 473     return 1
 474
 475   def IsInitialized(self, debug_strs=None):
 476     initialized = 1
 477     return initialized
 478
 479   def ByteSize(self):
 480     n = 0
 481     if (self.has_width_): n += 1 + self.lengthVarInt64(self.width_)
 482     if (self.has_height_): n += 1 + self.lengthVarInt64(self.height_)
 483     if (self.has_crop_to_fit_): n += 2
 484     if (self.has_crop_offset_x_): n += 5
 485     if (self.has_crop_offset_y_): n += 5
 486     if (self.has_rotate_): n += 1 + self.lengthVarInt64(self.rotate_)
 487     if (self.has_horizontal_flip_): n += 2
 488     if (self.has_vertical_flip_): n += 2
 489     if (self.has_crop_left_x_): n += 5
 490     if (self.has_crop_top_y_): n += 5
 491     if (self.has_crop_right_x_): n += 5
 492     if (self.has_crop_bottom_y_): n += 5
 493     if (self.has_autolevels_): n += 2
 494     if (self.has_allow_stretch_): n += 2
 495     return n
 496
 497   def ByteSizePartial(self):
 498     n = 0
 499     if (self.has_width_): n += 1 + self.lengthVarInt64(self.width_)
 500     if (self.has_height_): n += 1 + self.lengthVarInt64(self.height_)
 501     if (self.has_crop_to_fit_): n += 2
 502     if (self.has_crop_offset_x_): n += 5
 503     if (self.has_crop_offset_y_): n += 5
 504     if (self.has_rotate_): n += 1 + self.lengthVarInt64(self.rotate_)
 505     if (self.has_horizontal_flip_): n += 2
 506     if (self.has_vertical_flip_): n += 2
 507     if (self.has_crop_left_x_): n += 5
 508     if (self.has_crop_top_y_): n += 5
 509     if (self.has_crop_right_x_): n += 5
 510     if (self.has_crop_bottom_y_): n += 5
 511     if (self.has_autolevels_): n += 2
 512     if (self.has_allow_stretch_): n += 2
 513     return n
 514
 515   def Clear(self):
 516     self.clear_width()
 517     self.clear_height()
 518     self.clear_crop_to_fit()
 519     self.clear_crop_offset_x()
 520     self.clear_crop_offset_y()
 521     self.clear_rotate()
 522     self.clear_horizontal_flip()
 523     self.clear_vertical_flip()
 524     self.clear_crop_left_x()
 525     self.clear_crop_top_y()
 526     self.clear_crop_right_x()
 527     self.clear_crop_bottom_y()
 528     self.clear_autolevels()
 529     self.clear_allow_stretch()
 530
 531   def OutputUnchecked(self, out):
 532     if (self.has_width_):
 533       out.putVarInt32(8)
 534       out.putVarInt32(self.width_)
 535     if (self.has_height_):
 536       out.putVarInt32(16)
 537       out.putVarInt32(self.height_)
 538     if (self.has_rotate_):
 539       out.putVarInt32(24)
 540       out.putVarInt32(self.rotate_)
 541     if (self.has_horizontal_flip_):
 542       out.putVarInt32(32)
 543       out.putBoolean(self.horizontal_flip_)
 544     if (self.has_vertical_flip_):
 545       out.putVarInt32(40)
 546       out.putBoolean(self.vertical_flip_)
 547     if (self.has_crop_left_x_):
 548       out.putVarInt32(53)
 549       out.putFloat(self.crop_left_x_)
 550     if (self.has_crop_top_y_):
 551       out.putVarInt32(61)
 552       out.putFloat(self.crop_top_y_)
 553     if (self.has_crop_right_x_):
 554       out.putVarInt32(69)
 555       out.putFloat(self.crop_right_x_)
 556     if (self.has_crop_bottom_y_):
 557       out.putVarInt32(77)
 558       out.putFloat(self.crop_bottom_y_)
 559     if (self.has_autolevels_):
 560       out.putVarInt32(80)
 561       out.putBoolean(self.autolevels_)
 562     if (self.has_crop_to_fit_):
 563       out.putVarInt32(88)
 564       out.putBoolean(self.crop_to_fit_)
 565     if (self.has_crop_offset_x_):
 566       out.putVarInt32(101)
 567       out.putFloat(self.crop_offset_x_)
 568     if (self.has_crop_offset_y_):
 569       out.putVarInt32(109)
 570       out.putFloat(self.crop_offset_y_)
 571     if (self.has_allow_stretch_):
 572       out.putVarInt32(112)
 573       out.putBoolean(self.allow_stretch_)
 574
 575   def OutputPartial(self, out):
 576     if (self.has_width_):
 577       out.putVarInt32(8)
 578       out.putVarInt32(self.width_)
 579     if (self.has_height_):
 580       out.putVarInt32(16)
 581       out.putVarInt32(self.height_)
 582     if (self.has_rotate_):
 583       out.putVarInt32(24)
 584       out.putVarInt32(self.rotate_)
 585     if (self.has_horizontal_flip_):
 586       out.putVarInt32(32)
 587       out.putBoolean(self.horizontal_flip_)
 588     if (self.has_vertical_flip_):
 589       out.putVarInt32(40)
 590       out.putBoolean(self.vertical_flip_)
 591     if (self.has_crop_left_x_):
 592       out.putVarInt32(53)
 593       out.putFloat(self.crop_left_x_)
 594     if (self.has_crop_top_y_):
 595       out.putVarInt32(61)
 596       out.putFloat(self.crop_top_y_)
 597     if (self.has_crop_right_x_):
 598       out.putVarInt32(69)
 599       out.putFloat(self.crop_right_x_)
 600     if (self.has_crop_bottom_y_):
 601       out.putVarInt32(77)
 602       out.putFloat(self.crop_bottom_y_)
 603     if (self.has_autolevels_):
 604       out.putVarInt32(80)
 605       out.putBoolean(self.autolevels_)
 606     if (self.has_crop_to_fit_):
 607       out.putVarInt32(88)
 608       out.putBoolean(self.crop_to_fit_)
 609     if (self.has_crop_offset_x_):
 610       out.putVarInt32(101)
 611       out.putFloat(self.crop_offset_x_)
 612     if (self.has_crop_offset_y_):
 613       out.putVarInt32(109)
 614       out.putFloat(self.crop_offset_y_)
 615     if (self.has_allow_stretch_):
 616       out.putVarInt32(112)
 617       out.putBoolean(self.allow_stretch_)
 618
 619   def TryMerge(self, d):
 620     while d.avail() > 0:
 621       tt = d.getVarInt32()
 622       if tt == 8:
 623         self.set_width(d.getVarInt32())
 624         continue
 625       if tt == 16:
 626         self.set_height(d.getVarInt32())
 627         continue
 628       if tt == 24:
 629         self.set_rotate(d.getVarInt32())
 630         continue
 631       if tt == 32:
 632         self.set_horizontal_flip(d.getBoolean())
 633         continue
 634       if tt == 40:
 635         self.set_vertical_flip(d.getBoolean())
 636         continue
 637       if tt == 53:
 638         self.set_crop_left_x(d.getFloat())
 639         continue
 640       if tt == 61:
 641         self.set_crop_top_y(d.getFloat())
 642         continue
 643       if tt == 69:
 644         self.set_crop_right_x(d.getFloat())
 645         continue
 646       if tt == 77:
 647         self.set_crop_bottom_y(d.getFloat())
 648         continue
 649       if tt == 80:
 650         self.set_autolevels(d.getBoolean())
 651         continue
 652       if tt == 88:
 653         self.set_crop_to_fit(d.getBoolean())
 654         continue
 655       if tt == 101:
 656         self.set_crop_offset_x(d.getFloat())
 657         continue
 658       if tt == 109:
 659         self.set_crop_offset_y(d.getFloat())
 660         continue
 661       if tt == 112:
 662         self.set_allow_stretch(d.getBoolean())
 663         continue
 664
 665
 666       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 667       d.skipData(tt)
 668
 669
 670   def __str__(self, prefix="", printElemNumber=0):
 671     res=""
 672     if self.has_width_: res+=prefix+("width: %s\n" % self.DebugFormatInt32(self.width_))
 673     if self.has_height_: res+=prefix+("height: %s\n" % self.DebugFormatInt32(self.height_))
 674     if self.has_crop_to_fit_: res+=prefix+("crop_to_fit: %s\n" % self.DebugFormatBool(self.crop_to_fit_))
 675     if self.has_crop_offset_x_: res+=prefix+("crop_offset_x: %s\n" % self.DebugFormatFloat(self.crop_offset_x_))
 676     if self.has_crop_offset_y_: res+=prefix+("crop_offset_y: %s\n" % self.DebugFormatFloat(self.crop_offset_y_))
 677     if self.has_rotate_: res+=prefix+("rotate: %s\n" % self.DebugFormatInt32(self.rotate_))
 678     if self.has_horizontal_flip_: res+=prefix+("horizontal_flip: %s\n" % self.DebugFormatBool(self.horizontal_flip_))
 679     if self.has_vertical_flip_: res+=prefix+("vertical_flip: %s\n" % self.DebugFormatBool(self.vertical_flip_))
 680     if self.has_crop_left_x_: res+=prefix+("crop_left_x: %s\n" % self.DebugFormatFloat(self.crop_left_x_))
 681     if self.has_crop_top_y_: res+=prefix+("crop_top_y: %s\n" % self.DebugFormatFloat(self.crop_top_y_))
 682     if self.has_crop_right_x_: res+=prefix+("crop_right_x: %s\n" % self.DebugFormatFloat(self.crop_right_x_))
 683     if self.has_crop_bottom_y_: res+=prefix+("crop_bottom_y: %s\n" % self.DebugFormatFloat(self.crop_bottom_y_))
 684     if self.has_autolevels_: res+=prefix+("autolevels: %s\n" % self.DebugFormatBool(self.autolevels_))
 685     if self.has_allow_stretch_: res+=prefix+("allow_stretch: %s\n" % self.DebugFormatBool(self.allow_stretch_))
 686     return res
 687
 688
 689   def _BuildTagLookupTable(sparse, maxtag, default=None):
 690     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 691
 692   kwidth = 1
 693   kheight = 2
 694   kcrop_to_fit = 11
 695   kcrop_offset_x = 12
 696   kcrop_offset_y = 13
 697   krotate = 3
 698   khorizontal_flip = 4
 699   kvertical_flip = 5
 700   kcrop_left_x = 6
 701   kcrop_top_y = 7
 702   kcrop_right_x = 8
 703   kcrop_bottom_y = 9
 704   kautolevels = 10
 705   kallow_stretch = 14
 706
 707   _TEXT = _BuildTagLookupTable({
 708     0: "ErrorCode",
 709     1: "width",
 710     2: "height",
 711     3: "rotate",
 712     4: "horizontal_flip",
 713     5: "vertical_flip",
 714     6: "crop_left_x",
 715     7: "crop_top_y",
 716     8: "crop_right_x",
 717     9: "crop_bottom_y",
 718     10: "autolevels",
 719     11: "crop_to_fit",
 720     12: "crop_offset_x",
 721     13: "crop_offset_y",
 722     14: "allow_stretch",
 723   }, 14)
 724
 725   _TYPES = _BuildTagLookupTable({
 726     0: ProtocolBuffer.Encoder.NUMERIC,
 727     1: ProtocolBuffer.Encoder.NUMERIC,
 728     2: ProtocolBuffer.Encoder.NUMERIC,
 729     3: ProtocolBuffer.Encoder.NUMERIC,
 730     4: ProtocolBuffer.Encoder.NUMERIC,
 731     5: ProtocolBuffer.Encoder.NUMERIC,
 732     6: ProtocolBuffer.Encoder.FLOAT,
 733     7: ProtocolBuffer.Encoder.FLOAT,
 734     8: ProtocolBuffer.Encoder.FLOAT,
 735     9: ProtocolBuffer.Encoder.FLOAT,
 736     10: ProtocolBuffer.Encoder.NUMERIC,
 737     11: ProtocolBuffer.Encoder.NUMERIC,
 738     12: ProtocolBuffer.Encoder.FLOAT,
 739     13: ProtocolBuffer.Encoder.FLOAT,
 740     14: ProtocolBuffer.Encoder.NUMERIC,
 741   }, 14, ProtocolBuffer.Encoder.MAX_TYPE)
 742
 743
 744   _STYLE = """"""
 745   _STYLE_CONTENT_TYPE = """"""
 746   _PROTO_DESCRIPTOR_NAME = 'apphosting.Transform'
 747 class ImageData(ProtocolBuffer.ProtocolMessage):
 748   has_content_ = 0
 749   content_ = ""
 750   has_blob_key_ = 0
 751   blob_key_ = ""
 752   has_width_ = 0
 753   width_ = 0
 754   has_height_ = 0
 755   height_ = 0
 756
 757   def __init__(self, contents=None):
 758     if contents is not None: self.MergeFromString(contents)
 759
 760   def content(self): return self.content_
 761
 762   def set_content(self, x):
 763     self.has_content_ = 1
 764     self.content_ = x
 765
 766   def clear_content(self):
 767     if self.has_content_:
 768       self.has_content_ = 0
 769       self.content_ = ""
 770
 771   def has_content(self): return self.has_content_
 772
 773   def blob_key(self): return self.blob_key_
 774
 775   def set_blob_key(self, x):
 776     self.has_blob_key_ = 1
 777     self.blob_key_ = x
 778
 779   def clear_blob_key(self):
 780     if self.has_blob_key_:
 781       self.has_blob_key_ = 0
 782       self.blob_key_ = ""
 783
 784   def has_blob_key(self): return self.has_blob_key_
 785
 786   def width(self): return self.width_
 787
 788   def set_width(self, x):
 789     self.has_width_ = 1
 790     self.width_ = x
 791
 792   def clear_width(self):
 793     if self.has_width_:
 794       self.has_width_ = 0
 795       self.width_ = 0
 796
 797   def has_width(self): return self.has_width_
 798
 799   def height(self): return self.height_
 800
 801   def set_height(self, x):
 802     self.has_height_ = 1
 803     self.height_ = x
 804
 805   def clear_height(self):
 806     if self.has_height_:
 807       self.has_height_ = 0
 808       self.height_ = 0
 809
 810   def has_height(self): return self.has_height_
 811
 812
 813   def MergeFrom(self, x):
 814     assert x is not self
 815     if (x.has_content()): self.set_content(x.content())
 816     if (x.has_blob_key()): self.set_blob_key(x.blob_key())
 817     if (x.has_width()): self.set_width(x.width())
 818     if (x.has_height()): self.set_height(x.height())
 819
 820   def Equals(self, x):
 821     if x is self: return 1
 822     if self.has_content_ != x.has_content_: return 0
 823     if self.has_content_ and self.content_ != x.content_: return 0
 824     if self.has_blob_key_ != x.has_blob_key_: return 0
 825     if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0
 826     if self.has_width_ != x.has_width_: return 0
 827     if self.has_width_ and self.width_ != x.width_: return 0
 828     if self.has_height_ != x.has_height_: return 0
 829     if self.has_height_ and self.height_ != x.height_: return 0
 830     return 1
 831
 832   def IsInitialized(self, debug_strs=None):
 833     initialized = 1
 834     if (not self.has_content_):
 835       initialized = 0
 836       if debug_strs is not None:
 837         debug_strs.append('Required field: content not set.')
 838     return initialized
 839
 840   def ByteSize(self):
 841     n = 0
 842     n += self.lengthString(len(self.content_))
 843     if (self.has_blob_key_): n += 1 + self.lengthString(len(self.blob_key_))
 844     if (self.has_width_): n += 1 + self.lengthVarInt64(self.width_)
 845     if (self.has_height_): n += 1 + self.lengthVarInt64(self.height_)
 846     return n + 1
 847
 848   def ByteSizePartial(self):
 849     n = 0
 850     if (self.has_content_):
 851       n += 1
 852       n += self.lengthString(len(self.content_))
 853     if (self.has_blob_key_): n += 1 + self.lengthString(len(self.blob_key_))
 854     if (self.has_width_): n += 1 + self.lengthVarInt64(self.width_)
 855     if (self.has_height_): n += 1 + self.lengthVarInt64(self.height_)
 856     return n
 857
 858   def Clear(self):
 859     self.clear_content()
 860     self.clear_blob_key()
 861     self.clear_width()
 862     self.clear_height()
 863
 864   def OutputUnchecked(self, out):
 865     out.putVarInt32(10)
 866     out.putPrefixedString(self.content_)
 867     if (self.has_blob_key_):
 868       out.putVarInt32(18)
 869       out.putPrefixedString(self.blob_key_)
 870     if (self.has_width_):
 871       out.putVarInt32(24)
 872       out.putVarInt32(self.width_)
 873     if (self.has_height_):
 874       out.putVarInt32(32)
 875       out.putVarInt32(self.height_)
 876
 877   def OutputPartial(self, out):
 878     if (self.has_content_):
 879       out.putVarInt32(10)
 880       out.putPrefixedString(self.content_)
 881     if (self.has_blob_key_):
 882       out.putVarInt32(18)
 883       out.putPrefixedString(self.blob_key_)
 884     if (self.has_width_):
 885       out.putVarInt32(24)
 886       out.putVarInt32(self.width_)
 887     if (self.has_height_):
 888       out.putVarInt32(32)
 889       out.putVarInt32(self.height_)
 890
 891   def TryMerge(self, d):
 892     while d.avail() > 0:
 893       tt = d.getVarInt32()
 894       if tt == 10:
 895         self.set_content(d.getPrefixedString())
 896         continue
 897       if tt == 18:
 898         self.set_blob_key(d.getPrefixedString())
 899         continue
 900       if tt == 24:
 901         self.set_width(d.getVarInt32())
 902         continue
 903       if tt == 32:
 904         self.set_height(d.getVarInt32())
 905         continue
 906
 907
 908       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 909       d.skipData(tt)
 910
 911
 912   def __str__(self, prefix="", printElemNumber=0):
 913     res=""
 914     if self.has_content_: res+=prefix+("content: %s\n" % self.DebugFormatString(self.content_))
 915     if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_))
 916     if self.has_width_: res+=prefix+("width: %s\n" % self.DebugFormatInt32(self.width_))
 917     if self.has_height_: res+=prefix+("height: %s\n" % self.DebugFormatInt32(self.height_))
 918     return res
 919
 920
 921   def _BuildTagLookupTable(sparse, maxtag, default=None):
 922     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 923
 924   kcontent = 1
 925   kblob_key = 2
 926   kwidth = 3
 927   kheight = 4
 928
 929   _TEXT = _BuildTagLookupTable({
 930     0: "ErrorCode",
 931     1: "content",
 932     2: "blob_key",
 933     3: "width",
 934     4: "height",
 935   }, 4)
 936
 937   _TYPES = _BuildTagLookupTable({
 938     0: ProtocolBuffer.Encoder.NUMERIC,
 939     1: ProtocolBuffer.Encoder.STRING,
 940     2: ProtocolBuffer.Encoder.STRING,
 941     3: ProtocolBuffer.Encoder.NUMERIC,
 942     4: ProtocolBuffer.Encoder.NUMERIC,
 943   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
 944
 945
 946   _STYLE = """"""
 947   _STYLE_CONTENT_TYPE = """"""
 948   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImageData'
 949 class InputSettings(ProtocolBuffer.ProtocolMessage):
 950
 951
 952   UNCHANGED_ORIENTATION =    0
 953   CORRECT_ORIENTATION =    1
 954
 955   _ORIENTATION_CORRECTION_TYPE_NAMES = {
 956     0: "UNCHANGED_ORIENTATION",
 957     1: "CORRECT_ORIENTATION",
 958   }
 959
 960   def ORIENTATION_CORRECTION_TYPE_Name(cls, x): return cls._ORIENTATION_CORRECTION_TYPE_NAMES.get(x, "")
 961   ORIENTATION_CORRECTION_TYPE_Name = classmethod(ORIENTATION_CORRECTION_TYPE_Name)
 962
 963   has_correct_exif_orientation_ = 0
 964   correct_exif_orientation_ = 0
 965   has_parse_metadata_ = 0
 966   parse_metadata_ = 0
 967   has_transparent_substitution_rgb_ = 0
 968   transparent_substitution_rgb_ = 0
 969
 970   def __init__(self, contents=None):
 971     if contents is not None: self.MergeFromString(contents)
 972
 973   def correct_exif_orientation(self): return self.correct_exif_orientation_
 974
 975   def set_correct_exif_orientation(self, x):
 976     self.has_correct_exif_orientation_ = 1
 977     self.correct_exif_orientation_ = x
 978
 979   def clear_correct_exif_orientation(self):
 980     if self.has_correct_exif_orientation_:
 981       self.has_correct_exif_orientation_ = 0
 982       self.correct_exif_orientation_ = 0
 983
 984   def has_correct_exif_orientation(self): return self.has_correct_exif_orientation_
 985
 986   def parse_metadata(self): return self.parse_metadata_
 987
 988   def set_parse_metadata(self, x):
 989     self.has_parse_metadata_ = 1
 990     self.parse_metadata_ = x
 991
 992   def clear_parse_metadata(self):
 993     if self.has_parse_metadata_:
 994       self.has_parse_metadata_ = 0
 995       self.parse_metadata_ = 0
 996
 997   def has_parse_metadata(self): return self.has_parse_metadata_
 998
 999   def transparent_substitution_rgb(self): return self.transparent_substitution_rgb_
1000
1001   def set_transparent_substitution_rgb(self, x):
1002     self.has_transparent_substitution_rgb_ = 1
1003     self.transparent_substitution_rgb_ = x
1004
1005   def clear_transparent_substitution_rgb(self):
1006     if self.has_transparent_substitution_rgb_:
1007       self.has_transparent_substitution_rgb_ = 0
1008       self.transparent_substitution_rgb_ = 0
1009
1010   def has_transparent_substitution_rgb(self): return self.has_transparent_substitution_rgb_
1011
1012
1013   def MergeFrom(self, x):
1014     assert x is not self
1015     if (x.has_correct_exif_orientation()): self.set_correct_exif_orientation(x.correct_exif_orientation())
1016     if (x.has_parse_metadata()): self.set_parse_metadata(x.parse_metadata())
1017     if (x.has_transparent_substitution_rgb()): self.set_transparent_substitution_rgb(x.transparent_substitution_rgb())
1018
1019   def Equals(self, x):
1020     if x is self: return 1
1021     if self.has_correct_exif_orientation_ != x.has_correct_exif_orientation_: return 0
1022     if self.has_correct_exif_orientation_ and self.correct_exif_orientation_ != x.correct_exif_orientation_: return 0
1023     if self.has_parse_metadata_ != x.has_parse_metadata_: return 0
1024     if self.has_parse_metadata_ and self.parse_metadata_ != x.parse_metadata_: return 0
1025     if self.has_transparent_substitution_rgb_ != x.has_transparent_substitution_rgb_: return 0
1026     if self.has_transparent_substitution_rgb_ and self.transparent_substitution_rgb_ != x.transparent_substitution_rgb_: return 0
1027     return 1
1028
1029   def IsInitialized(self, debug_strs=None):
1030     initialized = 1
1031     return initialized
1032
1033   def ByteSize(self):
1034     n = 0
1035     if (self.has_correct_exif_orientation_): n += 1 + self.lengthVarInt64(self.correct_exif_orientation_)
1036     if (self.has_parse_metadata_): n += 2
1037     if (self.has_transparent_substitution_rgb_): n += 1 + self.lengthVarInt64(self.transparent_substitution_rgb_)
1038     return n
1039
1040   def ByteSizePartial(self):
1041     n = 0
1042     if (self.has_correct_exif_orientation_): n += 1 + self.lengthVarInt64(self.correct_exif_orientation_)
1043     if (self.has_parse_metadata_): n += 2
1044     if (self.has_transparent_substitution_rgb_): n += 1 + self.lengthVarInt64(self.transparent_substitution_rgb_)
1045     return n
1046
1047   def Clear(self):
1048     self.clear_correct_exif_orientation()
1049     self.clear_parse_metadata()
1050     self.clear_transparent_substitution_rgb()
1051
1052   def OutputUnchecked(self, out):
1053     if (self.has_correct_exif_orientation_):
1054       out.putVarInt32(8)
1055       out.putVarInt32(self.correct_exif_orientation_)
1056     if (self.has_parse_metadata_):
1057       out.putVarInt32(16)
1058       out.putBoolean(self.parse_metadata_)
1059     if (self.has_transparent_substitution_rgb_):
1060       out.putVarInt32(24)
1061       out.putVarInt32(self.transparent_substitution_rgb_)
1062
1063   def OutputPartial(self, out):
1064     if (self.has_correct_exif_orientation_):
1065       out.putVarInt32(8)
1066       out.putVarInt32(self.correct_exif_orientation_)
1067     if (self.has_parse_metadata_):
1068       out.putVarInt32(16)
1069       out.putBoolean(self.parse_metadata_)
1070     if (self.has_transparent_substitution_rgb_):
1071       out.putVarInt32(24)
1072       out.putVarInt32(self.transparent_substitution_rgb_)
1073
1074   def TryMerge(self, d):
1075     while d.avail() > 0:
1076       tt = d.getVarInt32()
1077       if tt == 8:
1078         self.set_correct_exif_orientation(d.getVarInt32())
1079         continue
1080       if tt == 16:
1081         self.set_parse_metadata(d.getBoolean())
1082         continue
1083       if tt == 24:
1084         self.set_transparent_substitution_rgb(d.getVarInt32())
1085         continue
1086
1087
1088       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1089       d.skipData(tt)
1090
1091
1092   def __str__(self, prefix="", printElemNumber=0):
1093     res=""
1094     if self.has_correct_exif_orientation_: res+=prefix+("correct_exif_orientation: %s\n" % self.DebugFormatInt32(self.correct_exif_orientation_))
1095     if self.has_parse_metadata_: res+=prefix+("parse_metadata: %s\n" % self.DebugFormatBool(self.parse_metadata_))
1096     if self.has_transparent_substitution_rgb_: res+=prefix+("transparent_substitution_rgb: %s\n" % self.DebugFormatInt32(self.transparent_substitution_rgb_))
1097     return res
1098
1099
1100   def _BuildTagLookupTable(sparse, maxtag, default=None):
1101     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1102
1103   kcorrect_exif_orientation = 1
1104   kparse_metadata = 2
1105   ktransparent_substitution_rgb = 3
1106
1107   _TEXT = _BuildTagLookupTable({
1108     0: "ErrorCode",
1109     1: "correct_exif_orientation",
1110     2: "parse_metadata",
1111     3: "transparent_substitution_rgb",
1112   }, 3)
1113
1114   _TYPES = _BuildTagLookupTable({
1115     0: ProtocolBuffer.Encoder.NUMERIC,
1116     1: ProtocolBuffer.Encoder.NUMERIC,
1117     2: ProtocolBuffer.Encoder.NUMERIC,
1118     3: ProtocolBuffer.Encoder.NUMERIC,
1119   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
1120
1121
1122   _STYLE = """"""
1123   _STYLE_CONTENT_TYPE = """"""
1124   _PROTO_DESCRIPTOR_NAME = 'apphosting.InputSettings'
1125 class OutputSettings(ProtocolBuffer.ProtocolMessage):
1126
1127
1128   PNG          =    0
1129   JPEG         =    1
1130   WEBP         =    2
1131
1132   _MIME_TYPE_NAMES = {
1133     0: "PNG",
1134     1: "JPEG",
1135     2: "WEBP",
1136   }
1137
1138   def MIME_TYPE_Name(cls, x): return cls._MIME_TYPE_NAMES.get(x, "")
1139   MIME_TYPE_Name = classmethod(MIME_TYPE_Name)
1140
1141   has_mime_type_ = 0
1142   mime_type_ = 0
1143   has_quality_ = 0
1144   quality_ = 0
1145
1146   def __init__(self, contents=None):
1147     if contents is not None: self.MergeFromString(contents)
1148
1149   def mime_type(self): return self.mime_type_
1150
1151   def set_mime_type(self, x):
1152     self.has_mime_type_ = 1
1153     self.mime_type_ = x
1154
1155   def clear_mime_type(self):
1156     if self.has_mime_type_:
1157       self.has_mime_type_ = 0
1158       self.mime_type_ = 0
1159
1160   def has_mime_type(self): return self.has_mime_type_
1161
1162   def quality(self): return self.quality_
1163
1164   def set_quality(self, x):
1165     self.has_quality_ = 1
1166     self.quality_ = x
1167
1168   def clear_quality(self):
1169     if self.has_quality_:
1170       self.has_quality_ = 0
1171       self.quality_ = 0
1172
1173   def has_quality(self): return self.has_quality_
1174
1175
1176   def MergeFrom(self, x):
1177     assert x is not self
1178     if (x.has_mime_type()): self.set_mime_type(x.mime_type())
1179     if (x.has_quality()): self.set_quality(x.quality())
1180
1181   def Equals(self, x):
1182     if x is self: return 1
1183     if self.has_mime_type_ != x.has_mime_type_: return 0
1184     if self.has_mime_type_ and self.mime_type_ != x.mime_type_: return 0
1185     if self.has_quality_ != x.has_quality_: return 0
1186     if self.has_quality_ and self.quality_ != x.quality_: return 0
1187     return 1
1188
1189   def IsInitialized(self, debug_strs=None):
1190     initialized = 1
1191     return initialized
1192
1193   def ByteSize(self):
1194     n = 0
1195     if (self.has_mime_type_): n += 1 + self.lengthVarInt64(self.mime_type_)
1196     if (self.has_quality_): n += 1 + self.lengthVarInt64(self.quality_)
1197     return n
1198
1199   def ByteSizePartial(self):
1200     n = 0
1201     if (self.has_mime_type_): n += 1 + self.lengthVarInt64(self.mime_type_)
1202     if (self.has_quality_): n += 1 + self.lengthVarInt64(self.quality_)
1203     return n
1204
1205   def Clear(self):
1206     self.clear_mime_type()
1207     self.clear_quality()
1208
1209   def OutputUnchecked(self, out):
1210     if (self.has_mime_type_):
1211       out.putVarInt32(8)
1212       out.putVarInt32(self.mime_type_)
1213     if (self.has_quality_):
1214       out.putVarInt32(16)
1215       out.putVarInt32(self.quality_)
1216
1217   def OutputPartial(self, out):
1218     if (self.has_mime_type_):
1219       out.putVarInt32(8)
1220       out.putVarInt32(self.mime_type_)
1221     if (self.has_quality_):
1222       out.putVarInt32(16)
1223       out.putVarInt32(self.quality_)
1224
1225   def TryMerge(self, d):
1226     while d.avail() > 0:
1227       tt = d.getVarInt32()
1228       if tt == 8:
1229         self.set_mime_type(d.getVarInt32())
1230         continue
1231       if tt == 16:
1232         self.set_quality(d.getVarInt32())
1233         continue
1234
1235
1236       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1237       d.skipData(tt)
1238
1239
1240   def __str__(self, prefix="", printElemNumber=0):
1241     res=""
1242     if self.has_mime_type_: res+=prefix+("mime_type: %s\n" % self.DebugFormatInt32(self.mime_type_))
1243     if self.has_quality_: res+=prefix+("quality: %s\n" % self.DebugFormatInt32(self.quality_))
1244     return res
1245
1246
1247   def _BuildTagLookupTable(sparse, maxtag, default=None):
1248     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1249
1250   kmime_type = 1
1251   kquality = 2
1252
1253   _TEXT = _BuildTagLookupTable({
1254     0: "ErrorCode",
1255     1: "mime_type",
1256     2: "quality",
1257   }, 2)
1258
1259   _TYPES = _BuildTagLookupTable({
1260     0: ProtocolBuffer.Encoder.NUMERIC,
1261     1: ProtocolBuffer.Encoder.NUMERIC,
1262     2: ProtocolBuffer.Encoder.NUMERIC,
1263   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1264
1265
1266   _STYLE = """"""
1267   _STYLE_CONTENT_TYPE = """"""
1268   _PROTO_DESCRIPTOR_NAME = 'apphosting.OutputSettings'
1269 class ImagesTransformRequest(ProtocolBuffer.ProtocolMessage):
1270   has_image_ = 0
1271   has_output_ = 0
1272   has_input_ = 0
1273   input_ = None
1274
1275   def __init__(self, contents=None):
1276     self.image_ = ImageData()
1277     self.transform_ = []
1278     self.output_ = OutputSettings()
1279     self.lazy_init_lock_ = thread.allocate_lock()
1280     if contents is not None: self.MergeFromString(contents)
1281
1282   def image(self): return self.image_
1283
1284   def mutable_image(self): self.has_image_ = 1; return self.image_
1285
1286   def clear_image(self):self.has_image_ = 0; self.image_.Clear()
1287
1288   def has_image(self): return self.has_image_
1289
1290   def transform_size(self): return len(self.transform_)
1291   def transform_list(self): return self.transform_
1292
1293   def transform(self, i):
1294     return self.transform_[i]
1295
1296   def mutable_transform(self, i):
1297     return self.transform_[i]
1298
1299   def add_transform(self):
1300     x = Transform()
1301     self.transform_.append(x)
1302     return x
1303
1304   def clear_transform(self):
1305     self.transform_ = []
1306   def output(self): return self.output_
1307
1308   def mutable_output(self): self.has_output_ = 1; return self.output_
1309
1310   def clear_output(self):self.has_output_ = 0; self.output_.Clear()
1311
1312   def has_output(self): return self.has_output_
1313
1314   def input(self):
1315     if self.input_ is None:
1316       self.lazy_init_lock_.acquire()
1317       try:
1318         if self.input_ is None: self.input_ = InputSettings()
1319       finally:
1320         self.lazy_init_lock_.release()
1321     return self.input_
1322
1323   def mutable_input(self): self.has_input_ = 1; return self.input()
1324
1325   def clear_input(self):
1326
1327     if self.has_input_:
1328       self.has_input_ = 0;
1329       if self.input_ is not None: self.input_.Clear()
1330
1331   def has_input(self): return self.has_input_
1332
1333
1334   def MergeFrom(self, x):
1335     assert x is not self
1336     if (x.has_image()): self.mutable_image().MergeFrom(x.image())
1337     for i in xrange(x.transform_size()): self.add_transform().CopyFrom(x.transform(i))
1338     if (x.has_output()): self.mutable_output().MergeFrom(x.output())
1339     if (x.has_input()): self.mutable_input().MergeFrom(x.input())
1340
1341   def Equals(self, x):
1342     if x is self: return 1
1343     if self.has_image_ != x.has_image_: return 0
1344     if self.has_image_ and self.image_ != x.image_: return 0
1345     if len(self.transform_) != len(x.transform_): return 0
1346     for e1, e2 in zip(self.transform_, x.transform_):
1347       if e1 != e2: return 0
1348     if self.has_output_ != x.has_output_: return 0
1349     if self.has_output_ and self.output_ != x.output_: return 0
1350     if self.has_input_ != x.has_input_: return 0
1351     if self.has_input_ and self.input_ != x.input_: return 0
1352     return 1
1353
1354   def IsInitialized(self, debug_strs=None):
1355     initialized = 1
1356     if (not self.has_image_):
1357       initialized = 0
1358       if debug_strs is not None:
1359         debug_strs.append('Required field: image not set.')
1360     elif not self.image_.IsInitialized(debug_strs): initialized = 0
1361     for p in self.transform_:
1362       if not p.IsInitialized(debug_strs): initialized=0
1363     if (not self.has_output_):
1364       initialized = 0
1365       if debug_strs is not None:
1366         debug_strs.append('Required field: output not set.')
1367     elif not self.output_.IsInitialized(debug_strs): initialized = 0
1368     if (self.has_input_ and not self.input_.IsInitialized(debug_strs)): initialized = 0
1369     return initialized
1370
1371   def ByteSize(self):
1372     n = 0
1373     n += self.lengthString(self.image_.ByteSize())
1374     n += 1 * len(self.transform_)
1375     for i in xrange(len(self.transform_)): n += self.lengthString(self.transform_[i].ByteSize())
1376     n += self.lengthString(self.output_.ByteSize())
1377     if (self.has_input_): n += 1 + self.lengthString(self.input_.ByteSize())
1378     return n + 2
1379
1380   def ByteSizePartial(self):
1381     n = 0
1382     if (self.has_image_):
1383       n += 1
1384       n += self.lengthString(self.image_.ByteSizePartial())
1385     n += 1 * len(self.transform_)
1386     for i in xrange(len(self.transform_)): n += self.lengthString(self.transform_[i].ByteSizePartial())
1387     if (self.has_output_):
1388       n += 1
1389       n += self.lengthString(self.output_.ByteSizePartial())
1390     if (self.has_input_): n += 1 + self.lengthString(self.input_.ByteSizePartial())
1391     return n
1392
1393   def Clear(self):
1394     self.clear_image()
1395     self.clear_transform()
1396     self.clear_output()
1397     self.clear_input()
1398
1399   def OutputUnchecked(self, out):
1400     out.putVarInt32(10)
1401     out.putVarInt32(self.image_.ByteSize())
1402     self.image_.OutputUnchecked(out)
1403     for i in xrange(len(self.transform_)):
1404       out.putVarInt32(18)
1405       out.putVarInt32(self.transform_[i].ByteSize())
1406       self.transform_[i].OutputUnchecked(out)
1407     out.putVarInt32(26)
1408     out.putVarInt32(self.output_.ByteSize())
1409     self.output_.OutputUnchecked(out)
1410     if (self.has_input_):
1411       out.putVarInt32(34)
1412       out.putVarInt32(self.input_.ByteSize())
1413       self.input_.OutputUnchecked(out)
1414
1415   def OutputPartial(self, out):
1416     if (self.has_image_):
1417       out.putVarInt32(10)
1418       out.putVarInt32(self.image_.ByteSizePartial())
1419       self.image_.OutputPartial(out)
1420     for i in xrange(len(self.transform_)):
1421       out.putVarInt32(18)
1422       out.putVarInt32(self.transform_[i].ByteSizePartial())
1423       self.transform_[i].OutputPartial(out)
1424     if (self.has_output_):
1425       out.putVarInt32(26)
1426       out.putVarInt32(self.output_.ByteSizePartial())
1427       self.output_.OutputPartial(out)
1428     if (self.has_input_):
1429       out.putVarInt32(34)
1430       out.putVarInt32(self.input_.ByteSizePartial())
1431       self.input_.OutputPartial(out)
1432
1433   def TryMerge(self, d):
1434     while d.avail() > 0:
1435       tt = d.getVarInt32()
1436       if tt == 10:
1437         length = d.getVarInt32()
1438         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1439         d.skip(length)
1440         self.mutable_image().TryMerge(tmp)
1441         continue
1442       if tt == 18:
1443         length = d.getVarInt32()
1444         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1445         d.skip(length)
1446         self.add_transform().TryMerge(tmp)
1447         continue
1448       if tt == 26:
1449         length = d.getVarInt32()
1450         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1451         d.skip(length)
1452         self.mutable_output().TryMerge(tmp)
1453         continue
1454       if tt == 34:
1455         length = d.getVarInt32()
1456         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1457         d.skip(length)
1458         self.mutable_input().TryMerge(tmp)
1459         continue
1460
1461
1462       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1463       d.skipData(tt)
1464
1465
1466   def __str__(self, prefix="", printElemNumber=0):
1467     res=""
1468     if self.has_image_:
1469       res+=prefix+"image <\n"
1470       res+=self.image_.__str__(prefix + "  ", printElemNumber)
1471       res+=prefix+">\n"
1472     cnt=0
1473     for e in self.transform_:
1474       elm=""
1475       if printElemNumber: elm="(%d)" % cnt
1476       res+=prefix+("transform%s <\n" % elm)
1477       res+=e.__str__(prefix + "  ", printElemNumber)
1478       res+=prefix+">\n"
1479       cnt+=1
1480     if self.has_output_:
1481       res+=prefix+"output <\n"
1482       res+=self.output_.__str__(prefix + "  ", printElemNumber)
1483       res+=prefix+">\n"
1484     if self.has_input_:
1485       res+=prefix+"input <\n"
1486       res+=self.input_.__str__(prefix + "  ", printElemNumber)
1487       res+=prefix+">\n"
1488     return res
1489
1490
1491   def _BuildTagLookupTable(sparse, maxtag, default=None):
1492     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1493
1494   kimage = 1
1495   ktransform = 2
1496   koutput = 3
1497   kinput = 4
1498
1499   _TEXT = _BuildTagLookupTable({
1500     0: "ErrorCode",
1501     1: "image",
1502     2: "transform",
1503     3: "output",
1504     4: "input",
1505   }, 4)
1506
1507   _TYPES = _BuildTagLookupTable({
1508     0: ProtocolBuffer.Encoder.NUMERIC,
1509     1: ProtocolBuffer.Encoder.STRING,
1510     2: ProtocolBuffer.Encoder.STRING,
1511     3: ProtocolBuffer.Encoder.STRING,
1512     4: ProtocolBuffer.Encoder.STRING,
1513   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
1514
1515
1516   _STYLE = """"""
1517   _STYLE_CONTENT_TYPE = """"""
1518   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesTransformRequest'
1519 class ImagesTransformResponse(ProtocolBuffer.ProtocolMessage):
1520   has_image_ = 0
1521   has_source_metadata_ = 0
1522   source_metadata_ = ""
1523
1524   def __init__(self, contents=None):
1525     self.image_ = ImageData()
1526     if contents is not None: self.MergeFromString(contents)
1527
1528   def image(self): return self.image_
1529
1530   def mutable_image(self): self.has_image_ = 1; return self.image_
1531
1532   def clear_image(self):self.has_image_ = 0; self.image_.Clear()
1533
1534   def has_image(self): return self.has_image_
1535
1536   def source_metadata(self): return self.source_metadata_
1537
1538   def set_source_metadata(self, x):
1539     self.has_source_metadata_ = 1
1540     self.source_metadata_ = x
1541
1542   def clear_source_metadata(self):
1543     if self.has_source_metadata_:
1544       self.has_source_metadata_ = 0
1545       self.source_metadata_ = ""
1546
1547   def has_source_metadata(self): return self.has_source_metadata_
1548
1549
1550   def MergeFrom(self, x):
1551     assert x is not self
1552     if (x.has_image()): self.mutable_image().MergeFrom(x.image())
1553     if (x.has_source_metadata()): self.set_source_metadata(x.source_metadata())
1554
1555   def Equals(self, x):
1556     if x is self: return 1
1557     if self.has_image_ != x.has_image_: return 0
1558     if self.has_image_ and self.image_ != x.image_: return 0
1559     if self.has_source_metadata_ != x.has_source_metadata_: return 0
1560     if self.has_source_metadata_ and self.source_metadata_ != x.source_metadata_: return 0
1561     return 1
1562
1563   def IsInitialized(self, debug_strs=None):
1564     initialized = 1
1565     if (not self.has_image_):
1566       initialized = 0
1567       if debug_strs is not None:
1568         debug_strs.append('Required field: image not set.')
1569     elif not self.image_.IsInitialized(debug_strs): initialized = 0
1570     return initialized
1571
1572   def ByteSize(self):
1573     n = 0
1574     n += self.lengthString(self.image_.ByteSize())
1575     if (self.has_source_metadata_): n += 1 + self.lengthString(len(self.source_metadata_))
1576     return n + 1
1577
1578   def ByteSizePartial(self):
1579     n = 0
1580     if (self.has_image_):
1581       n += 1
1582       n += self.lengthString(self.image_.ByteSizePartial())
1583     if (self.has_source_metadata_): n += 1 + self.lengthString(len(self.source_metadata_))
1584     return n
1585
1586   def Clear(self):
1587     self.clear_image()
1588     self.clear_source_metadata()
1589
1590   def OutputUnchecked(self, out):
1591     out.putVarInt32(10)
1592     out.putVarInt32(self.image_.ByteSize())
1593     self.image_.OutputUnchecked(out)
1594     if (self.has_source_metadata_):
1595       out.putVarInt32(18)
1596       out.putPrefixedString(self.source_metadata_)
1597
1598   def OutputPartial(self, out):
1599     if (self.has_image_):
1600       out.putVarInt32(10)
1601       out.putVarInt32(self.image_.ByteSizePartial())
1602       self.image_.OutputPartial(out)
1603     if (self.has_source_metadata_):
1604       out.putVarInt32(18)
1605       out.putPrefixedString(self.source_metadata_)
1606
1607   def TryMerge(self, d):
1608     while d.avail() > 0:
1609       tt = d.getVarInt32()
1610       if tt == 10:
1611         length = d.getVarInt32()
1612         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
1613         d.skip(length)
1614         self.mutable_image().TryMerge(tmp)
1615         continue
1616       if tt == 18:
1617         self.set_source_metadata(d.getPrefixedString())
1618         continue
1619
1620
1621       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1622       d.skipData(tt)
1623
1624
1625   def __str__(self, prefix="", printElemNumber=0):
1626     res=""
1627     if self.has_image_:
1628       res+=prefix+"image <\n"
1629       res+=self.image_.__str__(prefix + "  ", printElemNumber)
1630       res+=prefix+">\n"
1631     if self.has_source_metadata_: res+=prefix+("source_metadata: %s\n" % self.DebugFormatString(self.source_metadata_))
1632     return res
1633
1634
1635   def _BuildTagLookupTable(sparse, maxtag, default=None):
1636     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1637
1638   kimage = 1
1639   ksource_metadata = 2
1640
1641   _TEXT = _BuildTagLookupTable({
1642     0: "ErrorCode",
1643     1: "image",
1644     2: "source_metadata",
1645   }, 2)
1646
1647   _TYPES = _BuildTagLookupTable({
1648     0: ProtocolBuffer.Encoder.NUMERIC,
1649     1: ProtocolBuffer.Encoder.STRING,
1650     2: ProtocolBuffer.Encoder.STRING,
1651   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
1652
1653
1654   _STYLE = """"""
1655   _STYLE_CONTENT_TYPE = """"""
1656   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesTransformResponse'
1657 class CompositeImageOptions(ProtocolBuffer.ProtocolMessage):
1658
1659
1660   TOP_LEFT     =    0
1661   TOP          =    1
1662   TOP_RIGHT    =    2
1663   LEFT         =    3
1664   CENTER       =    4
1665   RIGHT        =    5
1666   BOTTOM_LEFT  =    6
1667   BOTTOM       =    7
1668   BOTTOM_RIGHT =    8
1669
1670   _ANCHOR_NAMES = {
1671     0: "TOP_LEFT",
1672     1: "TOP",
1673     2: "TOP_RIGHT",
1674     3: "LEFT",
1675     4: "CENTER",
1676     5: "RIGHT",
1677     6: "BOTTOM_LEFT",
1678     7: "BOTTOM",
1679     8: "BOTTOM_RIGHT",
1680   }
1681
1682   def ANCHOR_Name(cls, x): return cls._ANCHOR_NAMES.get(x, "")
1683   ANCHOR_Name = classmethod(ANCHOR_Name)
1684
1685   has_source_index_ = 0
1686   source_index_ = 0
1687   has_x_offset_ = 0
1688   x_offset_ = 0
1689   has_y_offset_ = 0
1690   y_offset_ = 0
1691   has_opacity_ = 0
1692   opacity_ = 0.0
1693   has_anchor_ = 0
1694   anchor_ = 0
1695
1696   def __init__(self, contents=None):
1697     if contents is not None: self.MergeFromString(contents)
1698
1699   def source_index(self): return self.source_index_
1700
1701   def set_source_index(self, x):
1702     self.has_source_index_ = 1
1703     self.source_index_ = x
1704
1705   def clear_source_index(self):
1706     if self.has_source_index_:
1707       self.has_source_index_ = 0
1708       self.source_index_ = 0
1709
1710   def has_source_index(self): return self.has_source_index_
1711
1712   def x_offset(self): return self.x_offset_
1713
1714   def set_x_offset(self, x):
1715     self.has_x_offset_ = 1
1716     self.x_offset_ = x
1717
1718   def clear_x_offset(self):
1719     if self.has_x_offset_:
1720       self.has_x_offset_ = 0
1721       self.x_offset_ = 0
1722
1723   def has_x_offset(self): return self.has_x_offset_
1724
1725   def y_offset(self): return self.y_offset_
1726
1727   def set_y_offset(self, x):
1728     self.has_y_offset_ = 1
1729     self.y_offset_ = x
1730
1731   def clear_y_offset(self):
1732     if self.has_y_offset_:
1733       self.has_y_offset_ = 0
1734       self.y_offset_ = 0
1735
1736   def has_y_offset(self): return self.has_y_offset_
1737
1738   def opacity(self): return self.opacity_
1739
1740   def set_opacity(self, x):
1741     self.has_opacity_ = 1
1742     self.opacity_ = x
1743
1744   def clear_opacity(self):
1745     if self.has_opacity_:
1746       self.has_opacity_ = 0
1747       self.opacity_ = 0.0
1748
1749   def has_opacity(self): return self.has_opacity_
1750
1751   def anchor(self): return self.anchor_
1752
1753   def set_anchor(self, x):
1754     self.has_anchor_ = 1
1755     self.anchor_ = x
1756
1757   def clear_anchor(self):
1758     if self.has_anchor_:
1759       self.has_anchor_ = 0
1760       self.anchor_ = 0
1761
1762   def has_anchor(self): return self.has_anchor_
1763
1764
1765   def MergeFrom(self, x):
1766     assert x is not self
1767     if (x.has_source_index()): self.set_source_index(x.source_index())
1768     if (x.has_x_offset()): self.set_x_offset(x.x_offset())
1769     if (x.has_y_offset()): self.set_y_offset(x.y_offset())
1770     if (x.has_opacity()): self.set_opacity(x.opacity())
1771     if (x.has_anchor()): self.set_anchor(x.anchor())
1772
1773   def Equals(self, x):
1774     if x is self: return 1
1775     if self.has_source_index_ != x.has_source_index_: return 0
1776     if self.has_source_index_ and self.source_index_ != x.source_index_: return 0
1777     if self.has_x_offset_ != x.has_x_offset_: return 0
1778     if self.has_x_offset_ and self.x_offset_ != x.x_offset_: return 0
1779     if self.has_y_offset_ != x.has_y_offset_: return 0
1780     if self.has_y_offset_ and self.y_offset_ != x.y_offset_: return 0
1781     if self.has_opacity_ != x.has_opacity_: return 0
1782     if self.has_opacity_ and self.opacity_ != x.opacity_: return 0
1783     if self.has_anchor_ != x.has_anchor_: return 0
1784     if self.has_anchor_ and self.anchor_ != x.anchor_: return 0
1785     return 1
1786
1787   def IsInitialized(self, debug_strs=None):
1788     initialized = 1
1789     if (not self.has_source_index_):
1790       initialized = 0
1791       if debug_strs is not None:
1792         debug_strs.append('Required field: source_index not set.')
1793     if (not self.has_x_offset_):
1794       initialized = 0
1795       if debug_strs is not None:
1796         debug_strs.append('Required field: x_offset not set.')
1797     if (not self.has_y_offset_):
1798       initialized = 0
1799       if debug_strs is not None:
1800         debug_strs.append('Required field: y_offset not set.')
1801     if (not self.has_opacity_):
1802       initialized = 0
1803       if debug_strs is not None:
1804         debug_strs.append('Required field: opacity not set.')
1805     if (not self.has_anchor_):
1806       initialized = 0
1807       if debug_strs is not None:
1808         debug_strs.append('Required field: anchor not set.')
1809     return initialized
1810
1811   def ByteSize(self):
1812     n = 0
1813     n += self.lengthVarInt64(self.source_index_)
1814     n += self.lengthVarInt64(self.x_offset_)
1815     n += self.lengthVarInt64(self.y_offset_)
1816     n += self.lengthVarInt64(self.anchor_)
1817     return n + 9
1818
1819   def ByteSizePartial(self):
1820     n = 0
1821     if (self.has_source_index_):
1822       n += 1
1823       n += self.lengthVarInt64(self.source_index_)
1824     if (self.has_x_offset_):
1825       n += 1
1826       n += self.lengthVarInt64(self.x_offset_)
1827     if (self.has_y_offset_):
1828       n += 1
1829       n += self.lengthVarInt64(self.y_offset_)
1830     if (self.has_opacity_):
1831       n += 5
1832     if (self.has_anchor_):
1833       n += 1
1834       n += self.lengthVarInt64(self.anchor_)
1835     return n
1836
1837   def Clear(self):
1838     self.clear_source_index()
1839     self.clear_x_offset()
1840     self.clear_y_offset()
1841     self.clear_opacity()
1842     self.clear_anchor()
1843
1844   def OutputUnchecked(self, out):
1845     out.putVarInt32(8)
1846     out.putVarInt32(self.source_index_)
1847     out.putVarInt32(16)
1848     out.putVarInt32(self.x_offset_)
1849     out.putVarInt32(24)
1850     out.putVarInt32(self.y_offset_)
1851     out.putVarInt32(37)
1852     out.putFloat(self.opacity_)
1853     out.putVarInt32(40)
1854     out.putVarInt32(self.anchor_)
1855
1856   def OutputPartial(self, out):
1857     if (self.has_source_index_):
1858       out.putVarInt32(8)
1859       out.putVarInt32(self.source_index_)
1860     if (self.has_x_offset_):
1861       out.putVarInt32(16)
1862       out.putVarInt32(self.x_offset_)
1863     if (self.has_y_offset_):
1864       out.putVarInt32(24)
1865       out.putVarInt32(self.y_offset_)
1866     if (self.has_opacity_):
1867       out.putVarInt32(37)
1868       out.putFloat(self.opacity_)
1869     if (self.has_anchor_):
1870       out.putVarInt32(40)
1871       out.putVarInt32(self.anchor_)
1872
1873   def TryMerge(self, d):
1874     while d.avail() > 0:
1875       tt = d.getVarInt32()
1876       if tt == 8:
1877         self.set_source_index(d.getVarInt32())
1878         continue
1879       if tt == 16:
1880         self.set_x_offset(d.getVarInt32())
1881         continue
1882       if tt == 24:
1883         self.set_y_offset(d.getVarInt32())
1884         continue
1885       if tt == 37:
1886         self.set_opacity(d.getFloat())
1887         continue
1888       if tt == 40:
1889         self.set_anchor(d.getVarInt32())
1890         continue
1891
1892
1893       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
1894       d.skipData(tt)
1895
1896
1897   def __str__(self, prefix="", printElemNumber=0):
1898     res=""
1899     if self.has_source_index_: res+=prefix+("source_index: %s\n" % self.DebugFormatInt32(self.source_index_))
1900     if self.has_x_offset_: res+=prefix+("x_offset: %s\n" % self.DebugFormatInt32(self.x_offset_))
1901     if self.has_y_offset_: res+=prefix+("y_offset: %s\n" % self.DebugFormatInt32(self.y_offset_))
1902     if self.has_opacity_: res+=prefix+("opacity: %s\n" % self.DebugFormatFloat(self.opacity_))
1903     if self.has_anchor_: res+=prefix+("anchor: %s\n" % self.DebugFormatInt32(self.anchor_))
1904     return res
1905
1906
1907   def _BuildTagLookupTable(sparse, maxtag, default=None):
1908     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
1909
1910   ksource_index = 1
1911   kx_offset = 2
1912   ky_offset = 3
1913   kopacity = 4
1914   kanchor = 5
1915
1916   _TEXT = _BuildTagLookupTable({
1917     0: "ErrorCode",
1918     1: "source_index",
1919     2: "x_offset",
1920     3: "y_offset",
1921     4: "opacity",
1922     5: "anchor",
1923   }, 5)
1924
1925   _TYPES = _BuildTagLookupTable({
1926     0: ProtocolBuffer.Encoder.NUMERIC,
1927     1: ProtocolBuffer.Encoder.NUMERIC,
1928     2: ProtocolBuffer.Encoder.NUMERIC,
1929     3: ProtocolBuffer.Encoder.NUMERIC,
1930     4: ProtocolBuffer.Encoder.FLOAT,
1931     5: ProtocolBuffer.Encoder.NUMERIC,
1932   }, 5, ProtocolBuffer.Encoder.MAX_TYPE)
1933
1934
1935   _STYLE = """"""
1936   _STYLE_CONTENT_TYPE = """"""
1937   _PROTO_DESCRIPTOR_NAME = 'apphosting.CompositeImageOptions'
1938 class ImagesCanvas(ProtocolBuffer.ProtocolMessage):
1939   has_width_ = 0
1940   width_ = 0
1941   has_height_ = 0
1942   height_ = 0
1943   has_output_ = 0
1944   has_color_ = 0
1945   color_ = -1
1946
1947   def __init__(self, contents=None):
1948     self.output_ = OutputSettings()
1949     if contents is not None: self.MergeFromString(contents)
1950
1951   def width(self): return self.width_
1952
1953   def set_width(self, x):
1954     self.has_width_ = 1
1955     self.width_ = x
1956
1957   def clear_width(self):
1958     if self.has_width_:
1959       self.has_width_ = 0
1960       self.width_ = 0
1961
1962   def has_width(self): return self.has_width_
1963
1964   def height(self): return self.height_
1965
1966   def set_height(self, x):
1967     self.has_height_ = 1
1968     self.height_ = x
1969
1970   def clear_height(self):
1971     if self.has_height_:
1972       self.has_height_ = 0
1973       self.height_ = 0
1974
1975   def has_height(self): return self.has_height_
1976
1977   def output(self): return self.output_
1978
1979   def mutable_output(self): self.has_output_ = 1; return self.output_
1980
1981   def clear_output(self):self.has_output_ = 0; self.output_.Clear()
1982
1983   def has_output(self): return self.has_output_
1984
1985   def color(self): return self.color_
1986
1987   def set_color(self, x):
1988     self.has_color_ = 1
1989     self.color_ = x
1990
1991   def clear_color(self):
1992     if self.has_color_:
1993       self.has_color_ = 0
1994       self.color_ = -1
1995
1996   def has_color(self): return self.has_color_
1997
1998
1999   def MergeFrom(self, x):
2000     assert x is not self
2001     if (x.has_width()): self.set_width(x.width())
2002     if (x.has_height()): self.set_height(x.height())
2003     if (x.has_output()): self.mutable_output().MergeFrom(x.output())
2004     if (x.has_color()): self.set_color(x.color())
2005
2006   def Equals(self, x):
2007     if x is self: return 1
2008     if self.has_width_ != x.has_width_: return 0
2009     if self.has_width_ and self.width_ != x.width_: return 0
2010     if self.has_height_ != x.has_height_: return 0
2011     if self.has_height_ and self.height_ != x.height_: return 0
2012     if self.has_output_ != x.has_output_: return 0
2013     if self.has_output_ and self.output_ != x.output_: return 0
2014     if self.has_color_ != x.has_color_: return 0
2015     if self.has_color_ and self.color_ != x.color_: return 0
2016     return 1
2017
2018   def IsInitialized(self, debug_strs=None):
2019     initialized = 1
2020     if (not self.has_width_):
2021       initialized = 0
2022       if debug_strs is not None:
2023         debug_strs.append('Required field: width not set.')
2024     if (not self.has_height_):
2025       initialized = 0
2026       if debug_strs is not None:
2027         debug_strs.append('Required field: height not set.')
2028     if (not self.has_output_):
2029       initialized = 0
2030       if debug_strs is not None:
2031         debug_strs.append('Required field: output not set.')
2032     elif not self.output_.IsInitialized(debug_strs): initialized = 0
2033     return initialized
2034
2035   def ByteSize(self):
2036     n = 0
2037     n += self.lengthVarInt64(self.width_)
2038     n += self.lengthVarInt64(self.height_)
2039     n += self.lengthString(self.output_.ByteSize())
2040     if (self.has_color_): n += 1 + self.lengthVarInt64(self.color_)
2041     return n + 3
2042
2043   def ByteSizePartial(self):
2044     n = 0
2045     if (self.has_width_):
2046       n += 1
2047       n += self.lengthVarInt64(self.width_)
2048     if (self.has_height_):
2049       n += 1
2050       n += self.lengthVarInt64(self.height_)
2051     if (self.has_output_):
2052       n += 1
2053       n += self.lengthString(self.output_.ByteSizePartial())
2054     if (self.has_color_): n += 1 + self.lengthVarInt64(self.color_)
2055     return n
2056
2057   def Clear(self):
2058     self.clear_width()
2059     self.clear_height()
2060     self.clear_output()
2061     self.clear_color()
2062
2063   def OutputUnchecked(self, out):
2064     out.putVarInt32(8)
2065     out.putVarInt32(self.width_)
2066     out.putVarInt32(16)
2067     out.putVarInt32(self.height_)
2068     out.putVarInt32(26)
2069     out.putVarInt32(self.output_.ByteSize())
2070     self.output_.OutputUnchecked(out)
2071     if (self.has_color_):
2072       out.putVarInt32(32)
2073       out.putVarInt32(self.color_)
2074
2075   def OutputPartial(self, out):
2076     if (self.has_width_):
2077       out.putVarInt32(8)
2078       out.putVarInt32(self.width_)
2079     if (self.has_height_):
2080       out.putVarInt32(16)
2081       out.putVarInt32(self.height_)
2082     if (self.has_output_):
2083       out.putVarInt32(26)
2084       out.putVarInt32(self.output_.ByteSizePartial())
2085       self.output_.OutputPartial(out)
2086     if (self.has_color_):
2087       out.putVarInt32(32)
2088       out.putVarInt32(self.color_)
2089
2090   def TryMerge(self, d):
2091     while d.avail() > 0:
2092       tt = d.getVarInt32()
2093       if tt == 8:
2094         self.set_width(d.getVarInt32())
2095         continue
2096       if tt == 16:
2097         self.set_height(d.getVarInt32())
2098         continue
2099       if tt == 26:
2100         length = d.getVarInt32()
2101         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2102         d.skip(length)
2103         self.mutable_output().TryMerge(tmp)
2104         continue
2105       if tt == 32:
2106         self.set_color(d.getVarInt32())
2107         continue
2108
2109
2110       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2111       d.skipData(tt)
2112
2113
2114   def __str__(self, prefix="", printElemNumber=0):
2115     res=""
2116     if self.has_width_: res+=prefix+("width: %s\n" % self.DebugFormatInt32(self.width_))
2117     if self.has_height_: res+=prefix+("height: %s\n" % self.DebugFormatInt32(self.height_))
2118     if self.has_output_:
2119       res+=prefix+"output <\n"
2120       res+=self.output_.__str__(prefix + "  ", printElemNumber)
2121       res+=prefix+">\n"
2122     if self.has_color_: res+=prefix+("color: %s\n" % self.DebugFormatInt32(self.color_))
2123     return res
2124
2125
2126   def _BuildTagLookupTable(sparse, maxtag, default=None):
2127     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2128
2129   kwidth = 1
2130   kheight = 2
2131   koutput = 3
2132   kcolor = 4
2133
2134   _TEXT = _BuildTagLookupTable({
2135     0: "ErrorCode",
2136     1: "width",
2137     2: "height",
2138     3: "output",
2139     4: "color",
2140   }, 4)
2141
2142   _TYPES = _BuildTagLookupTable({
2143     0: ProtocolBuffer.Encoder.NUMERIC,
2144     1: ProtocolBuffer.Encoder.NUMERIC,
2145     2: ProtocolBuffer.Encoder.NUMERIC,
2146     3: ProtocolBuffer.Encoder.STRING,
2147     4: ProtocolBuffer.Encoder.NUMERIC,
2148   }, 4, ProtocolBuffer.Encoder.MAX_TYPE)
2149
2150
2151   _STYLE = """"""
2152   _STYLE_CONTENT_TYPE = """"""
2153   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesCanvas'
2154 class ImagesCompositeRequest(ProtocolBuffer.ProtocolMessage):
2155   has_canvas_ = 0
2156
2157   def __init__(self, contents=None):
2158     self.image_ = []
2159     self.options_ = []
2160     self.canvas_ = ImagesCanvas()
2161     if contents is not None: self.MergeFromString(contents)
2162
2163   def image_size(self): return len(self.image_)
2164   def image_list(self): return self.image_
2165
2166   def image(self, i):
2167     return self.image_[i]
2168
2169   def mutable_image(self, i):
2170     return self.image_[i]
2171
2172   def add_image(self):
2173     x = ImageData()
2174     self.image_.append(x)
2175     return x
2176
2177   def clear_image(self):
2178     self.image_ = []
2179   def options_size(self): return len(self.options_)
2180   def options_list(self): return self.options_
2181
2182   def options(self, i):
2183     return self.options_[i]
2184
2185   def mutable_options(self, i):
2186     return self.options_[i]
2187
2188   def add_options(self):
2189     x = CompositeImageOptions()
2190     self.options_.append(x)
2191     return x
2192
2193   def clear_options(self):
2194     self.options_ = []
2195   def canvas(self): return self.canvas_
2196
2197   def mutable_canvas(self): self.has_canvas_ = 1; return self.canvas_
2198
2199   def clear_canvas(self):self.has_canvas_ = 0; self.canvas_.Clear()
2200
2201   def has_canvas(self): return self.has_canvas_
2202
2203
2204   def MergeFrom(self, x):
2205     assert x is not self
2206     for i in xrange(x.image_size()): self.add_image().CopyFrom(x.image(i))
2207     for i in xrange(x.options_size()): self.add_options().CopyFrom(x.options(i))
2208     if (x.has_canvas()): self.mutable_canvas().MergeFrom(x.canvas())
2209
2210   def Equals(self, x):
2211     if x is self: return 1
2212     if len(self.image_) != len(x.image_): return 0
2213     for e1, e2 in zip(self.image_, x.image_):
2214       if e1 != e2: return 0
2215     if len(self.options_) != len(x.options_): return 0
2216     for e1, e2 in zip(self.options_, x.options_):
2217       if e1 != e2: return 0
2218     if self.has_canvas_ != x.has_canvas_: return 0
2219     if self.has_canvas_ and self.canvas_ != x.canvas_: return 0
2220     return 1
2221
2222   def IsInitialized(self, debug_strs=None):
2223     initialized = 1
2224     for p in self.image_:
2225       if not p.IsInitialized(debug_strs): initialized=0
2226     for p in self.options_:
2227       if not p.IsInitialized(debug_strs): initialized=0
2228     if (not self.has_canvas_):
2229       initialized = 0
2230       if debug_strs is not None:
2231         debug_strs.append('Required field: canvas not set.')
2232     elif not self.canvas_.IsInitialized(debug_strs): initialized = 0
2233     return initialized
2234
2235   def ByteSize(self):
2236     n = 0
2237     n += 1 * len(self.image_)
2238     for i in xrange(len(self.image_)): n += self.lengthString(self.image_[i].ByteSize())
2239     n += 1 * len(self.options_)
2240     for i in xrange(len(self.options_)): n += self.lengthString(self.options_[i].ByteSize())
2241     n += self.lengthString(self.canvas_.ByteSize())
2242     return n + 1
2243
2244   def ByteSizePartial(self):
2245     n = 0
2246     n += 1 * len(self.image_)
2247     for i in xrange(len(self.image_)): n += self.lengthString(self.image_[i].ByteSizePartial())
2248     n += 1 * len(self.options_)
2249     for i in xrange(len(self.options_)): n += self.lengthString(self.options_[i].ByteSizePartial())
2250     if (self.has_canvas_):
2251       n += 1
2252       n += self.lengthString(self.canvas_.ByteSizePartial())
2253     return n
2254
2255   def Clear(self):
2256     self.clear_image()
2257     self.clear_options()
2258     self.clear_canvas()
2259
2260   def OutputUnchecked(self, out):
2261     for i in xrange(len(self.image_)):
2262       out.putVarInt32(10)
2263       out.putVarInt32(self.image_[i].ByteSize())
2264       self.image_[i].OutputUnchecked(out)
2265     for i in xrange(len(self.options_)):
2266       out.putVarInt32(18)
2267       out.putVarInt32(self.options_[i].ByteSize())
2268       self.options_[i].OutputUnchecked(out)
2269     out.putVarInt32(26)
2270     out.putVarInt32(self.canvas_.ByteSize())
2271     self.canvas_.OutputUnchecked(out)
2272
2273   def OutputPartial(self, out):
2274     for i in xrange(len(self.image_)):
2275       out.putVarInt32(10)
2276       out.putVarInt32(self.image_[i].ByteSizePartial())
2277       self.image_[i].OutputPartial(out)
2278     for i in xrange(len(self.options_)):
2279       out.putVarInt32(18)
2280       out.putVarInt32(self.options_[i].ByteSizePartial())
2281       self.options_[i].OutputPartial(out)
2282     if (self.has_canvas_):
2283       out.putVarInt32(26)
2284       out.putVarInt32(self.canvas_.ByteSizePartial())
2285       self.canvas_.OutputPartial(out)
2286
2287   def TryMerge(self, d):
2288     while d.avail() > 0:
2289       tt = d.getVarInt32()
2290       if tt == 10:
2291         length = d.getVarInt32()
2292         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2293         d.skip(length)
2294         self.add_image().TryMerge(tmp)
2295         continue
2296       if tt == 18:
2297         length = d.getVarInt32()
2298         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2299         d.skip(length)
2300         self.add_options().TryMerge(tmp)
2301         continue
2302       if tt == 26:
2303         length = d.getVarInt32()
2304         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2305         d.skip(length)
2306         self.mutable_canvas().TryMerge(tmp)
2307         continue
2308
2309
2310       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2311       d.skipData(tt)
2312
2313
2314   def __str__(self, prefix="", printElemNumber=0):
2315     res=""
2316     cnt=0
2317     for e in self.image_:
2318       elm=""
2319       if printElemNumber: elm="(%d)" % cnt
2320       res+=prefix+("image%s <\n" % elm)
2321       res+=e.__str__(prefix + "  ", printElemNumber)
2322       res+=prefix+">\n"
2323       cnt+=1
2324     cnt=0
2325     for e in self.options_:
2326       elm=""
2327       if printElemNumber: elm="(%d)" % cnt
2328       res+=prefix+("options%s <\n" % elm)
2329       res+=e.__str__(prefix + "  ", printElemNumber)
2330       res+=prefix+">\n"
2331       cnt+=1
2332     if self.has_canvas_:
2333       res+=prefix+"canvas <\n"
2334       res+=self.canvas_.__str__(prefix + "  ", printElemNumber)
2335       res+=prefix+">\n"
2336     return res
2337
2338
2339   def _BuildTagLookupTable(sparse, maxtag, default=None):
2340     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2341
2342   kimage = 1
2343   koptions = 2
2344   kcanvas = 3
2345
2346   _TEXT = _BuildTagLookupTable({
2347     0: "ErrorCode",
2348     1: "image",
2349     2: "options",
2350     3: "canvas",
2351   }, 3)
2352
2353   _TYPES = _BuildTagLookupTable({
2354     0: ProtocolBuffer.Encoder.NUMERIC,
2355     1: ProtocolBuffer.Encoder.STRING,
2356     2: ProtocolBuffer.Encoder.STRING,
2357     3: ProtocolBuffer.Encoder.STRING,
2358   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
2359
2360
2361   _STYLE = """"""
2362   _STYLE_CONTENT_TYPE = """"""
2363   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesCompositeRequest'
2364 class ImagesCompositeResponse(ProtocolBuffer.ProtocolMessage):
2365   has_image_ = 0
2366
2367   def __init__(self, contents=None):
2368     self.image_ = ImageData()
2369     if contents is not None: self.MergeFromString(contents)
2370
2371   def image(self): return self.image_
2372
2373   def mutable_image(self): self.has_image_ = 1; return self.image_
2374
2375   def clear_image(self):self.has_image_ = 0; self.image_.Clear()
2376
2377   def has_image(self): return self.has_image_
2378
2379
2380   def MergeFrom(self, x):
2381     assert x is not self
2382     if (x.has_image()): self.mutable_image().MergeFrom(x.image())
2383
2384   def Equals(self, x):
2385     if x is self: return 1
2386     if self.has_image_ != x.has_image_: return 0
2387     if self.has_image_ and self.image_ != x.image_: return 0
2388     return 1
2389
2390   def IsInitialized(self, debug_strs=None):
2391     initialized = 1
2392     if (not self.has_image_):
2393       initialized = 0
2394       if debug_strs is not None:
2395         debug_strs.append('Required field: image not set.')
2396     elif not self.image_.IsInitialized(debug_strs): initialized = 0
2397     return initialized
2398
2399   def ByteSize(self):
2400     n = 0
2401     n += self.lengthString(self.image_.ByteSize())
2402     return n + 1
2403
2404   def ByteSizePartial(self):
2405     n = 0
2406     if (self.has_image_):
2407       n += 1
2408       n += self.lengthString(self.image_.ByteSizePartial())
2409     return n
2410
2411   def Clear(self):
2412     self.clear_image()
2413
2414   def OutputUnchecked(self, out):
2415     out.putVarInt32(10)
2416     out.putVarInt32(self.image_.ByteSize())
2417     self.image_.OutputUnchecked(out)
2418
2419   def OutputPartial(self, out):
2420     if (self.has_image_):
2421       out.putVarInt32(10)
2422       out.putVarInt32(self.image_.ByteSizePartial())
2423       self.image_.OutputPartial(out)
2424
2425   def TryMerge(self, d):
2426     while d.avail() > 0:
2427       tt = d.getVarInt32()
2428       if tt == 10:
2429         length = d.getVarInt32()
2430         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2431         d.skip(length)
2432         self.mutable_image().TryMerge(tmp)
2433         continue
2434
2435
2436       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2437       d.skipData(tt)
2438
2439
2440   def __str__(self, prefix="", printElemNumber=0):
2441     res=""
2442     if self.has_image_:
2443       res+=prefix+"image <\n"
2444       res+=self.image_.__str__(prefix + "  ", printElemNumber)
2445       res+=prefix+">\n"
2446     return res
2447
2448
2449   def _BuildTagLookupTable(sparse, maxtag, default=None):
2450     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2451
2452   kimage = 1
2453
2454   _TEXT = _BuildTagLookupTable({
2455     0: "ErrorCode",
2456     1: "image",
2457   }, 1)
2458
2459   _TYPES = _BuildTagLookupTable({
2460     0: ProtocolBuffer.Encoder.NUMERIC,
2461     1: ProtocolBuffer.Encoder.STRING,
2462   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
2463
2464
2465   _STYLE = """"""
2466   _STYLE_CONTENT_TYPE = """"""
2467   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesCompositeResponse'
2468 class ImagesHistogramRequest(ProtocolBuffer.ProtocolMessage):
2469   has_image_ = 0
2470
2471   def __init__(self, contents=None):
2472     self.image_ = ImageData()
2473     if contents is not None: self.MergeFromString(contents)
2474
2475   def image(self): return self.image_
2476
2477   def mutable_image(self): self.has_image_ = 1; return self.image_
2478
2479   def clear_image(self):self.has_image_ = 0; self.image_.Clear()
2480
2481   def has_image(self): return self.has_image_
2482
2483
2484   def MergeFrom(self, x):
2485     assert x is not self
2486     if (x.has_image()): self.mutable_image().MergeFrom(x.image())
2487
2488   def Equals(self, x):
2489     if x is self: return 1
2490     if self.has_image_ != x.has_image_: return 0
2491     if self.has_image_ and self.image_ != x.image_: return 0
2492     return 1
2493
2494   def IsInitialized(self, debug_strs=None):
2495     initialized = 1
2496     if (not self.has_image_):
2497       initialized = 0
2498       if debug_strs is not None:
2499         debug_strs.append('Required field: image not set.')
2500     elif not self.image_.IsInitialized(debug_strs): initialized = 0
2501     return initialized
2502
2503   def ByteSize(self):
2504     n = 0
2505     n += self.lengthString(self.image_.ByteSize())
2506     return n + 1
2507
2508   def ByteSizePartial(self):
2509     n = 0
2510     if (self.has_image_):
2511       n += 1
2512       n += self.lengthString(self.image_.ByteSizePartial())
2513     return n
2514
2515   def Clear(self):
2516     self.clear_image()
2517
2518   def OutputUnchecked(self, out):
2519     out.putVarInt32(10)
2520     out.putVarInt32(self.image_.ByteSize())
2521     self.image_.OutputUnchecked(out)
2522
2523   def OutputPartial(self, out):
2524     if (self.has_image_):
2525       out.putVarInt32(10)
2526       out.putVarInt32(self.image_.ByteSizePartial())
2527       self.image_.OutputPartial(out)
2528
2529   def TryMerge(self, d):
2530     while d.avail() > 0:
2531       tt = d.getVarInt32()
2532       if tt == 10:
2533         length = d.getVarInt32()
2534         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2535         d.skip(length)
2536         self.mutable_image().TryMerge(tmp)
2537         continue
2538
2539
2540       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2541       d.skipData(tt)
2542
2543
2544   def __str__(self, prefix="", printElemNumber=0):
2545     res=""
2546     if self.has_image_:
2547       res+=prefix+"image <\n"
2548       res+=self.image_.__str__(prefix + "  ", printElemNumber)
2549       res+=prefix+">\n"
2550     return res
2551
2552
2553   def _BuildTagLookupTable(sparse, maxtag, default=None):
2554     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2555
2556   kimage = 1
2557
2558   _TEXT = _BuildTagLookupTable({
2559     0: "ErrorCode",
2560     1: "image",
2561   }, 1)
2562
2563   _TYPES = _BuildTagLookupTable({
2564     0: ProtocolBuffer.Encoder.NUMERIC,
2565     1: ProtocolBuffer.Encoder.STRING,
2566   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
2567
2568
2569   _STYLE = """"""
2570   _STYLE_CONTENT_TYPE = """"""
2571   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesHistogramRequest'
2572 class ImagesHistogram(ProtocolBuffer.ProtocolMessage):
2573
2574   def __init__(self, contents=None):
2575     self.red_ = []
2576     self.green_ = []
2577     self.blue_ = []
2578     if contents is not None: self.MergeFromString(contents)
2579
2580   def red_size(self): return len(self.red_)
2581   def red_list(self): return self.red_
2582
2583   def red(self, i):
2584     return self.red_[i]
2585
2586   def set_red(self, i, x):
2587     self.red_[i] = x
2588
2589   def add_red(self, x):
2590     self.red_.append(x)
2591
2592   def clear_red(self):
2593     self.red_ = []
2594
2595   def green_size(self): return len(self.green_)
2596   def green_list(self): return self.green_
2597
2598   def green(self, i):
2599     return self.green_[i]
2600
2601   def set_green(self, i, x):
2602     self.green_[i] = x
2603
2604   def add_green(self, x):
2605     self.green_.append(x)
2606
2607   def clear_green(self):
2608     self.green_ = []
2609
2610   def blue_size(self): return len(self.blue_)
2611   def blue_list(self): return self.blue_
2612
2613   def blue(self, i):
2614     return self.blue_[i]
2615
2616   def set_blue(self, i, x):
2617     self.blue_[i] = x
2618
2619   def add_blue(self, x):
2620     self.blue_.append(x)
2621
2622   def clear_blue(self):
2623     self.blue_ = []
2624
2625
2626   def MergeFrom(self, x):
2627     assert x is not self
2628     for i in xrange(x.red_size()): self.add_red(x.red(i))
2629     for i in xrange(x.green_size()): self.add_green(x.green(i))
2630     for i in xrange(x.blue_size()): self.add_blue(x.blue(i))
2631
2632   def Equals(self, x):
2633     if x is self: return 1
2634     if len(self.red_) != len(x.red_): return 0
2635     for e1, e2 in zip(self.red_, x.red_):
2636       if e1 != e2: return 0
2637     if len(self.green_) != len(x.green_): return 0
2638     for e1, e2 in zip(self.green_, x.green_):
2639       if e1 != e2: return 0
2640     if len(self.blue_) != len(x.blue_): return 0
2641     for e1, e2 in zip(self.blue_, x.blue_):
2642       if e1 != e2: return 0
2643     return 1
2644
2645   def IsInitialized(self, debug_strs=None):
2646     initialized = 1
2647     return initialized
2648
2649   def ByteSize(self):
2650     n = 0
2651     n += 1 * len(self.red_)
2652     for i in xrange(len(self.red_)): n += self.lengthVarInt64(self.red_[i])
2653     n += 1 * len(self.green_)
2654     for i in xrange(len(self.green_)): n += self.lengthVarInt64(self.green_[i])
2655     n += 1 * len(self.blue_)
2656     for i in xrange(len(self.blue_)): n += self.lengthVarInt64(self.blue_[i])
2657     return n
2658
2659   def ByteSizePartial(self):
2660     n = 0
2661     n += 1 * len(self.red_)
2662     for i in xrange(len(self.red_)): n += self.lengthVarInt64(self.red_[i])
2663     n += 1 * len(self.green_)
2664     for i in xrange(len(self.green_)): n += self.lengthVarInt64(self.green_[i])
2665     n += 1 * len(self.blue_)
2666     for i in xrange(len(self.blue_)): n += self.lengthVarInt64(self.blue_[i])
2667     return n
2668
2669   def Clear(self):
2670     self.clear_red()
2671     self.clear_green()
2672     self.clear_blue()
2673
2674   def OutputUnchecked(self, out):
2675     for i in xrange(len(self.red_)):
2676       out.putVarInt32(8)
2677       out.putVarInt32(self.red_[i])
2678     for i in xrange(len(self.green_)):
2679       out.putVarInt32(16)
2680       out.putVarInt32(self.green_[i])
2681     for i in xrange(len(self.blue_)):
2682       out.putVarInt32(24)
2683       out.putVarInt32(self.blue_[i])
2684
2685   def OutputPartial(self, out):
2686     for i in xrange(len(self.red_)):
2687       out.putVarInt32(8)
2688       out.putVarInt32(self.red_[i])
2689     for i in xrange(len(self.green_)):
2690       out.putVarInt32(16)
2691       out.putVarInt32(self.green_[i])
2692     for i in xrange(len(self.blue_)):
2693       out.putVarInt32(24)
2694       out.putVarInt32(self.blue_[i])
2695
2696   def TryMerge(self, d):
2697     while d.avail() > 0:
2698       tt = d.getVarInt32()
2699       if tt == 8:
2700         self.add_red(d.getVarInt32())
2701         continue
2702       if tt == 16:
2703         self.add_green(d.getVarInt32())
2704         continue
2705       if tt == 24:
2706         self.add_blue(d.getVarInt32())
2707         continue
2708
2709
2710       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2711       d.skipData(tt)
2712
2713
2714   def __str__(self, prefix="", printElemNumber=0):
2715     res=""
2716     cnt=0
2717     for e in self.red_:
2718       elm=""
2719       if printElemNumber: elm="(%d)" % cnt
2720       res+=prefix+("red%s: %s\n" % (elm, self.DebugFormatInt32(e)))
2721       cnt+=1
2722     cnt=0
2723     for e in self.green_:
2724       elm=""
2725       if printElemNumber: elm="(%d)" % cnt
2726       res+=prefix+("green%s: %s\n" % (elm, self.DebugFormatInt32(e)))
2727       cnt+=1
2728     cnt=0
2729     for e in self.blue_:
2730       elm=""
2731       if printElemNumber: elm="(%d)" % cnt
2732       res+=prefix+("blue%s: %s\n" % (elm, self.DebugFormatInt32(e)))
2733       cnt+=1
2734     return res
2735
2736
2737   def _BuildTagLookupTable(sparse, maxtag, default=None):
2738     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2739
2740   kred = 1
2741   kgreen = 2
2742   kblue = 3
2743
2744   _TEXT = _BuildTagLookupTable({
2745     0: "ErrorCode",
2746     1: "red",
2747     2: "green",
2748     3: "blue",
2749   }, 3)
2750
2751   _TYPES = _BuildTagLookupTable({
2752     0: ProtocolBuffer.Encoder.NUMERIC,
2753     1: ProtocolBuffer.Encoder.NUMERIC,
2754     2: ProtocolBuffer.Encoder.NUMERIC,
2755     3: ProtocolBuffer.Encoder.NUMERIC,
2756   }, 3, ProtocolBuffer.Encoder.MAX_TYPE)
2757
2758
2759   _STYLE = """"""
2760   _STYLE_CONTENT_TYPE = """"""
2761   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesHistogram'
2762 class ImagesHistogramResponse(ProtocolBuffer.ProtocolMessage):
2763   has_histogram_ = 0
2764
2765   def __init__(self, contents=None):
2766     self.histogram_ = ImagesHistogram()
2767     if contents is not None: self.MergeFromString(contents)
2768
2769   def histogram(self): return self.histogram_
2770
2771   def mutable_histogram(self): self.has_histogram_ = 1; return self.histogram_
2772
2773   def clear_histogram(self):self.has_histogram_ = 0; self.histogram_.Clear()
2774
2775   def has_histogram(self): return self.has_histogram_
2776
2777
2778   def MergeFrom(self, x):
2779     assert x is not self
2780     if (x.has_histogram()): self.mutable_histogram().MergeFrom(x.histogram())
2781
2782   def Equals(self, x):
2783     if x is self: return 1
2784     if self.has_histogram_ != x.has_histogram_: return 0
2785     if self.has_histogram_ and self.histogram_ != x.histogram_: return 0
2786     return 1
2787
2788   def IsInitialized(self, debug_strs=None):
2789     initialized = 1
2790     if (not self.has_histogram_):
2791       initialized = 0
2792       if debug_strs is not None:
2793         debug_strs.append('Required field: histogram not set.')
2794     elif not self.histogram_.IsInitialized(debug_strs): initialized = 0
2795     return initialized
2796
2797   def ByteSize(self):
2798     n = 0
2799     n += self.lengthString(self.histogram_.ByteSize())
2800     return n + 1
2801
2802   def ByteSizePartial(self):
2803     n = 0
2804     if (self.has_histogram_):
2805       n += 1
2806       n += self.lengthString(self.histogram_.ByteSizePartial())
2807     return n
2808
2809   def Clear(self):
2810     self.clear_histogram()
2811
2812   def OutputUnchecked(self, out):
2813     out.putVarInt32(10)
2814     out.putVarInt32(self.histogram_.ByteSize())
2815     self.histogram_.OutputUnchecked(out)
2816
2817   def OutputPartial(self, out):
2818     if (self.has_histogram_):
2819       out.putVarInt32(10)
2820       out.putVarInt32(self.histogram_.ByteSizePartial())
2821       self.histogram_.OutputPartial(out)
2822
2823   def TryMerge(self, d):
2824     while d.avail() > 0:
2825       tt = d.getVarInt32()
2826       if tt == 10:
2827         length = d.getVarInt32()
2828         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)
2829         d.skip(length)
2830         self.mutable_histogram().TryMerge(tmp)
2831         continue
2832
2833
2834       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2835       d.skipData(tt)
2836
2837
2838   def __str__(self, prefix="", printElemNumber=0):
2839     res=""
2840     if self.has_histogram_:
2841       res+=prefix+"histogram <\n"
2842       res+=self.histogram_.__str__(prefix + "  ", printElemNumber)
2843       res+=prefix+">\n"
2844     return res
2845
2846
2847   def _BuildTagLookupTable(sparse, maxtag, default=None):
2848     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2849
2850   khistogram = 1
2851
2852   _TEXT = _BuildTagLookupTable({
2853     0: "ErrorCode",
2854     1: "histogram",
2855   }, 1)
2856
2857   _TYPES = _BuildTagLookupTable({
2858     0: ProtocolBuffer.Encoder.NUMERIC,
2859     1: ProtocolBuffer.Encoder.STRING,
2860   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
2861
2862
2863   _STYLE = """"""
2864   _STYLE_CONTENT_TYPE = """"""
2865   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesHistogramResponse'
2866 class ImagesGetUrlBaseRequest(ProtocolBuffer.ProtocolMessage):
2867   has_blob_key_ = 0
2868   blob_key_ = ""
2869   has_create_secure_url_ = 0
2870   create_secure_url_ = 0
2871
2872   def __init__(self, contents=None):
2873     if contents is not None: self.MergeFromString(contents)
2874
2875   def blob_key(self): return self.blob_key_
2876
2877   def set_blob_key(self, x):
2878     self.has_blob_key_ = 1
2879     self.blob_key_ = x
2880
2881   def clear_blob_key(self):
2882     if self.has_blob_key_:
2883       self.has_blob_key_ = 0
2884       self.blob_key_ = ""
2885
2886   def has_blob_key(self): return self.has_blob_key_
2887
2888   def create_secure_url(self): return self.create_secure_url_
2889
2890   def set_create_secure_url(self, x):
2891     self.has_create_secure_url_ = 1
2892     self.create_secure_url_ = x
2893
2894   def clear_create_secure_url(self):
2895     if self.has_create_secure_url_:
2896       self.has_create_secure_url_ = 0
2897       self.create_secure_url_ = 0
2898
2899   def has_create_secure_url(self): return self.has_create_secure_url_
2900
2901
2902   def MergeFrom(self, x):
2903     assert x is not self
2904     if (x.has_blob_key()): self.set_blob_key(x.blob_key())
2905     if (x.has_create_secure_url()): self.set_create_secure_url(x.create_secure_url())
2906
2907   def Equals(self, x):
2908     if x is self: return 1
2909     if self.has_blob_key_ != x.has_blob_key_: return 0
2910     if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0
2911     if self.has_create_secure_url_ != x.has_create_secure_url_: return 0
2912     if self.has_create_secure_url_ and self.create_secure_url_ != x.create_secure_url_: return 0
2913     return 1
2914
2915   def IsInitialized(self, debug_strs=None):
2916     initialized = 1
2917     if (not self.has_blob_key_):
2918       initialized = 0
2919       if debug_strs is not None:
2920         debug_strs.append('Required field: blob_key not set.')
2921     return initialized
2922
2923   def ByteSize(self):
2924     n = 0
2925     n += self.lengthString(len(self.blob_key_))
2926     if (self.has_create_secure_url_): n += 2
2927     return n + 1
2928
2929   def ByteSizePartial(self):
2930     n = 0
2931     if (self.has_blob_key_):
2932       n += 1
2933       n += self.lengthString(len(self.blob_key_))
2934     if (self.has_create_secure_url_): n += 2
2935     return n
2936
2937   def Clear(self):
2938     self.clear_blob_key()
2939     self.clear_create_secure_url()
2940
2941   def OutputUnchecked(self, out):
2942     out.putVarInt32(10)
2943     out.putPrefixedString(self.blob_key_)
2944     if (self.has_create_secure_url_):
2945       out.putVarInt32(16)
2946       out.putBoolean(self.create_secure_url_)
2947
2948   def OutputPartial(self, out):
2949     if (self.has_blob_key_):
2950       out.putVarInt32(10)
2951       out.putPrefixedString(self.blob_key_)
2952     if (self.has_create_secure_url_):
2953       out.putVarInt32(16)
2954       out.putBoolean(self.create_secure_url_)
2955
2956   def TryMerge(self, d):
2957     while d.avail() > 0:
2958       tt = d.getVarInt32()
2959       if tt == 10:
2960         self.set_blob_key(d.getPrefixedString())
2961         continue
2962       if tt == 16:
2963         self.set_create_secure_url(d.getBoolean())
2964         continue
2965
2966
2967       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
2968       d.skipData(tt)
2969
2970
2971   def __str__(self, prefix="", printElemNumber=0):
2972     res=""
2973     if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_))
2974     if self.has_create_secure_url_: res+=prefix+("create_secure_url: %s\n" % self.DebugFormatBool(self.create_secure_url_))
2975     return res
2976
2977
2978   def _BuildTagLookupTable(sparse, maxtag, default=None):
2979     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
2980
2981   kblob_key = 1
2982   kcreate_secure_url = 2
2983
2984   _TEXT = _BuildTagLookupTable({
2985     0: "ErrorCode",
2986     1: "blob_key",
2987     2: "create_secure_url",
2988   }, 2)
2989
2990   _TYPES = _BuildTagLookupTable({
2991     0: ProtocolBuffer.Encoder.NUMERIC,
2992     1: ProtocolBuffer.Encoder.STRING,
2993     2: ProtocolBuffer.Encoder.NUMERIC,
2994   }, 2, ProtocolBuffer.Encoder.MAX_TYPE)
2995
2996
2997   _STYLE = """"""
2998   _STYLE_CONTENT_TYPE = """"""
2999   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesGetUrlBaseRequest'
3000 class ImagesGetUrlBaseResponse(ProtocolBuffer.ProtocolMessage):
3001   has_url_ = 0
3002   url_ = ""
3003
3004   def __init__(self, contents=None):
3005     if contents is not None: self.MergeFromString(contents)
3006
3007   def url(self): return self.url_
3008
3009   def set_url(self, x):
3010     self.has_url_ = 1
3011     self.url_ = x
3012
3013   def clear_url(self):
3014     if self.has_url_:
3015       self.has_url_ = 0
3016       self.url_ = ""
3017
3018   def has_url(self): return self.has_url_
3019
3020
3021   def MergeFrom(self, x):
3022     assert x is not self
3023     if (x.has_url()): self.set_url(x.url())
3024
3025   def Equals(self, x):
3026     if x is self: return 1
3027     if self.has_url_ != x.has_url_: return 0
3028     if self.has_url_ and self.url_ != x.url_: return 0
3029     return 1
3030
3031   def IsInitialized(self, debug_strs=None):
3032     initialized = 1
3033     if (not self.has_url_):
3034       initialized = 0
3035       if debug_strs is not None:
3036         debug_strs.append('Required field: url not set.')
3037     return initialized
3038
3039   def ByteSize(self):
3040     n = 0
3041     n += self.lengthString(len(self.url_))
3042     return n + 1
3043
3044   def ByteSizePartial(self):
3045     n = 0
3046     if (self.has_url_):
3047       n += 1
3048       n += self.lengthString(len(self.url_))
3049     return n
3050
3051   def Clear(self):
3052     self.clear_url()
3053
3054   def OutputUnchecked(self, out):
3055     out.putVarInt32(10)
3056     out.putPrefixedString(self.url_)
3057
3058   def OutputPartial(self, out):
3059     if (self.has_url_):
3060       out.putVarInt32(10)
3061       out.putPrefixedString(self.url_)
3062
3063   def TryMerge(self, d):
3064     while d.avail() > 0:
3065       tt = d.getVarInt32()
3066       if tt == 10:
3067         self.set_url(d.getPrefixedString())
3068         continue
3069
3070
3071       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3072       d.skipData(tt)
3073
3074
3075   def __str__(self, prefix="", printElemNumber=0):
3076     res=""
3077     if self.has_url_: res+=prefix+("url: %s\n" % self.DebugFormatString(self.url_))
3078     return res
3079
3080
3081   def _BuildTagLookupTable(sparse, maxtag, default=None):
3082     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3083
3084   kurl = 1
3085
3086   _TEXT = _BuildTagLookupTable({
3087     0: "ErrorCode",
3088     1: "url",
3089   }, 1)
3090
3091   _TYPES = _BuildTagLookupTable({
3092     0: ProtocolBuffer.Encoder.NUMERIC,
3093     1: ProtocolBuffer.Encoder.STRING,
3094   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
3095
3096
3097   _STYLE = """"""
3098   _STYLE_CONTENT_TYPE = """"""
3099   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesGetUrlBaseResponse'
3100 class ImagesDeleteUrlBaseRequest(ProtocolBuffer.ProtocolMessage):
3101   has_blob_key_ = 0
3102   blob_key_ = ""
3103
3104   def __init__(self, contents=None):
3105     if contents is not None: self.MergeFromString(contents)
3106
3107   def blob_key(self): return self.blob_key_
3108
3109   def set_blob_key(self, x):
3110     self.has_blob_key_ = 1
3111     self.blob_key_ = x
3112
3113   def clear_blob_key(self):
3114     if self.has_blob_key_:
3115       self.has_blob_key_ = 0
3116       self.blob_key_ = ""
3117
3118   def has_blob_key(self): return self.has_blob_key_
3119
3120
3121   def MergeFrom(self, x):
3122     assert x is not self
3123     if (x.has_blob_key()): self.set_blob_key(x.blob_key())
3124
3125   def Equals(self, x):
3126     if x is self: return 1
3127     if self.has_blob_key_ != x.has_blob_key_: return 0
3128     if self.has_blob_key_ and self.blob_key_ != x.blob_key_: return 0
3129     return 1
3130
3131   def IsInitialized(self, debug_strs=None):
3132     initialized = 1
3133     if (not self.has_blob_key_):
3134       initialized = 0
3135       if debug_strs is not None:
3136         debug_strs.append('Required field: blob_key not set.')
3137     return initialized
3138
3139   def ByteSize(self):
3140     n = 0
3141     n += self.lengthString(len(self.blob_key_))
3142     return n + 1
3143
3144   def ByteSizePartial(self):
3145     n = 0
3146     if (self.has_blob_key_):
3147       n += 1
3148       n += self.lengthString(len(self.blob_key_))
3149     return n
3150
3151   def Clear(self):
3152     self.clear_blob_key()
3153
3154   def OutputUnchecked(self, out):
3155     out.putVarInt32(10)
3156     out.putPrefixedString(self.blob_key_)
3157
3158   def OutputPartial(self, out):
3159     if (self.has_blob_key_):
3160       out.putVarInt32(10)
3161       out.putPrefixedString(self.blob_key_)
3162
3163   def TryMerge(self, d):
3164     while d.avail() > 0:
3165       tt = d.getVarInt32()
3166       if tt == 10:
3167         self.set_blob_key(d.getPrefixedString())
3168         continue
3169
3170
3171       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3172       d.skipData(tt)
3173
3174
3175   def __str__(self, prefix="", printElemNumber=0):
3176     res=""
3177     if self.has_blob_key_: res+=prefix+("blob_key: %s\n" % self.DebugFormatString(self.blob_key_))
3178     return res
3179
3180
3181   def _BuildTagLookupTable(sparse, maxtag, default=None):
3182     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3183
3184   kblob_key = 1
3185
3186   _TEXT = _BuildTagLookupTable({
3187     0: "ErrorCode",
3188     1: "blob_key",
3189   }, 1)
3190
3191   _TYPES = _BuildTagLookupTable({
3192     0: ProtocolBuffer.Encoder.NUMERIC,
3193     1: ProtocolBuffer.Encoder.STRING,
3194   }, 1, ProtocolBuffer.Encoder.MAX_TYPE)
3195
3196
3197   _STYLE = """"""
3198   _STYLE_CONTENT_TYPE = """"""
3199   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesDeleteUrlBaseRequest'
3200 class ImagesDeleteUrlBaseResponse(ProtocolBuffer.ProtocolMessage):
3201
3202   def __init__(self, contents=None):
3203     pass
3204     if contents is not None: self.MergeFromString(contents)
3205
3206
3207   def MergeFrom(self, x):
3208     assert x is not self
3209
3210   def Equals(self, x):
3211     if x is self: return 1
3212     return 1
3213
3214   def IsInitialized(self, debug_strs=None):
3215     initialized = 1
3216     return initialized
3217
3218   def ByteSize(self):
3219     n = 0
3220     return n
3221
3222   def ByteSizePartial(self):
3223     n = 0
3224     return n
3225
3226   def Clear(self):
3227     pass
3228
3229   def OutputUnchecked(self, out):
3230     pass
3231
3232   def OutputPartial(self, out):
3233     pass
3234
3235   def TryMerge(self, d):
3236     while d.avail() > 0:
3237       tt = d.getVarInt32()
3238
3239
3240       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
3241       d.skipData(tt)
3242
3243
3244   def __str__(self, prefix="", printElemNumber=0):
3245     res=""
3246     return res
3247
3248
3249   def _BuildTagLookupTable(sparse, maxtag, default=None):
3250     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
3251
3252
3253   _TEXT = _BuildTagLookupTable({
3254     0: "ErrorCode",
3255   }, 0)
3256
3257   _TYPES = _BuildTagLookupTable({
3258     0: ProtocolBuffer.Encoder.NUMERIC,
3259   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
3260
3261
3262   _STYLE = """"""
3263   _STYLE_CONTENT_TYPE = """"""
3264   _PROTO_DESCRIPTOR_NAME = 'apphosting.ImagesDeleteUrlBaseResponse'
3265 if _extension_runtime:
3266   pass
3267
3268 __all__ = ['ImagesServiceError','ImagesServiceTransform','Transform','ImageData','InputSettings','OutputSettings','ImagesTransformRequest','ImagesTransformResponse','CompositeImageOptions','ImagesCanvas','ImagesCompositeRequest','ImagesCompositeResponse','ImagesHistogramRequest','ImagesHistogram','ImagesHistogramResponse','ImagesGetUrlBaseRequest','ImagesGetUrlBaseResponse','ImagesDeleteUrlBaseRequest','ImagesDeleteUrlBaseResponse']