|
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 from google.net.proto import ProtocolBuffer |
|
19 import array |
|
20 import dummy_thread as thread |
|
21 |
|
22 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit |
|
23 unusednames=printElemNumber,debug_strs no-special""" |
|
24 |
|
25 class ImagesServiceError(ProtocolBuffer.ProtocolMessage): |
|
26 |
|
27 UNSPECIFIED_ERROR = 1 |
|
28 BAD_TRANSFORM_DATA = 2 |
|
29 NOT_IMAGE = 3 |
|
30 BAD_IMAGE_DATA = 4 |
|
31 IMAGE_TOO_LARGE = 5 |
|
32 |
|
33 _ErrorCode_NAMES = { |
|
34 1: "UNSPECIFIED_ERROR", |
|
35 2: "BAD_TRANSFORM_DATA", |
|
36 3: "NOT_IMAGE", |
|
37 4: "BAD_IMAGE_DATA", |
|
38 5: "IMAGE_TOO_LARGE", |
|
39 } |
|
40 |
|
41 def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "") |
|
42 ErrorCode_Name = classmethod(ErrorCode_Name) |
|
43 |
|
44 def __init__(self, contents=None): |
|
45 pass |
|
46 if contents is not None: self.MergeFromString(contents) |
|
47 |
|
48 |
|
49 def MergeFrom(self, x): |
|
50 assert x is not self |
|
51 |
|
52 def Equals(self, x): |
|
53 if x is self: return 1 |
|
54 return 1 |
|
55 |
|
56 def __eq__(self, other): |
|
57 return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other) |
|
58 |
|
59 def __ne__(self, other): |
|
60 return not (self == other) |
|
61 |
|
62 def IsInitialized(self, debug_strs=None): |
|
63 initialized = 1 |
|
64 return initialized |
|
65 |
|
66 def ByteSize(self): |
|
67 n = 0 |
|
68 return n + 0 |
|
69 |
|
70 def Clear(self): |
|
71 pass |
|
72 |
|
73 def OutputUnchecked(self, out): |
|
74 pass |
|
75 |
|
76 def TryMerge(self, d): |
|
77 while d.avail() > 0: |
|
78 tt = d.getVarInt32() |
|
79 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
80 d.skipData(tt) |
|
81 |
|
82 |
|
83 def __str__(self, prefix="", printElemNumber=0): |
|
84 res="" |
|
85 return res |
|
86 |
|
87 |
|
88 _TEXT = ( |
|
89 "ErrorCode", |
|
90 ) |
|
91 |
|
92 _TYPES = ( |
|
93 ProtocolBuffer.Encoder.NUMERIC, |
|
94 ) |
|
95 |
|
96 _STYLE = """""" |
|
97 _STYLE_CONTENT_TYPE = """""" |
|
98 class ImagesServiceTransform(ProtocolBuffer.ProtocolMessage): |
|
99 |
|
100 RESIZE = 1 |
|
101 ROTATE = 2 |
|
102 HORIZONTAL_FLIP = 3 |
|
103 VERTICAL_FLIP = 4 |
|
104 CROP = 5 |
|
105 IM_FEELING_LUCKY = 6 |
|
106 |
|
107 _Type_NAMES = { |
|
108 1: "RESIZE", |
|
109 2: "ROTATE", |
|
110 3: "HORIZONTAL_FLIP", |
|
111 4: "VERTICAL_FLIP", |
|
112 5: "CROP", |
|
113 6: "IM_FEELING_LUCKY", |
|
114 } |
|
115 |
|
116 def Type_Name(cls, x): return cls._Type_NAMES.get(x, "") |
|
117 Type_Name = classmethod(Type_Name) |
|
118 |
|
119 def __init__(self, contents=None): |
|
120 pass |
|
121 if contents is not None: self.MergeFromString(contents) |
|
122 |
|
123 |
|
124 def MergeFrom(self, x): |
|
125 assert x is not self |
|
126 |
|
127 def Equals(self, x): |
|
128 if x is self: return 1 |
|
129 return 1 |
|
130 |
|
131 def __eq__(self, other): |
|
132 return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other) |
|
133 |
|
134 def __ne__(self, other): |
|
135 return not (self == other) |
|
136 |
|
137 def IsInitialized(self, debug_strs=None): |
|
138 initialized = 1 |
|
139 return initialized |
|
140 |
|
141 def ByteSize(self): |
|
142 n = 0 |
|
143 return n + 0 |
|
144 |
|
145 def Clear(self): |
|
146 pass |
|
147 |
|
148 def OutputUnchecked(self, out): |
|
149 pass |
|
150 |
|
151 def TryMerge(self, d): |
|
152 while d.avail() > 0: |
|
153 tt = d.getVarInt32() |
|
154 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
155 d.skipData(tt) |
|
156 |
|
157 |
|
158 def __str__(self, prefix="", printElemNumber=0): |
|
159 res="" |
|
160 return res |
|
161 |
|
162 |
|
163 _TEXT = ( |
|
164 "ErrorCode", |
|
165 ) |
|
166 |
|
167 _TYPES = ( |
|
168 ProtocolBuffer.Encoder.NUMERIC, |
|
169 ) |
|
170 |
|
171 _STYLE = """""" |
|
172 _STYLE_CONTENT_TYPE = """""" |
|
173 class Transform(ProtocolBuffer.ProtocolMessage): |
|
174 def __init__(self, contents=None): |
|
175 self.width_ = 0 |
|
176 self.height_ = 0 |
|
177 self.rotate_ = 0 |
|
178 self.horizontal_flip_ = 0 |
|
179 self.vertical_flip_ = 0 |
|
180 self.crop_left_x_ = 0.0 |
|
181 self.crop_top_y_ = 0.0 |
|
182 self.crop_right_x_ = 1.0 |
|
183 self.crop_bottom_y_ = 1.0 |
|
184 self.autolevels_ = 0 |
|
185 self.has_width_ = 0 |
|
186 self.has_height_ = 0 |
|
187 self.has_rotate_ = 0 |
|
188 self.has_horizontal_flip_ = 0 |
|
189 self.has_vertical_flip_ = 0 |
|
190 self.has_crop_left_x_ = 0 |
|
191 self.has_crop_top_y_ = 0 |
|
192 self.has_crop_right_x_ = 0 |
|
193 self.has_crop_bottom_y_ = 0 |
|
194 self.has_autolevels_ = 0 |
|
195 if contents is not None: self.MergeFromString(contents) |
|
196 |
|
197 def width(self): return self.width_ |
|
198 |
|
199 def set_width(self, x): |
|
200 self.has_width_ = 1 |
|
201 self.width_ = x |
|
202 |
|
203 def clear_width(self): |
|
204 self.has_width_ = 0 |
|
205 self.width_ = 0 |
|
206 |
|
207 def has_width(self): return self.has_width_ |
|
208 |
|
209 def height(self): return self.height_ |
|
210 |
|
211 def set_height(self, x): |
|
212 self.has_height_ = 1 |
|
213 self.height_ = x |
|
214 |
|
215 def clear_height(self): |
|
216 self.has_height_ = 0 |
|
217 self.height_ = 0 |
|
218 |
|
219 def has_height(self): return self.has_height_ |
|
220 |
|
221 def rotate(self): return self.rotate_ |
|
222 |
|
223 def set_rotate(self, x): |
|
224 self.has_rotate_ = 1 |
|
225 self.rotate_ = x |
|
226 |
|
227 def clear_rotate(self): |
|
228 self.has_rotate_ = 0 |
|
229 self.rotate_ = 0 |
|
230 |
|
231 def has_rotate(self): return self.has_rotate_ |
|
232 |
|
233 def horizontal_flip(self): return self.horizontal_flip_ |
|
234 |
|
235 def set_horizontal_flip(self, x): |
|
236 self.has_horizontal_flip_ = 1 |
|
237 self.horizontal_flip_ = x |
|
238 |
|
239 def clear_horizontal_flip(self): |
|
240 self.has_horizontal_flip_ = 0 |
|
241 self.horizontal_flip_ = 0 |
|
242 |
|
243 def has_horizontal_flip(self): return self.has_horizontal_flip_ |
|
244 |
|
245 def vertical_flip(self): return self.vertical_flip_ |
|
246 |
|
247 def set_vertical_flip(self, x): |
|
248 self.has_vertical_flip_ = 1 |
|
249 self.vertical_flip_ = x |
|
250 |
|
251 def clear_vertical_flip(self): |
|
252 self.has_vertical_flip_ = 0 |
|
253 self.vertical_flip_ = 0 |
|
254 |
|
255 def has_vertical_flip(self): return self.has_vertical_flip_ |
|
256 |
|
257 def crop_left_x(self): return self.crop_left_x_ |
|
258 |
|
259 def set_crop_left_x(self, x): |
|
260 self.has_crop_left_x_ = 1 |
|
261 self.crop_left_x_ = x |
|
262 |
|
263 def clear_crop_left_x(self): |
|
264 self.has_crop_left_x_ = 0 |
|
265 self.crop_left_x_ = 0.0 |
|
266 |
|
267 def has_crop_left_x(self): return self.has_crop_left_x_ |
|
268 |
|
269 def crop_top_y(self): return self.crop_top_y_ |
|
270 |
|
271 def set_crop_top_y(self, x): |
|
272 self.has_crop_top_y_ = 1 |
|
273 self.crop_top_y_ = x |
|
274 |
|
275 def clear_crop_top_y(self): |
|
276 self.has_crop_top_y_ = 0 |
|
277 self.crop_top_y_ = 0.0 |
|
278 |
|
279 def has_crop_top_y(self): return self.has_crop_top_y_ |
|
280 |
|
281 def crop_right_x(self): return self.crop_right_x_ |
|
282 |
|
283 def set_crop_right_x(self, x): |
|
284 self.has_crop_right_x_ = 1 |
|
285 self.crop_right_x_ = x |
|
286 |
|
287 def clear_crop_right_x(self): |
|
288 self.has_crop_right_x_ = 0 |
|
289 self.crop_right_x_ = 1.0 |
|
290 |
|
291 def has_crop_right_x(self): return self.has_crop_right_x_ |
|
292 |
|
293 def crop_bottom_y(self): return self.crop_bottom_y_ |
|
294 |
|
295 def set_crop_bottom_y(self, x): |
|
296 self.has_crop_bottom_y_ = 1 |
|
297 self.crop_bottom_y_ = x |
|
298 |
|
299 def clear_crop_bottom_y(self): |
|
300 self.has_crop_bottom_y_ = 0 |
|
301 self.crop_bottom_y_ = 1.0 |
|
302 |
|
303 def has_crop_bottom_y(self): return self.has_crop_bottom_y_ |
|
304 |
|
305 def autolevels(self): return self.autolevels_ |
|
306 |
|
307 def set_autolevels(self, x): |
|
308 self.has_autolevels_ = 1 |
|
309 self.autolevels_ = x |
|
310 |
|
311 def clear_autolevels(self): |
|
312 self.has_autolevels_ = 0 |
|
313 self.autolevels_ = 0 |
|
314 |
|
315 def has_autolevels(self): return self.has_autolevels_ |
|
316 |
|
317 |
|
318 def MergeFrom(self, x): |
|
319 assert x is not self |
|
320 if (x.has_width()): self.set_width(x.width()) |
|
321 if (x.has_height()): self.set_height(x.height()) |
|
322 if (x.has_rotate()): self.set_rotate(x.rotate()) |
|
323 if (x.has_horizontal_flip()): self.set_horizontal_flip(x.horizontal_flip()) |
|
324 if (x.has_vertical_flip()): self.set_vertical_flip(x.vertical_flip()) |
|
325 if (x.has_crop_left_x()): self.set_crop_left_x(x.crop_left_x()) |
|
326 if (x.has_crop_top_y()): self.set_crop_top_y(x.crop_top_y()) |
|
327 if (x.has_crop_right_x()): self.set_crop_right_x(x.crop_right_x()) |
|
328 if (x.has_crop_bottom_y()): self.set_crop_bottom_y(x.crop_bottom_y()) |
|
329 if (x.has_autolevels()): self.set_autolevels(x.autolevels()) |
|
330 |
|
331 def Equals(self, x): |
|
332 if x is self: return 1 |
|
333 if self.has_width_ != x.has_width_: return 0 |
|
334 if self.has_width_ and self.width_ != x.width_: return 0 |
|
335 if self.has_height_ != x.has_height_: return 0 |
|
336 if self.has_height_ and self.height_ != x.height_: return 0 |
|
337 if self.has_rotate_ != x.has_rotate_: return 0 |
|
338 if self.has_rotate_ and self.rotate_ != x.rotate_: return 0 |
|
339 if self.has_horizontal_flip_ != x.has_horizontal_flip_: return 0 |
|
340 if self.has_horizontal_flip_ and self.horizontal_flip_ != x.horizontal_flip_: return 0 |
|
341 if self.has_vertical_flip_ != x.has_vertical_flip_: return 0 |
|
342 if self.has_vertical_flip_ and self.vertical_flip_ != x.vertical_flip_: return 0 |
|
343 if self.has_crop_left_x_ != x.has_crop_left_x_: return 0 |
|
344 if self.has_crop_left_x_ and self.crop_left_x_ != x.crop_left_x_: return 0 |
|
345 if self.has_crop_top_y_ != x.has_crop_top_y_: return 0 |
|
346 if self.has_crop_top_y_ and self.crop_top_y_ != x.crop_top_y_: return 0 |
|
347 if self.has_crop_right_x_ != x.has_crop_right_x_: return 0 |
|
348 if self.has_crop_right_x_ and self.crop_right_x_ != x.crop_right_x_: return 0 |
|
349 if self.has_crop_bottom_y_ != x.has_crop_bottom_y_: return 0 |
|
350 if self.has_crop_bottom_y_ and self.crop_bottom_y_ != x.crop_bottom_y_: return 0 |
|
351 if self.has_autolevels_ != x.has_autolevels_: return 0 |
|
352 if self.has_autolevels_ and self.autolevels_ != x.autolevels_: return 0 |
|
353 return 1 |
|
354 |
|
355 def __eq__(self, other): |
|
356 return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other) |
|
357 |
|
358 def __ne__(self, other): |
|
359 return not (self == other) |
|
360 |
|
361 def IsInitialized(self, debug_strs=None): |
|
362 initialized = 1 |
|
363 return initialized |
|
364 |
|
365 def ByteSize(self): |
|
366 n = 0 |
|
367 if (self.has_width_): n += 1 + self.lengthVarInt64(self.width_) |
|
368 if (self.has_height_): n += 1 + self.lengthVarInt64(self.height_) |
|
369 if (self.has_rotate_): n += 1 + self.lengthVarInt64(self.rotate_) |
|
370 if (self.has_horizontal_flip_): n += 2 |
|
371 if (self.has_vertical_flip_): n += 2 |
|
372 if (self.has_crop_left_x_): n += 5 |
|
373 if (self.has_crop_top_y_): n += 5 |
|
374 if (self.has_crop_right_x_): n += 5 |
|
375 if (self.has_crop_bottom_y_): n += 5 |
|
376 if (self.has_autolevels_): n += 2 |
|
377 return n + 0 |
|
378 |
|
379 def Clear(self): |
|
380 self.clear_width() |
|
381 self.clear_height() |
|
382 self.clear_rotate() |
|
383 self.clear_horizontal_flip() |
|
384 self.clear_vertical_flip() |
|
385 self.clear_crop_left_x() |
|
386 self.clear_crop_top_y() |
|
387 self.clear_crop_right_x() |
|
388 self.clear_crop_bottom_y() |
|
389 self.clear_autolevels() |
|
390 |
|
391 def OutputUnchecked(self, out): |
|
392 if (self.has_width_): |
|
393 out.putVarInt32(8) |
|
394 out.putVarInt32(self.width_) |
|
395 if (self.has_height_): |
|
396 out.putVarInt32(16) |
|
397 out.putVarInt32(self.height_) |
|
398 if (self.has_rotate_): |
|
399 out.putVarInt32(24) |
|
400 out.putVarInt32(self.rotate_) |
|
401 if (self.has_horizontal_flip_): |
|
402 out.putVarInt32(32) |
|
403 out.putBoolean(self.horizontal_flip_) |
|
404 if (self.has_vertical_flip_): |
|
405 out.putVarInt32(40) |
|
406 out.putBoolean(self.vertical_flip_) |
|
407 if (self.has_crop_left_x_): |
|
408 out.putVarInt32(53) |
|
409 out.putFloat(self.crop_left_x_) |
|
410 if (self.has_crop_top_y_): |
|
411 out.putVarInt32(61) |
|
412 out.putFloat(self.crop_top_y_) |
|
413 if (self.has_crop_right_x_): |
|
414 out.putVarInt32(69) |
|
415 out.putFloat(self.crop_right_x_) |
|
416 if (self.has_crop_bottom_y_): |
|
417 out.putVarInt32(77) |
|
418 out.putFloat(self.crop_bottom_y_) |
|
419 if (self.has_autolevels_): |
|
420 out.putVarInt32(80) |
|
421 out.putBoolean(self.autolevels_) |
|
422 |
|
423 def TryMerge(self, d): |
|
424 while d.avail() > 0: |
|
425 tt = d.getVarInt32() |
|
426 if tt == 8: |
|
427 self.set_width(d.getVarInt32()) |
|
428 continue |
|
429 if tt == 16: |
|
430 self.set_height(d.getVarInt32()) |
|
431 continue |
|
432 if tt == 24: |
|
433 self.set_rotate(d.getVarInt32()) |
|
434 continue |
|
435 if tt == 32: |
|
436 self.set_horizontal_flip(d.getBoolean()) |
|
437 continue |
|
438 if tt == 40: |
|
439 self.set_vertical_flip(d.getBoolean()) |
|
440 continue |
|
441 if tt == 53: |
|
442 self.set_crop_left_x(d.getFloat()) |
|
443 continue |
|
444 if tt == 61: |
|
445 self.set_crop_top_y(d.getFloat()) |
|
446 continue |
|
447 if tt == 69: |
|
448 self.set_crop_right_x(d.getFloat()) |
|
449 continue |
|
450 if tt == 77: |
|
451 self.set_crop_bottom_y(d.getFloat()) |
|
452 continue |
|
453 if tt == 80: |
|
454 self.set_autolevels(d.getBoolean()) |
|
455 continue |
|
456 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
457 d.skipData(tt) |
|
458 |
|
459 |
|
460 def __str__(self, prefix="", printElemNumber=0): |
|
461 res="" |
|
462 if self.has_width_: res+=prefix+("width: %s\n" % self.DebugFormatInt32(self.width_)) |
|
463 if self.has_height_: res+=prefix+("height: %s\n" % self.DebugFormatInt32(self.height_)) |
|
464 if self.has_rotate_: res+=prefix+("rotate: %s\n" % self.DebugFormatInt32(self.rotate_)) |
|
465 if self.has_horizontal_flip_: res+=prefix+("horizontal_flip: %s\n" % self.DebugFormatBool(self.horizontal_flip_)) |
|
466 if self.has_vertical_flip_: res+=prefix+("vertical_flip: %s\n" % self.DebugFormatBool(self.vertical_flip_)) |
|
467 if self.has_crop_left_x_: res+=prefix+("crop_left_x: %s\n" % self.DebugFormatFloat(self.crop_left_x_)) |
|
468 if self.has_crop_top_y_: res+=prefix+("crop_top_y: %s\n" % self.DebugFormatFloat(self.crop_top_y_)) |
|
469 if self.has_crop_right_x_: res+=prefix+("crop_right_x: %s\n" % self.DebugFormatFloat(self.crop_right_x_)) |
|
470 if self.has_crop_bottom_y_: res+=prefix+("crop_bottom_y: %s\n" % self.DebugFormatFloat(self.crop_bottom_y_)) |
|
471 if self.has_autolevels_: res+=prefix+("autolevels: %s\n" % self.DebugFormatBool(self.autolevels_)) |
|
472 return res |
|
473 |
|
474 kwidth = 1 |
|
475 kheight = 2 |
|
476 krotate = 3 |
|
477 khorizontal_flip = 4 |
|
478 kvertical_flip = 5 |
|
479 kcrop_left_x = 6 |
|
480 kcrop_top_y = 7 |
|
481 kcrop_right_x = 8 |
|
482 kcrop_bottom_y = 9 |
|
483 kautolevels = 10 |
|
484 |
|
485 _TEXT = ( |
|
486 "ErrorCode", |
|
487 "width", |
|
488 "height", |
|
489 "rotate", |
|
490 "horizontal_flip", |
|
491 "vertical_flip", |
|
492 "crop_left_x", |
|
493 "crop_top_y", |
|
494 "crop_right_x", |
|
495 "crop_bottom_y", |
|
496 "autolevels", |
|
497 ) |
|
498 |
|
499 _TYPES = ( |
|
500 ProtocolBuffer.Encoder.NUMERIC, |
|
501 ProtocolBuffer.Encoder.NUMERIC, |
|
502 |
|
503 ProtocolBuffer.Encoder.NUMERIC, |
|
504 |
|
505 ProtocolBuffer.Encoder.NUMERIC, |
|
506 |
|
507 ProtocolBuffer.Encoder.NUMERIC, |
|
508 |
|
509 ProtocolBuffer.Encoder.NUMERIC, |
|
510 |
|
511 ProtocolBuffer.Encoder.FLOAT, |
|
512 |
|
513 ProtocolBuffer.Encoder.FLOAT, |
|
514 |
|
515 ProtocolBuffer.Encoder.FLOAT, |
|
516 |
|
517 ProtocolBuffer.Encoder.FLOAT, |
|
518 |
|
519 ProtocolBuffer.Encoder.NUMERIC, |
|
520 |
|
521 ) |
|
522 |
|
523 _STYLE = """""" |
|
524 _STYLE_CONTENT_TYPE = """""" |
|
525 class ImageData(ProtocolBuffer.ProtocolMessage): |
|
526 def __init__(self, contents=None): |
|
527 self.content_ = "" |
|
528 self.has_content_ = 0 |
|
529 if contents is not None: self.MergeFromString(contents) |
|
530 |
|
531 def content(self): return self.content_ |
|
532 |
|
533 def set_content(self, x): |
|
534 self.has_content_ = 1 |
|
535 self.content_ = x |
|
536 |
|
537 def clear_content(self): |
|
538 self.has_content_ = 0 |
|
539 self.content_ = "" |
|
540 |
|
541 def has_content(self): return self.has_content_ |
|
542 |
|
543 |
|
544 def MergeFrom(self, x): |
|
545 assert x is not self |
|
546 if (x.has_content()): self.set_content(x.content()) |
|
547 |
|
548 def Equals(self, x): |
|
549 if x is self: return 1 |
|
550 if self.has_content_ != x.has_content_: return 0 |
|
551 if self.has_content_ and self.content_ != x.content_: return 0 |
|
552 return 1 |
|
553 |
|
554 def __eq__(self, other): |
|
555 return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other) |
|
556 |
|
557 def __ne__(self, other): |
|
558 return not (self == other) |
|
559 |
|
560 def IsInitialized(self, debug_strs=None): |
|
561 initialized = 1 |
|
562 if (not self.has_content_): |
|
563 initialized = 0 |
|
564 if debug_strs is not None: |
|
565 debug_strs.append('Required field: content not set.') |
|
566 return initialized |
|
567 |
|
568 def ByteSize(self): |
|
569 n = 0 |
|
570 n += self.lengthString(len(self.content_)) |
|
571 return n + 1 |
|
572 |
|
573 def Clear(self): |
|
574 self.clear_content() |
|
575 |
|
576 def OutputUnchecked(self, out): |
|
577 out.putVarInt32(10) |
|
578 out.putPrefixedString(self.content_) |
|
579 |
|
580 def TryMerge(self, d): |
|
581 while d.avail() > 0: |
|
582 tt = d.getVarInt32() |
|
583 if tt == 10: |
|
584 self.set_content(d.getPrefixedString()) |
|
585 continue |
|
586 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
587 d.skipData(tt) |
|
588 |
|
589 |
|
590 def __str__(self, prefix="", printElemNumber=0): |
|
591 res="" |
|
592 if self.has_content_: res+=prefix+("content: %s\n" % self.DebugFormatString(self.content_)) |
|
593 return res |
|
594 |
|
595 kcontent = 1 |
|
596 |
|
597 _TEXT = ( |
|
598 "ErrorCode", |
|
599 "content", |
|
600 ) |
|
601 |
|
602 _TYPES = ( |
|
603 ProtocolBuffer.Encoder.NUMERIC, |
|
604 ProtocolBuffer.Encoder.STRING, |
|
605 |
|
606 ) |
|
607 |
|
608 _STYLE = """""" |
|
609 _STYLE_CONTENT_TYPE = """""" |
|
610 class OutputSettings(ProtocolBuffer.ProtocolMessage): |
|
611 |
|
612 PNG = 0 |
|
613 JPEG = 1 |
|
614 |
|
615 _MIME_TYPE_NAMES = { |
|
616 0: "PNG", |
|
617 1: "JPEG", |
|
618 } |
|
619 |
|
620 def MIME_TYPE_Name(cls, x): return cls._MIME_TYPE_NAMES.get(x, "") |
|
621 MIME_TYPE_Name = classmethod(MIME_TYPE_Name) |
|
622 |
|
623 def __init__(self, contents=None): |
|
624 self.mime_type_ = 0 |
|
625 self.has_mime_type_ = 0 |
|
626 if contents is not None: self.MergeFromString(contents) |
|
627 |
|
628 def mime_type(self): return self.mime_type_ |
|
629 |
|
630 def set_mime_type(self, x): |
|
631 self.has_mime_type_ = 1 |
|
632 self.mime_type_ = x |
|
633 |
|
634 def clear_mime_type(self): |
|
635 self.has_mime_type_ = 0 |
|
636 self.mime_type_ = 0 |
|
637 |
|
638 def has_mime_type(self): return self.has_mime_type_ |
|
639 |
|
640 |
|
641 def MergeFrom(self, x): |
|
642 assert x is not self |
|
643 if (x.has_mime_type()): self.set_mime_type(x.mime_type()) |
|
644 |
|
645 def Equals(self, x): |
|
646 if x is self: return 1 |
|
647 if self.has_mime_type_ != x.has_mime_type_: return 0 |
|
648 if self.has_mime_type_ and self.mime_type_ != x.mime_type_: return 0 |
|
649 return 1 |
|
650 |
|
651 def __eq__(self, other): |
|
652 return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other) |
|
653 |
|
654 def __ne__(self, other): |
|
655 return not (self == other) |
|
656 |
|
657 def IsInitialized(self, debug_strs=None): |
|
658 initialized = 1 |
|
659 return initialized |
|
660 |
|
661 def ByteSize(self): |
|
662 n = 0 |
|
663 if (self.has_mime_type_): n += 1 + self.lengthVarInt64(self.mime_type_) |
|
664 return n + 0 |
|
665 |
|
666 def Clear(self): |
|
667 self.clear_mime_type() |
|
668 |
|
669 def OutputUnchecked(self, out): |
|
670 if (self.has_mime_type_): |
|
671 out.putVarInt32(8) |
|
672 out.putVarInt32(self.mime_type_) |
|
673 |
|
674 def TryMerge(self, d): |
|
675 while d.avail() > 0: |
|
676 tt = d.getVarInt32() |
|
677 if tt == 8: |
|
678 self.set_mime_type(d.getVarInt32()) |
|
679 continue |
|
680 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
681 d.skipData(tt) |
|
682 |
|
683 |
|
684 def __str__(self, prefix="", printElemNumber=0): |
|
685 res="" |
|
686 if self.has_mime_type_: res+=prefix+("mime_type: %s\n" % self.DebugFormatInt32(self.mime_type_)) |
|
687 return res |
|
688 |
|
689 kmime_type = 1 |
|
690 |
|
691 _TEXT = ( |
|
692 "ErrorCode", |
|
693 "mime_type", |
|
694 ) |
|
695 |
|
696 _TYPES = ( |
|
697 ProtocolBuffer.Encoder.NUMERIC, |
|
698 ProtocolBuffer.Encoder.NUMERIC, |
|
699 |
|
700 ) |
|
701 |
|
702 _STYLE = """""" |
|
703 _STYLE_CONTENT_TYPE = """""" |
|
704 class ImagesTransformRequest(ProtocolBuffer.ProtocolMessage): |
|
705 def __init__(self, contents=None): |
|
706 self.image_ = ImageData() |
|
707 self.transform_ = [] |
|
708 self.output_ = OutputSettings() |
|
709 self.has_image_ = 0 |
|
710 self.has_output_ = 0 |
|
711 if contents is not None: self.MergeFromString(contents) |
|
712 |
|
713 def image(self): return self.image_ |
|
714 |
|
715 def mutable_image(self): self.has_image_ = 1; return self.image_ |
|
716 |
|
717 def clear_image(self):self.has_image_ = 0; self.image_.Clear() |
|
718 |
|
719 def has_image(self): return self.has_image_ |
|
720 |
|
721 def transform_size(self): return len(self.transform_) |
|
722 def transform_list(self): return self.transform_ |
|
723 |
|
724 def transform(self, i): |
|
725 return self.transform_[i] |
|
726 |
|
727 def mutable_transform(self, i): |
|
728 return self.transform_[i] |
|
729 |
|
730 def add_transform(self): |
|
731 x = Transform() |
|
732 self.transform_.append(x) |
|
733 return x |
|
734 |
|
735 def clear_transform(self): |
|
736 self.transform_ = [] |
|
737 def output(self): return self.output_ |
|
738 |
|
739 def mutable_output(self): self.has_output_ = 1; return self.output_ |
|
740 |
|
741 def clear_output(self):self.has_output_ = 0; self.output_.Clear() |
|
742 |
|
743 def has_output(self): return self.has_output_ |
|
744 |
|
745 |
|
746 def MergeFrom(self, x): |
|
747 assert x is not self |
|
748 if (x.has_image()): self.mutable_image().MergeFrom(x.image()) |
|
749 for i in xrange(x.transform_size()): self.add_transform().CopyFrom(x.transform(i)) |
|
750 if (x.has_output()): self.mutable_output().MergeFrom(x.output()) |
|
751 |
|
752 def Equals(self, x): |
|
753 if x is self: return 1 |
|
754 if self.has_image_ != x.has_image_: return 0 |
|
755 if self.has_image_ and self.image_ != x.image_: return 0 |
|
756 if len(self.transform_) != len(x.transform_): return 0 |
|
757 for e1, e2 in zip(self.transform_, x.transform_): |
|
758 if e1 != e2: return 0 |
|
759 if self.has_output_ != x.has_output_: return 0 |
|
760 if self.has_output_ and self.output_ != x.output_: return 0 |
|
761 return 1 |
|
762 |
|
763 def __eq__(self, other): |
|
764 return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other) |
|
765 |
|
766 def __ne__(self, other): |
|
767 return not (self == other) |
|
768 |
|
769 def IsInitialized(self, debug_strs=None): |
|
770 initialized = 1 |
|
771 if (not self.has_image_): |
|
772 initialized = 0 |
|
773 if debug_strs is not None: |
|
774 debug_strs.append('Required field: image not set.') |
|
775 elif not self.image_.IsInitialized(debug_strs): initialized = 0 |
|
776 for i in xrange(len(self.transform_)): |
|
777 if (not self.transform_[i].IsInitialized(debug_strs)): initialized=0 |
|
778 if (not self.has_output_): |
|
779 initialized = 0 |
|
780 if debug_strs is not None: |
|
781 debug_strs.append('Required field: output not set.') |
|
782 elif not self.output_.IsInitialized(debug_strs): initialized = 0 |
|
783 return initialized |
|
784 |
|
785 def ByteSize(self): |
|
786 n = 0 |
|
787 n += self.lengthString(self.image_.ByteSize()) |
|
788 n += 1 * len(self.transform_) |
|
789 for i in xrange(len(self.transform_)): n += self.lengthString(self.transform_[i].ByteSize()) |
|
790 n += self.lengthString(self.output_.ByteSize()) |
|
791 return n + 2 |
|
792 |
|
793 def Clear(self): |
|
794 self.clear_image() |
|
795 self.clear_transform() |
|
796 self.clear_output() |
|
797 |
|
798 def OutputUnchecked(self, out): |
|
799 out.putVarInt32(10) |
|
800 out.putVarInt32(self.image_.ByteSize()) |
|
801 self.image_.OutputUnchecked(out) |
|
802 for i in xrange(len(self.transform_)): |
|
803 out.putVarInt32(18) |
|
804 out.putVarInt32(self.transform_[i].ByteSize()) |
|
805 self.transform_[i].OutputUnchecked(out) |
|
806 out.putVarInt32(26) |
|
807 out.putVarInt32(self.output_.ByteSize()) |
|
808 self.output_.OutputUnchecked(out) |
|
809 |
|
810 def TryMerge(self, d): |
|
811 while d.avail() > 0: |
|
812 tt = d.getVarInt32() |
|
813 if tt == 10: |
|
814 length = d.getVarInt32() |
|
815 tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
|
816 d.skip(length) |
|
817 self.mutable_image().TryMerge(tmp) |
|
818 continue |
|
819 if tt == 18: |
|
820 length = d.getVarInt32() |
|
821 tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
|
822 d.skip(length) |
|
823 self.add_transform().TryMerge(tmp) |
|
824 continue |
|
825 if tt == 26: |
|
826 length = d.getVarInt32() |
|
827 tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
|
828 d.skip(length) |
|
829 self.mutable_output().TryMerge(tmp) |
|
830 continue |
|
831 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
832 d.skipData(tt) |
|
833 |
|
834 |
|
835 def __str__(self, prefix="", printElemNumber=0): |
|
836 res="" |
|
837 if self.has_image_: |
|
838 res+=prefix+"image <\n" |
|
839 res+=self.image_.__str__(prefix + " ", printElemNumber) |
|
840 res+=prefix+">\n" |
|
841 cnt=0 |
|
842 for e in self.transform_: |
|
843 elm="" |
|
844 if printElemNumber: elm="(%d)" % cnt |
|
845 res+=prefix+("transform%s <\n" % elm) |
|
846 res+=e.__str__(prefix + " ", printElemNumber) |
|
847 res+=prefix+">\n" |
|
848 cnt+=1 |
|
849 if self.has_output_: |
|
850 res+=prefix+"output <\n" |
|
851 res+=self.output_.__str__(prefix + " ", printElemNumber) |
|
852 res+=prefix+">\n" |
|
853 return res |
|
854 |
|
855 kimage = 1 |
|
856 ktransform = 2 |
|
857 koutput = 3 |
|
858 |
|
859 _TEXT = ( |
|
860 "ErrorCode", |
|
861 "image", |
|
862 "transform", |
|
863 "output", |
|
864 ) |
|
865 |
|
866 _TYPES = ( |
|
867 ProtocolBuffer.Encoder.NUMERIC, |
|
868 ProtocolBuffer.Encoder.STRING, |
|
869 |
|
870 ProtocolBuffer.Encoder.STRING, |
|
871 |
|
872 ProtocolBuffer.Encoder.STRING, |
|
873 |
|
874 ) |
|
875 |
|
876 _STYLE = """""" |
|
877 _STYLE_CONTENT_TYPE = """""" |
|
878 class ImagesTransformResponse(ProtocolBuffer.ProtocolMessage): |
|
879 def __init__(self, contents=None): |
|
880 self.image_ = ImageData() |
|
881 self.has_image_ = 0 |
|
882 if contents is not None: self.MergeFromString(contents) |
|
883 |
|
884 def image(self): return self.image_ |
|
885 |
|
886 def mutable_image(self): self.has_image_ = 1; return self.image_ |
|
887 |
|
888 def clear_image(self):self.has_image_ = 0; self.image_.Clear() |
|
889 |
|
890 def has_image(self): return self.has_image_ |
|
891 |
|
892 |
|
893 def MergeFrom(self, x): |
|
894 assert x is not self |
|
895 if (x.has_image()): self.mutable_image().MergeFrom(x.image()) |
|
896 |
|
897 def Equals(self, x): |
|
898 if x is self: return 1 |
|
899 if self.has_image_ != x.has_image_: return 0 |
|
900 if self.has_image_ and self.image_ != x.image_: return 0 |
|
901 return 1 |
|
902 |
|
903 def __eq__(self, other): |
|
904 return (other is not None) and (other.__class__ == self.__class__) and self.Equals(other) |
|
905 |
|
906 def __ne__(self, other): |
|
907 return not (self == other) |
|
908 |
|
909 def IsInitialized(self, debug_strs=None): |
|
910 initialized = 1 |
|
911 if (not self.has_image_): |
|
912 initialized = 0 |
|
913 if debug_strs is not None: |
|
914 debug_strs.append('Required field: image not set.') |
|
915 elif not self.image_.IsInitialized(debug_strs): initialized = 0 |
|
916 return initialized |
|
917 |
|
918 def ByteSize(self): |
|
919 n = 0 |
|
920 n += self.lengthString(self.image_.ByteSize()) |
|
921 return n + 1 |
|
922 |
|
923 def Clear(self): |
|
924 self.clear_image() |
|
925 |
|
926 def OutputUnchecked(self, out): |
|
927 out.putVarInt32(10) |
|
928 out.putVarInt32(self.image_.ByteSize()) |
|
929 self.image_.OutputUnchecked(out) |
|
930 |
|
931 def TryMerge(self, d): |
|
932 while d.avail() > 0: |
|
933 tt = d.getVarInt32() |
|
934 if tt == 10: |
|
935 length = d.getVarInt32() |
|
936 tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) |
|
937 d.skip(length) |
|
938 self.mutable_image().TryMerge(tmp) |
|
939 continue |
|
940 if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError |
|
941 d.skipData(tt) |
|
942 |
|
943 |
|
944 def __str__(self, prefix="", printElemNumber=0): |
|
945 res="" |
|
946 if self.has_image_: |
|
947 res+=prefix+"image <\n" |
|
948 res+=self.image_.__str__(prefix + " ", printElemNumber) |
|
949 res+=prefix+">\n" |
|
950 return res |
|
951 |
|
952 kimage = 1 |
|
953 |
|
954 _TEXT = ( |
|
955 "ErrorCode", |
|
956 "image", |
|
957 ) |
|
958 |
|
959 _TYPES = ( |
|
960 ProtocolBuffer.Encoder.NUMERIC, |
|
961 ProtocolBuffer.Encoder.STRING, |
|
962 |
|
963 ) |
|
964 |
|
965 _STYLE = """""" |
|
966 _STYLE_CONTENT_TYPE = """""" |
|
967 |
|
968 __all__ = ['ImagesServiceError','ImagesServiceTransform','Transform','ImageData','OutputSettings','ImagesTransformRequest','ImagesTransformResponse'] |