#!/usr/bin/env python

#

# Copyright 2007 Google Inc.

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#

from google.net.proto import ProtocolBuffer

import array

import dummy_thread as thread

__pychecker__ = """maxreturns=0 maxbranches=0 no-callinit

                   unusednames=printElemNumber,debug_strs no-special"""

class ImagesServiceError(ProtocolBuffer.ProtocolMessage):

  UNSPECIFIED_ERROR =    1

  BAD_TRANSFORM_DATA =    2

  NOT_IMAGE    =    3

  BAD_IMAGE_DATA =    4

  IMAGE_TOO_LARGE =    5

  _ErrorCode_NAMES = {

    1: "UNSPECIFIED_ERROR",

    2: "BAD_TRANSFORM_DATA",

    3: "NOT_IMAGE",

    4: "BAD_IMAGE_DATA",

    5: "IMAGE_TOO_LARGE",

  }

  def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")

  ErrorCode_Name = classmethod(ErrorCode_Name)

  def __init__(self, contents=None):

    pass

    if contents is not None: self.MergeFromString(contents)

  def MergeFrom(self, x):

    assert x is not self

  def Equals(self, x):

    if x is self: return 1

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    return initialized

  def ByteSize(self):

    n = 0

    return n + 0

  def Clear(self):

    pass

  def OutputUnchecked(self, out):

    pass

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    return res

  _TEXT = (

   "ErrorCode",

  )

  _TYPES = (

   ProtocolBuffer.Encoder.NUMERIC,

  )

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class ImagesServiceTransform(ProtocolBuffer.ProtocolMessage):

  RESIZE       =    1

  ROTATE       =    2

  HORIZONTAL_FLIP =    3

  VERTICAL_FLIP =    4

  CROP         =    5

  IM_FEELING_LUCKY =    6

  _Type_NAMES = {

    1: "RESIZE",

    2: "ROTATE",

    3: "HORIZONTAL_FLIP",

    4: "VERTICAL_FLIP",

    5: "CROP",

    6: "IM_FEELING_LUCKY",

  }

  def Type_Name(cls, x): return cls._Type_NAMES.get(x, "")

  Type_Name = classmethod(Type_Name)

  def __init__(self, contents=None):

    pass

    if contents is not None: self.MergeFromString(contents)

  def MergeFrom(self, x):

    assert x is not self

  def Equals(self, x):

    if x is self: return 1

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    return initialized

  def ByteSize(self):

    n = 0

    return n + 0

  def Clear(self):

    pass

  def OutputUnchecked(self, out):

    pass

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    return res

  _TEXT = (

   "ErrorCode",

  )

  _TYPES = (

   ProtocolBuffer.Encoder.NUMERIC,

  )

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class Transform(ProtocolBuffer.ProtocolMessage):

  has_width_ = 0

  width_ = 0

  has_height_ = 0

  height_ = 0

  has_rotate_ = 0

  rotate_ = 0

  has_horizontal_flip_ = 0

  horizontal_flip_ = 0

  has_vertical_flip_ = 0

  vertical_flip_ = 0

  has_crop_left_x_ = 0

  crop_left_x_ = 0.0

  has_crop_top_y_ = 0

  crop_top_y_ = 0.0

  has_crop_right_x_ = 0

  crop_right_x_ = 1.0

  has_crop_bottom_y_ = 0

  crop_bottom_y_ = 1.0

  has_autolevels_ = 0

  autolevels_ = 0

  def __init__(self, contents=None):

    if contents is not None: self.MergeFromString(contents)

  def width(self): return self.width_

  def set_width(self, x):

    self.has_width_ = 1

    self.width_ = x

  def clear_width(self):

    if self.has_width_:

      self.has_width_ = 0

      self.width_ = 0

  def has_width(self): return self.has_width_

  def height(self): return self.height_

  def set_height(self, x):

    self.has_height_ = 1

    self.height_ = x

  def clear_height(self):

    if self.has_height_:

      self.has_height_ = 0

      self.height_ = 0

  def has_height(self): return self.has_height_

  def rotate(self): return self.rotate_

  def set_rotate(self, x):

    self.has_rotate_ = 1

    self.rotate_ = x

  def clear_rotate(self):

    if self.has_rotate_:

      self.has_rotate_ = 0

      self.rotate_ = 0

  def has_rotate(self): return self.has_rotate_

  def horizontal_flip(self): return self.horizontal_flip_

  def set_horizontal_flip(self, x):

    self.has_horizontal_flip_ = 1

    self.horizontal_flip_ = x

  def clear_horizontal_flip(self):

    if self.has_horizontal_flip_:

      self.has_horizontal_flip_ = 0

      self.horizontal_flip_ = 0

  def has_horizontal_flip(self): return self.has_horizontal_flip_

  def vertical_flip(self): return self.vertical_flip_

  def set_vertical_flip(self, x):

    self.has_vertical_flip_ = 1

    self.vertical_flip_ = x

  def clear_vertical_flip(self):

    if self.has_vertical_flip_:

      self.has_vertical_flip_ = 0

      self.vertical_flip_ = 0

  def has_vertical_flip(self): return self.has_vertical_flip_

  def crop_left_x(self): return self.crop_left_x_

  def set_crop_left_x(self, x):

    self.has_crop_left_x_ = 1

    self.crop_left_x_ = x

  def clear_crop_left_x(self):

    if self.has_crop_left_x_:

      self.has_crop_left_x_ = 0

      self.crop_left_x_ = 0.0

  def has_crop_left_x(self): return self.has_crop_left_x_

  def crop_top_y(self): return self.crop_top_y_

  def set_crop_top_y(self, x):

    self.has_crop_top_y_ = 1

    self.crop_top_y_ = x

  def clear_crop_top_y(self):

    if self.has_crop_top_y_:

      self.has_crop_top_y_ = 0

      self.crop_top_y_ = 0.0

  def has_crop_top_y(self): return self.has_crop_top_y_

  def crop_right_x(self): return self.crop_right_x_

  def set_crop_right_x(self, x):

    self.has_crop_right_x_ = 1

    self.crop_right_x_ = x

  def clear_crop_right_x(self):

    if self.has_crop_right_x_:

      self.has_crop_right_x_ = 0

      self.crop_right_x_ = 1.0

  def has_crop_right_x(self): return self.has_crop_right_x_

  def crop_bottom_y(self): return self.crop_bottom_y_

  def set_crop_bottom_y(self, x):

    self.has_crop_bottom_y_ = 1

    self.crop_bottom_y_ = x

  def clear_crop_bottom_y(self):

    if self.has_crop_bottom_y_:

      self.has_crop_bottom_y_ = 0

      self.crop_bottom_y_ = 1.0

  def has_crop_bottom_y(self): return self.has_crop_bottom_y_

  def autolevels(self): return self.autolevels_

  def set_autolevels(self, x):

    self.has_autolevels_ = 1

    self.autolevels_ = x

  def clear_autolevels(self):

    if self.has_autolevels_:

      self.has_autolevels_ = 0

      self.autolevels_ = 0

  def has_autolevels(self): return self.has_autolevels_

  def MergeFrom(self, x):

    assert x is not self

    if (x.has_width()): self.set_width(x.width())

    if (x.has_height()): self.set_height(x.height())

    if (x.has_rotate()): self.set_rotate(x.rotate())

    if (x.has_horizontal_flip()): self.set_horizontal_flip(x.horizontal_flip())

    if (x.has_vertical_flip()): self.set_vertical_flip(x.vertical_flip())

    if (x.has_crop_left_x()): self.set_crop_left_x(x.crop_left_x())

    if (x.has_crop_top_y()): self.set_crop_top_y(x.crop_top_y())

    if (x.has_crop_right_x()): self.set_crop_right_x(x.crop_right_x())

    if (x.has_crop_bottom_y()): self.set_crop_bottom_y(x.crop_bottom_y())

    if (x.has_autolevels()): self.set_autolevels(x.autolevels())

  def Equals(self, x):

    if x is self: return 1

    if self.has_width_ != x.has_width_: return 0

    if self.has_width_ and self.width_ != x.width_: return 0

    if self.has_height_ != x.has_height_: return 0

    if self.has_height_ and self.height_ != x.height_: return 0

    if self.has_rotate_ != x.has_rotate_: return 0

    if self.has_rotate_ and self.rotate_ != x.rotate_: return 0

    if self.has_horizontal_flip_ != x.has_horizontal_flip_: return 0

    if self.has_horizontal_flip_ and self.horizontal_flip_ != x.horizontal_flip_: return 0

    if self.has_vertical_flip_ != x.has_vertical_flip_: return 0

    if self.has_vertical_flip_ and self.vertical_flip_ != x.vertical_flip_: return 0

    if self.has_crop_left_x_ != x.has_crop_left_x_: return 0

    if self.has_crop_left_x_ and self.crop_left_x_ != x.crop_left_x_: return 0

    if self.has_crop_top_y_ != x.has_crop_top_y_: return 0

    if self.has_crop_top_y_ and self.crop_top_y_ != x.crop_top_y_: return 0

    if self.has_crop_right_x_ != x.has_crop_right_x_: return 0

    if self.has_crop_right_x_ and self.crop_right_x_ != x.crop_right_x_: return 0

    if self.has_crop_bottom_y_ != x.has_crop_bottom_y_: return 0

    if self.has_crop_bottom_y_ and self.crop_bottom_y_ != x.crop_bottom_y_: return 0

    if self.has_autolevels_ != x.has_autolevels_: return 0

    if self.has_autolevels_ and self.autolevels_ != x.autolevels_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    return initialized

  def ByteSize(self):

    n = 0

    if (self.has_width_): n += 1 + self.lengthVarInt64(self.width_)

    if (self.has_height_): n += 1 + self.lengthVarInt64(self.height_)

    if (self.has_rotate_): n += 1 + self.lengthVarInt64(self.rotate_)

    if (self.has_horizontal_flip_): n += 2

    if (self.has_vertical_flip_): n += 2

    if (self.has_crop_left_x_): n += 5

    if (self.has_crop_top_y_): n += 5

    if (self.has_crop_right_x_): n += 5

    if (self.has_crop_bottom_y_): n += 5

    if (self.has_autolevels_): n += 2

    return n + 0

  def Clear(self):

    self.clear_width()

    self.clear_height()

    self.clear_rotate()

    self.clear_horizontal_flip()

    self.clear_vertical_flip()

    self.clear_crop_left_x()

    self.clear_crop_top_y()

    self.clear_crop_right_x()

    self.clear_crop_bottom_y()

    self.clear_autolevels()

  def OutputUnchecked(self, out):

    if (self.has_width_):

      out.putVarInt32(8)

      out.putVarInt32(self.width_)

    if (self.has_height_):

      out.putVarInt32(16)

      out.putVarInt32(self.height_)

    if (self.has_rotate_):

      out.putVarInt32(24)

      out.putVarInt32(self.rotate_)

    if (self.has_horizontal_flip_):

      out.putVarInt32(32)

      out.putBoolean(self.horizontal_flip_)

    if (self.has_vertical_flip_):

      out.putVarInt32(40)

      out.putBoolean(self.vertical_flip_)

    if (self.has_crop_left_x_):

      out.putVarInt32(53)

      out.putFloat(self.crop_left_x_)

    if (self.has_crop_top_y_):

      out.putVarInt32(61)

      out.putFloat(self.crop_top_y_)

    if (self.has_crop_right_x_):

      out.putVarInt32(69)

      out.putFloat(self.crop_right_x_)

    if (self.has_crop_bottom_y_):

      out.putVarInt32(77)

      out.putFloat(self.crop_bottom_y_)

    if (self.has_autolevels_):

      out.putVarInt32(80)

      out.putBoolean(self.autolevels_)

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if tt == 8:

        self.set_width(d.getVarInt32())

        continue

      if tt == 16:

        self.set_height(d.getVarInt32())

        continue

      if tt == 24:

        self.set_rotate(d.getVarInt32())

        continue

      if tt == 32:

        self.set_horizontal_flip(d.getBoolean())

        continue

      if tt == 40:

        self.set_vertical_flip(d.getBoolean())

        continue

      if tt == 53:

        self.set_crop_left_x(d.getFloat())

        continue

      if tt == 61:

        self.set_crop_top_y(d.getFloat())

        continue

      if tt == 69:

        self.set_crop_right_x(d.getFloat())

        continue

      if tt == 77:

        self.set_crop_bottom_y(d.getFloat())

        continue

      if tt == 80:

        self.set_autolevels(d.getBoolean())

        continue

      if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

      d.skipData(tt)

  def __str__(self, prefix="", printElemNumber=0):

    res=""

    if self.has_width_: res+=prefix+("width: %s\n" % self.DebugFormatInt32(self.width_))

    if self.has_height_: res+=prefix+("height: %s\n" % self.DebugFormatInt32(self.height_))

    if self.has_rotate_: res+=prefix+("rotate: %s\n" % self.DebugFormatInt32(self.rotate_))

    if self.has_horizontal_flip_: res+=prefix+("horizontal_flip: %s\n" % self.DebugFormatBool(self.horizontal_flip_))

    if self.has_vertical_flip_: res+=prefix+("vertical_flip: %s\n" % self.DebugFormatBool(self.vertical_flip_))

    if self.has_crop_left_x_: res+=prefix+("crop_left_x: %s\n" % self.DebugFormatFloat(self.crop_left_x_))

    if self.has_crop_top_y_: res+=prefix+("crop_top_y: %s\n" % self.DebugFormatFloat(self.crop_top_y_))

    if self.has_crop_right_x_: res+=prefix+("crop_right_x: %s\n" % self.DebugFormatFloat(self.crop_right_x_))

    if self.has_crop_bottom_y_: res+=prefix+("crop_bottom_y: %s\n" % self.DebugFormatFloat(self.crop_bottom_y_))

    if self.has_autolevels_: res+=prefix+("autolevels: %s\n" % self.DebugFormatBool(self.autolevels_))

    return res

  kwidth = 1

  kheight = 2

  krotate = 3

  khorizontal_flip = 4

  kvertical_flip = 5

  kcrop_left_x = 6

  kcrop_top_y = 7

  kcrop_right_x = 8

  kcrop_bottom_y = 9

  kautolevels = 10

  _TEXT = (

   "ErrorCode",

   "width",

   "height",

   "rotate",

   "horizontal_flip",

   "vertical_flip",

   "crop_left_x",

   "crop_top_y",

   "crop_right_x",

   "crop_bottom_y",

   "autolevels",

  )

  _TYPES = (

   ProtocolBuffer.Encoder.NUMERIC,

   ProtocolBuffer.Encoder.NUMERIC,

   ProtocolBuffer.Encoder.NUMERIC,

   ProtocolBuffer.Encoder.NUMERIC,

   ProtocolBuffer.Encoder.NUMERIC,

   ProtocolBuffer.Encoder.NUMERIC,

   ProtocolBuffer.Encoder.FLOAT,

   ProtocolBuffer.Encoder.FLOAT,

   ProtocolBuffer.Encoder.FLOAT,

   ProtocolBuffer.Encoder.FLOAT,

   ProtocolBuffer.Encoder.NUMERIC,

  )

  _STYLE = """"""

  _STYLE_CONTENT_TYPE = """"""

class ImageData(ProtocolBuffer.ProtocolMessage):

  has_content_ = 0

  content_ = ""