google_appengine/google/appengine/api/urlfetch_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 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 URLFetchServiceError(ProtocolBuffer.ProtocolMessage):
  26
  27   OK           =    0
  28   INVALID_URL  =    1
  29   FETCH_ERROR  =    2
  30   UNSPECIFIED_ERROR =    3
  31   RESPONSE_TOO_LARGE =    4
  32   DEADLINE_EXCEEDED =    5
  33
  34   _ErrorCode_NAMES = {
  35     0: "OK",
  36     1: "INVALID_URL",
  37     2: "FETCH_ERROR",
  38     3: "UNSPECIFIED_ERROR",
  39     4: "RESPONSE_TOO_LARGE",
  40     5: "DEADLINE_EXCEEDED",
  41   }
  42
  43   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  44   ErrorCode_Name = classmethod(ErrorCode_Name)
  45
  46
  47   def __init__(self, contents=None):
  48     pass
  49     if contents is not None: self.MergeFromString(contents)
  50
  51
  52   def MergeFrom(self, x):
  53     assert x is not self
  54
  55   def Equals(self, x):
  56     if x is self: return 1
  57     return 1
  58
  59   def IsInitialized(self, debug_strs=None):
  60     initialized = 1
  61     return initialized
  62
  63   def ByteSize(self):
  64     n = 0
  65     return n + 0
  66
  67   def Clear(self):
  68     pass
  69
  70   def OutputUnchecked(self, out):
  71     pass
  72
  73   def TryMerge(self, d):
  74     while d.avail() > 0:
  75       tt = d.getVarInt32()
  76       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
  77       d.skipData(tt)
  78
  79
  80   def __str__(self, prefix="", printElemNumber=0):
  81     res=""
  82     return res
  83
  84
  85   def _BuildTagLookupTable(sparse, maxtag, default=None):
  86     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
  87
  88
  89   _TEXT = _BuildTagLookupTable({
  90     0: "ErrorCode",
  91   }, 0)
  92
  93   _TYPES = _BuildTagLookupTable({
  94     0: ProtocolBuffer.Encoder.NUMERIC,
  95   }, 0, ProtocolBuffer.Encoder.MAX_TYPE)
  96
  97   _STYLE = """"""
  98   _STYLE_CONTENT_TYPE = """"""
  99 class URLFetchRequest_Header(ProtocolBuffer.ProtocolMessage):
 100   has_key_ = 0
 101   key_ = ""
 102   has_value_ = 0
 103   value_ = ""
 104
 105   def __init__(self, contents=None):
 106     if contents is not None: self.MergeFromString(contents)
 107
 108   def key(self): return self.key_
 109
 110   def set_key(self, x):
 111     self.has_key_ = 1
 112     self.key_ = x
 113
 114   def clear_key(self):
 115     if self.has_key_:
 116       self.has_key_ = 0
 117       self.key_ = ""
 118
 119   def has_key(self): return self.has_key_
 120
 121   def value(self): return self.value_
 122
 123   def set_value(self, x):
 124     self.has_value_ = 1
 125     self.value_ = x
 126
 127   def clear_value(self):
 128     if self.has_value_:
 129       self.has_value_ = 0
 130       self.value_ = ""
 131
 132   def has_value(self): return self.has_value_
 133
 134
 135   def MergeFrom(self, x):
 136     assert x is not self
 137     if (x.has_key()): self.set_key(x.key())
 138     if (x.has_value()): self.set_value(x.value())
 139
 140   def Equals(self, x):
 141     if x is self: return 1
 142     if self.has_key_ != x.has_key_: return 0
 143     if self.has_key_ and self.key_ != x.key_: return 0
 144     if self.has_value_ != x.has_value_: return 0
 145     if self.has_value_ and self.value_ != x.value_: return 0
 146     return 1
 147
 148   def IsInitialized(self, debug_strs=None):
 149     initialized = 1
 150     if (not self.has_key_):
 151       initialized = 0
 152       if debug_strs is not None:
 153         debug_strs.append('Required field: key not set.')
 154     if (not self.has_value_):
 155       initialized = 0
 156       if debug_strs is not None:
 157         debug_strs.append('Required field: value not set.')
 158     return initialized
 159
 160   def ByteSize(self):
 161     n = 0
 162     n += self.lengthString(len(self.key_))
 163     n += self.lengthString(len(self.value_))
 164     return n + 2
 165
 166   def Clear(self):
 167     self.clear_key()
 168     self.clear_value()
 169
 170   def OutputUnchecked(self, out):
 171     out.putVarInt32(34)
 172     out.putPrefixedString(self.key_)
 173     out.putVarInt32(42)
 174     out.putPrefixedString(self.value_)
 175
 176   def TryMerge(self, d):
 177     while 1:
 178       tt = d.getVarInt32()
 179       if tt == 28: break
 180       if tt == 34:
 181         self.set_key(d.getPrefixedString())
 182         continue
 183       if tt == 42:
 184         self.set_value(d.getPrefixedString())
 185         continue
 186       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 187       d.skipData(tt)
 188
 189
 190   def __str__(self, prefix="", printElemNumber=0):
 191     res=""
 192     if self.has_key_: res+=prefix+("Key: %s\n" % self.DebugFormatString(self.key_))
 193     if self.has_value_: res+=prefix+("Value: %s\n" % self.DebugFormatString(self.value_))
 194     return res
 195
 196 class URLFetchRequest(ProtocolBuffer.ProtocolMessage):
 197
 198   GET          =    1
 199   POST         =    2
 200   HEAD         =    3
 201   PUT          =    4
 202   DELETE       =    5
 203
 204   _RequestMethod_NAMES = {
 205     1: "GET",
 206     2: "POST",
 207     3: "HEAD",
 208     4: "PUT",
 209     5: "DELETE",
 210   }
 211
 212   def RequestMethod_Name(cls, x): return cls._RequestMethod_NAMES.get(x, "")
 213   RequestMethod_Name = classmethod(RequestMethod_Name)
 214
 215   has_method_ = 0
 216   method_ = 0
 217   has_url_ = 0
 218   url_ = ""
 219   has_payload_ = 0
 220   payload_ = ""
 221   has_followredirects_ = 0
 222   followredirects_ = 1
 223   has_deadline_ = 0
 224   deadline_ = 0.0
 225
 226   def __init__(self, contents=None):
 227     self.header_ = []
 228     if contents is not None: self.MergeFromString(contents)
 229
 230   def method(self): return self.method_
 231
 232   def set_method(self, x):
 233     self.has_method_ = 1
 234     self.method_ = x
 235
 236   def clear_method(self):
 237     if self.has_method_:
 238       self.has_method_ = 0
 239       self.method_ = 0
 240
 241   def has_method(self): return self.has_method_
 242
 243   def url(self): return self.url_
 244
 245   def set_url(self, x):
 246     self.has_url_ = 1
 247     self.url_ = x
 248
 249   def clear_url(self):
 250     if self.has_url_:
 251       self.has_url_ = 0
 252       self.url_ = ""
 253
 254   def has_url(self): return self.has_url_
 255
 256   def header_size(self): return len(self.header_)
 257   def header_list(self): return self.header_
 258
 259   def header(self, i):
 260     return self.header_[i]
 261
 262   def mutable_header(self, i):
 263     return self.header_[i]
 264
 265   def add_header(self):
 266     x = URLFetchRequest_Header()
 267     self.header_.append(x)
 268     return x
 269
 270   def clear_header(self):
 271     self.header_ = []
 272   def payload(self): return self.payload_
 273
 274   def set_payload(self, x):
 275     self.has_payload_ = 1
 276     self.payload_ = x
 277
 278   def clear_payload(self):
 279     if self.has_payload_:
 280       self.has_payload_ = 0
 281       self.payload_ = ""
 282
 283   def has_payload(self): return self.has_payload_
 284
 285   def followredirects(self): return self.followredirects_
 286
 287   def set_followredirects(self, x):
 288     self.has_followredirects_ = 1
 289     self.followredirects_ = x
 290
 291   def clear_followredirects(self):
 292     if self.has_followredirects_:
 293       self.has_followredirects_ = 0
 294       self.followredirects_ = 1
 295
 296   def has_followredirects(self): return self.has_followredirects_
 297
 298   def deadline(self): return self.deadline_
 299
 300   def set_deadline(self, x):
 301     self.has_deadline_ = 1
 302     self.deadline_ = x
 303
 304   def clear_deadline(self):
 305     if self.has_deadline_:
 306       self.has_deadline_ = 0
 307       self.deadline_ = 0.0
 308
 309   def has_deadline(self): return self.has_deadline_
 310
 311
 312   def MergeFrom(self, x):
 313     assert x is not self
 314     if (x.has_method()): self.set_method(x.method())
 315     if (x.has_url()): self.set_url(x.url())
 316     for i in xrange(x.header_size()): self.add_header().CopyFrom(x.header(i))
 317     if (x.has_payload()): self.set_payload(x.payload())
 318     if (x.has_followredirects()): self.set_followredirects(x.followredirects())
 319     if (x.has_deadline()): self.set_deadline(x.deadline())
 320
 321   def Equals(self, x):
 322     if x is self: return 1
 323     if self.has_method_ != x.has_method_: return 0
 324     if self.has_method_ and self.method_ != x.method_: return 0
 325     if self.has_url_ != x.has_url_: return 0
 326     if self.has_url_ and self.url_ != x.url_: return 0
 327     if len(self.header_) != len(x.header_): return 0
 328     for e1, e2 in zip(self.header_, x.header_):
 329       if e1 != e2: return 0
 330     if self.has_payload_ != x.has_payload_: return 0
 331     if self.has_payload_ and self.payload_ != x.payload_: return 0
 332     if self.has_followredirects_ != x.has_followredirects_: return 0
 333     if self.has_followredirects_ and self.followredirects_ != x.followredirects_: return 0
 334     if self.has_deadline_ != x.has_deadline_: return 0
 335     if self.has_deadline_ and self.deadline_ != x.deadline_: return 0
 336     return 1
 337
 338   def IsInitialized(self, debug_strs=None):
 339     initialized = 1
 340     if (not self.has_method_):
 341       initialized = 0
 342       if debug_strs is not None:
 343         debug_strs.append('Required field: method not set.')
 344     if (not self.has_url_):
 345       initialized = 0
 346       if debug_strs is not None:
 347         debug_strs.append('Required field: url not set.')
 348     for p in self.header_:
 349       if not p.IsInitialized(debug_strs): initialized=0
 350     return initialized
 351
 352   def ByteSize(self):
 353     n = 0
 354     n += self.lengthVarInt64(self.method_)
 355     n += self.lengthString(len(self.url_))
 356     n += 2 * len(self.header_)
 357     for i in xrange(len(self.header_)): n += self.header_[i].ByteSize()
 358     if (self.has_payload_): n += 1 + self.lengthString(len(self.payload_))
 359     if (self.has_followredirects_): n += 2
 360     if (self.has_deadline_): n += 9
 361     return n + 2
 362
 363   def Clear(self):
 364     self.clear_method()
 365     self.clear_url()
 366     self.clear_header()
 367     self.clear_payload()
 368     self.clear_followredirects()
 369     self.clear_deadline()
 370
 371   def OutputUnchecked(self, out):
 372     out.putVarInt32(8)
 373     out.putVarInt32(self.method_)
 374     out.putVarInt32(18)
 375     out.putPrefixedString(self.url_)
 376     for i in xrange(len(self.header_)):
 377       out.putVarInt32(27)
 378       self.header_[i].OutputUnchecked(out)
 379       out.putVarInt32(28)
 380     if (self.has_payload_):
 381       out.putVarInt32(50)
 382       out.putPrefixedString(self.payload_)
 383     if (self.has_followredirects_):
 384       out.putVarInt32(56)
 385       out.putBoolean(self.followredirects_)
 386     if (self.has_deadline_):
 387       out.putVarInt32(65)
 388       out.putDouble(self.deadline_)
 389
 390   def TryMerge(self, d):
 391     while d.avail() > 0:
 392       tt = d.getVarInt32()
 393       if tt == 8:
 394         self.set_method(d.getVarInt32())
 395         continue
 396       if tt == 18:
 397         self.set_url(d.getPrefixedString())
 398         continue
 399       if tt == 27:
 400         self.add_header().TryMerge(d)
 401         continue
 402       if tt == 50:
 403         self.set_payload(d.getPrefixedString())
 404         continue
 405       if tt == 56:
 406         self.set_followredirects(d.getBoolean())
 407         continue
 408       if tt == 65:
 409         self.set_deadline(d.getDouble())
 410         continue
 411       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 412       d.skipData(tt)
 413
 414
 415   def __str__(self, prefix="", printElemNumber=0):
 416     res=""
 417     if self.has_method_: res+=prefix+("Method: %s\n" % self.DebugFormatInt32(self.method_))
 418     if self.has_url_: res+=prefix+("Url: %s\n" % self.DebugFormatString(self.url_))
 419     cnt=0
 420     for e in self.header_:
 421       elm=""
 422       if printElemNumber: elm="(%d)" % cnt
 423       res+=prefix+("Header%s {\n" % elm)
 424       res+=e.__str__(prefix + "  ", printElemNumber)
 425       res+=prefix+"}\n"
 426       cnt+=1
 427     if self.has_payload_: res+=prefix+("Payload: %s\n" % self.DebugFormatString(self.payload_))
 428     if self.has_followredirects_: res+=prefix+("FollowRedirects: %s\n" % self.DebugFormatBool(self.followredirects_))
 429     if self.has_deadline_: res+=prefix+("Deadline: %s\n" % self.DebugFormat(self.deadline_))
 430     return res
 431
 432
 433   def _BuildTagLookupTable(sparse, maxtag, default=None):
 434     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 435
 436   kMethod = 1
 437   kUrl = 2
 438   kHeaderGroup = 3
 439   kHeaderKey = 4
 440   kHeaderValue = 5
 441   kPayload = 6
 442   kFollowRedirects = 7
 443   kDeadline = 8
 444
 445   _TEXT = _BuildTagLookupTable({
 446     0: "ErrorCode",
 447     1: "Method",
 448     2: "Url",
 449     3: "Header",
 450     4: "Key",
 451     5: "Value",
 452     6: "Payload",
 453     7: "FollowRedirects",
 454     8: "Deadline",
 455   }, 8)
 456
 457   _TYPES = _BuildTagLookupTable({
 458     0: ProtocolBuffer.Encoder.NUMERIC,
 459     1: ProtocolBuffer.Encoder.NUMERIC,
 460     2: ProtocolBuffer.Encoder.STRING,
 461     3: ProtocolBuffer.Encoder.STARTGROUP,
 462     4: ProtocolBuffer.Encoder.STRING,
 463     5: ProtocolBuffer.Encoder.STRING,
 464     6: ProtocolBuffer.Encoder.STRING,
 465     7: ProtocolBuffer.Encoder.NUMERIC,
 466     8: ProtocolBuffer.Encoder.DOUBLE,
 467   }, 8, ProtocolBuffer.Encoder.MAX_TYPE)
 468
 469   _STYLE = """"""
 470   _STYLE_CONTENT_TYPE = """"""
 471 class URLFetchResponse_Header(ProtocolBuffer.ProtocolMessage):
 472   has_key_ = 0
 473   key_ = ""
 474   has_value_ = 0
 475   value_ = ""
 476
 477   def __init__(self, contents=None):
 478     if contents is not None: self.MergeFromString(contents)
 479
 480   def key(self): return self.key_
 481
 482   def set_key(self, x):
 483     self.has_key_ = 1
 484     self.key_ = x
 485
 486   def clear_key(self):
 487     if self.has_key_:
 488       self.has_key_ = 0
 489       self.key_ = ""
 490
 491   def has_key(self): return self.has_key_
 492
 493   def value(self): return self.value_
 494
 495   def set_value(self, x):
 496     self.has_value_ = 1
 497     self.value_ = x
 498
 499   def clear_value(self):
 500     if self.has_value_:
 501       self.has_value_ = 0
 502       self.value_ = ""
 503
 504   def has_value(self): return self.has_value_
 505
 506
 507   def MergeFrom(self, x):
 508     assert x is not self
 509     if (x.has_key()): self.set_key(x.key())
 510     if (x.has_value()): self.set_value(x.value())
 511
 512   def Equals(self, x):
 513     if x is self: return 1
 514     if self.has_key_ != x.has_key_: return 0
 515     if self.has_key_ and self.key_ != x.key_: return 0
 516     if self.has_value_ != x.has_value_: return 0
 517     if self.has_value_ and self.value_ != x.value_: return 0
 518     return 1
 519
 520   def IsInitialized(self, debug_strs=None):
 521     initialized = 1
 522     if (not self.has_key_):
 523       initialized = 0
 524       if debug_strs is not None:
 525         debug_strs.append('Required field: key not set.')
 526     if (not self.has_value_):
 527       initialized = 0
 528       if debug_strs is not None:
 529         debug_strs.append('Required field: value not set.')
 530     return initialized
 531
 532   def ByteSize(self):
 533     n = 0
 534     n += self.lengthString(len(self.key_))
 535     n += self.lengthString(len(self.value_))
 536     return n + 2
 537
 538   def Clear(self):
 539     self.clear_key()
 540     self.clear_value()
 541
 542   def OutputUnchecked(self, out):
 543     out.putVarInt32(34)
 544     out.putPrefixedString(self.key_)
 545     out.putVarInt32(42)
 546     out.putPrefixedString(self.value_)
 547
 548   def TryMerge(self, d):
 549     while 1:
 550       tt = d.getVarInt32()
 551       if tt == 28: break
 552       if tt == 34:
 553         self.set_key(d.getPrefixedString())
 554         continue
 555       if tt == 42:
 556         self.set_value(d.getPrefixedString())
 557         continue
 558       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 559       d.skipData(tt)
 560
 561
 562   def __str__(self, prefix="", printElemNumber=0):
 563     res=""
 564     if self.has_key_: res+=prefix+("Key: %s\n" % self.DebugFormatString(self.key_))
 565     if self.has_value_: res+=prefix+("Value: %s\n" % self.DebugFormatString(self.value_))
 566     return res
 567
 568 class URLFetchResponse(ProtocolBuffer.ProtocolMessage):
 569   has_content_ = 0
 570   content_ = ""
 571   has_statuscode_ = 0
 572   statuscode_ = 0
 573   has_contentwastruncated_ = 0
 574   contentwastruncated_ = 0
 575   has_externalbytessent_ = 0
 576   externalbytessent_ = 0
 577   has_externalbytesreceived_ = 0
 578   externalbytesreceived_ = 0
 579   has_finalurl_ = 0
 580   finalurl_ = ""
 581   has_apicpumilliseconds_ = 0
 582   apicpumilliseconds_ = 0
 583   has_apibytessent_ = 0
 584   apibytessent_ = 0
 585   has_apibytesreceived_ = 0
 586   apibytesreceived_ = 0
 587
 588   def __init__(self, contents=None):
 589     self.header_ = []
 590     if contents is not None: self.MergeFromString(contents)
 591
 592   def content(self): return self.content_
 593
 594   def set_content(self, x):
 595     self.has_content_ = 1
 596     self.content_ = x
 597
 598   def clear_content(self):
 599     if self.has_content_:
 600       self.has_content_ = 0
 601       self.content_ = ""
 602
 603   def has_content(self): return self.has_content_
 604
 605   def statuscode(self): return self.statuscode_
 606
 607   def set_statuscode(self, x):
 608     self.has_statuscode_ = 1
 609     self.statuscode_ = x
 610
 611   def clear_statuscode(self):
 612     if self.has_statuscode_:
 613       self.has_statuscode_ = 0
 614       self.statuscode_ = 0
 615
 616   def has_statuscode(self): return self.has_statuscode_
 617
 618   def header_size(self): return len(self.header_)
 619   def header_list(self): return self.header_
 620
 621   def header(self, i):
 622     return self.header_[i]
 623
 624   def mutable_header(self, i):
 625     return self.header_[i]
 626
 627   def add_header(self):
 628     x = URLFetchResponse_Header()
 629     self.header_.append(x)
 630     return x
 631
 632   def clear_header(self):
 633     self.header_ = []
 634   def contentwastruncated(self): return self.contentwastruncated_
 635
 636   def set_contentwastruncated(self, x):
 637     self.has_contentwastruncated_ = 1
 638     self.contentwastruncated_ = x
 639
 640   def clear_contentwastruncated(self):
 641     if self.has_contentwastruncated_:
 642       self.has_contentwastruncated_ = 0
 643       self.contentwastruncated_ = 0
 644
 645   def has_contentwastruncated(self): return self.has_contentwastruncated_
 646
 647   def externalbytessent(self): return self.externalbytessent_
 648
 649   def set_externalbytessent(self, x):
 650     self.has_externalbytessent_ = 1
 651     self.externalbytessent_ = x
 652
 653   def clear_externalbytessent(self):
 654     if self.has_externalbytessent_:
 655       self.has_externalbytessent_ = 0
 656       self.externalbytessent_ = 0
 657
 658   def has_externalbytessent(self): return self.has_externalbytessent_
 659
 660   def externalbytesreceived(self): return self.externalbytesreceived_
 661
 662   def set_externalbytesreceived(self, x):
 663     self.has_externalbytesreceived_ = 1
 664     self.externalbytesreceived_ = x
 665
 666   def clear_externalbytesreceived(self):
 667     if self.has_externalbytesreceived_:
 668       self.has_externalbytesreceived_ = 0
 669       self.externalbytesreceived_ = 0
 670
 671   def has_externalbytesreceived(self): return self.has_externalbytesreceived_
 672
 673   def finalurl(self): return self.finalurl_
 674
 675   def set_finalurl(self, x):
 676     self.has_finalurl_ = 1
 677     self.finalurl_ = x
 678
 679   def clear_finalurl(self):
 680     if self.has_finalurl_:
 681       self.has_finalurl_ = 0
 682       self.finalurl_ = ""
 683
 684   def has_finalurl(self): return self.has_finalurl_
 685
 686   def apicpumilliseconds(self): return self.apicpumilliseconds_
 687
 688   def set_apicpumilliseconds(self, x):
 689     self.has_apicpumilliseconds_ = 1
 690     self.apicpumilliseconds_ = x
 691
 692   def clear_apicpumilliseconds(self):
 693     if self.has_apicpumilliseconds_:
 694       self.has_apicpumilliseconds_ = 0
 695       self.apicpumilliseconds_ = 0
 696
 697   def has_apicpumilliseconds(self): return self.has_apicpumilliseconds_
 698
 699   def apibytessent(self): return self.apibytessent_
 700
 701   def set_apibytessent(self, x):
 702     self.has_apibytessent_ = 1
 703     self.apibytessent_ = x
 704
 705   def clear_apibytessent(self):
 706     if self.has_apibytessent_:
 707       self.has_apibytessent_ = 0
 708       self.apibytessent_ = 0
 709
 710   def has_apibytessent(self): return self.has_apibytessent_
 711
 712   def apibytesreceived(self): return self.apibytesreceived_
 713
 714   def set_apibytesreceived(self, x):
 715     self.has_apibytesreceived_ = 1
 716     self.apibytesreceived_ = x
 717
 718   def clear_apibytesreceived(self):
 719     if self.has_apibytesreceived_:
 720       self.has_apibytesreceived_ = 0
 721       self.apibytesreceived_ = 0
 722
 723   def has_apibytesreceived(self): return self.has_apibytesreceived_
 724
 725
 726   def MergeFrom(self, x):
 727     assert x is not self
 728     if (x.has_content()): self.set_content(x.content())
 729     if (x.has_statuscode()): self.set_statuscode(x.statuscode())
 730     for i in xrange(x.header_size()): self.add_header().CopyFrom(x.header(i))
 731     if (x.has_contentwastruncated()): self.set_contentwastruncated(x.contentwastruncated())
 732     if (x.has_externalbytessent()): self.set_externalbytessent(x.externalbytessent())
 733     if (x.has_externalbytesreceived()): self.set_externalbytesreceived(x.externalbytesreceived())
 734     if (x.has_finalurl()): self.set_finalurl(x.finalurl())
 735     if (x.has_apicpumilliseconds()): self.set_apicpumilliseconds(x.apicpumilliseconds())
 736     if (x.has_apibytessent()): self.set_apibytessent(x.apibytessent())
 737     if (x.has_apibytesreceived()): self.set_apibytesreceived(x.apibytesreceived())
 738
 739   def Equals(self, x):
 740     if x is self: return 1
 741     if self.has_content_ != x.has_content_: return 0
 742     if self.has_content_ and self.content_ != x.content_: return 0
 743     if self.has_statuscode_ != x.has_statuscode_: return 0
 744     if self.has_statuscode_ and self.statuscode_ != x.statuscode_: return 0
 745     if len(self.header_) != len(x.header_): return 0
 746     for e1, e2 in zip(self.header_, x.header_):
 747       if e1 != e2: return 0
 748     if self.has_contentwastruncated_ != x.has_contentwastruncated_: return 0
 749     if self.has_contentwastruncated_ and self.contentwastruncated_ != x.contentwastruncated_: return 0
 750     if self.has_externalbytessent_ != x.has_externalbytessent_: return 0
 751     if self.has_externalbytessent_ and self.externalbytessent_ != x.externalbytessent_: return 0
 752     if self.has_externalbytesreceived_ != x.has_externalbytesreceived_: return 0
 753     if self.has_externalbytesreceived_ and self.externalbytesreceived_ != x.externalbytesreceived_: return 0
 754     if self.has_finalurl_ != x.has_finalurl_: return 0
 755     if self.has_finalurl_ and self.finalurl_ != x.finalurl_: return 0
 756     if self.has_apicpumilliseconds_ != x.has_apicpumilliseconds_: return 0
 757     if self.has_apicpumilliseconds_ and self.apicpumilliseconds_ != x.apicpumilliseconds_: return 0
 758     if self.has_apibytessent_ != x.has_apibytessent_: return 0
 759     if self.has_apibytessent_ and self.apibytessent_ != x.apibytessent_: return 0
 760     if self.has_apibytesreceived_ != x.has_apibytesreceived_: return 0
 761     if self.has_apibytesreceived_ and self.apibytesreceived_ != x.apibytesreceived_: return 0
 762     return 1
 763
 764   def IsInitialized(self, debug_strs=None):
 765     initialized = 1
 766     if (not self.has_statuscode_):
 767       initialized = 0
 768       if debug_strs is not None:
 769         debug_strs.append('Required field: statuscode not set.')
 770     for p in self.header_:
 771       if not p.IsInitialized(debug_strs): initialized=0
 772     return initialized
 773
 774   def ByteSize(self):
 775     n = 0
 776     if (self.has_content_): n += 1 + self.lengthString(len(self.content_))
 777     n += self.lengthVarInt64(self.statuscode_)
 778     n += 2 * len(self.header_)
 779     for i in xrange(len(self.header_)): n += self.header_[i].ByteSize()
 780     if (self.has_contentwastruncated_): n += 2
 781     if (self.has_externalbytessent_): n += 1 + self.lengthVarInt64(self.externalbytessent_)
 782     if (self.has_externalbytesreceived_): n += 1 + self.lengthVarInt64(self.externalbytesreceived_)
 783     if (self.has_finalurl_): n += 1 + self.lengthString(len(self.finalurl_))
 784     if (self.has_apicpumilliseconds_): n += 1 + self.lengthVarInt64(self.apicpumilliseconds_)
 785     if (self.has_apibytessent_): n += 1 + self.lengthVarInt64(self.apibytessent_)
 786     if (self.has_apibytesreceived_): n += 1 + self.lengthVarInt64(self.apibytesreceived_)
 787     return n + 1
 788
 789   def Clear(self):
 790     self.clear_content()
 791     self.clear_statuscode()
 792     self.clear_header()
 793     self.clear_contentwastruncated()
 794     self.clear_externalbytessent()
 795     self.clear_externalbytesreceived()
 796     self.clear_finalurl()
 797     self.clear_apicpumilliseconds()
 798     self.clear_apibytessent()
 799     self.clear_apibytesreceived()
 800
 801   def OutputUnchecked(self, out):
 802     if (self.has_content_):
 803       out.putVarInt32(10)
 804       out.putPrefixedString(self.content_)
 805     out.putVarInt32(16)
 806     out.putVarInt32(self.statuscode_)
 807     for i in xrange(len(self.header_)):
 808       out.putVarInt32(27)
 809       self.header_[i].OutputUnchecked(out)
 810       out.putVarInt32(28)
 811     if (self.has_contentwastruncated_):
 812       out.putVarInt32(48)
 813       out.putBoolean(self.contentwastruncated_)
 814     if (self.has_externalbytessent_):
 815       out.putVarInt32(56)
 816       out.putVarInt64(self.externalbytessent_)
 817     if (self.has_externalbytesreceived_):
 818       out.putVarInt32(64)
 819       out.putVarInt64(self.externalbytesreceived_)
 820     if (self.has_finalurl_):
 821       out.putVarInt32(74)
 822       out.putPrefixedString(self.finalurl_)
 823     if (self.has_apicpumilliseconds_):
 824       out.putVarInt32(80)
 825       out.putVarInt64(self.apicpumilliseconds_)
 826     if (self.has_apibytessent_):
 827       out.putVarInt32(88)
 828       out.putVarInt64(self.apibytessent_)
 829     if (self.has_apibytesreceived_):
 830       out.putVarInt32(96)
 831       out.putVarInt64(self.apibytesreceived_)
 832
 833   def TryMerge(self, d):
 834     while d.avail() > 0:
 835       tt = d.getVarInt32()
 836       if tt == 10:
 837         self.set_content(d.getPrefixedString())
 838         continue
 839       if tt == 16:
 840         self.set_statuscode(d.getVarInt32())
 841         continue
 842       if tt == 27:
 843         self.add_header().TryMerge(d)
 844         continue
 845       if tt == 48:
 846         self.set_contentwastruncated(d.getBoolean())
 847         continue
 848       if tt == 56:
 849         self.set_externalbytessent(d.getVarInt64())
 850         continue
 851       if tt == 64:
 852         self.set_externalbytesreceived(d.getVarInt64())
 853         continue
 854       if tt == 74:
 855         self.set_finalurl(d.getPrefixedString())
 856         continue
 857       if tt == 80:
 858         self.set_apicpumilliseconds(d.getVarInt64())
 859         continue
 860       if tt == 88:
 861         self.set_apibytessent(d.getVarInt64())
 862         continue
 863       if tt == 96:
 864         self.set_apibytesreceived(d.getVarInt64())
 865         continue
 866       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 867       d.skipData(tt)
 868
 869
 870   def __str__(self, prefix="", printElemNumber=0):
 871     res=""
 872     if self.has_content_: res+=prefix+("Content: %s\n" % self.DebugFormatString(self.content_))
 873     if self.has_statuscode_: res+=prefix+("StatusCode: %s\n" % self.DebugFormatInt32(self.statuscode_))
 874     cnt=0
 875     for e in self.header_:
 876       elm=""
 877       if printElemNumber: elm="(%d)" % cnt
 878       res+=prefix+("Header%s {\n" % elm)
 879       res+=e.__str__(prefix + "  ", printElemNumber)
 880       res+=prefix+"}\n"
 881       cnt+=1
 882     if self.has_contentwastruncated_: res+=prefix+("ContentWasTruncated: %s\n" % self.DebugFormatBool(self.contentwastruncated_))
 883     if self.has_externalbytessent_: res+=prefix+("ExternalBytesSent: %s\n" % self.DebugFormatInt64(self.externalbytessent_))
 884     if self.has_externalbytesreceived_: res+=prefix+("ExternalBytesReceived: %s\n" % self.DebugFormatInt64(self.externalbytesreceived_))
 885     if self.has_finalurl_: res+=prefix+("FinalUrl: %s\n" % self.DebugFormatString(self.finalurl_))
 886     if self.has_apicpumilliseconds_: res+=prefix+("ApiCpuMilliseconds: %s\n" % self.DebugFormatInt64(self.apicpumilliseconds_))
 887     if self.has_apibytessent_: res+=prefix+("ApiBytesSent: %s\n" % self.DebugFormatInt64(self.apibytessent_))
 888     if self.has_apibytesreceived_: res+=prefix+("ApiBytesReceived: %s\n" % self.DebugFormatInt64(self.apibytesreceived_))
 889     return res
 890
 891
 892   def _BuildTagLookupTable(sparse, maxtag, default=None):
 893     return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)])
 894
 895   kContent = 1
 896   kStatusCode = 2
 897   kHeaderGroup = 3
 898   kHeaderKey = 4
 899   kHeaderValue = 5
 900   kContentWasTruncated = 6
 901   kExternalBytesSent = 7
 902   kExternalBytesReceived = 8
 903   kFinalUrl = 9
 904   kApiCpuMilliseconds = 10
 905   kApiBytesSent = 11
 906   kApiBytesReceived = 12
 907
 908   _TEXT = _BuildTagLookupTable({
 909     0: "ErrorCode",
 910     1: "Content",
 911     2: "StatusCode",
 912     3: "Header",
 913     4: "Key",
 914     5: "Value",
 915     6: "ContentWasTruncated",
 916     7: "ExternalBytesSent",
 917     8: "ExternalBytesReceived",
 918     9: "FinalUrl",
 919     10: "ApiCpuMilliseconds",
 920     11: "ApiBytesSent",
 921     12: "ApiBytesReceived",
 922   }, 12)
 923
 924   _TYPES = _BuildTagLookupTable({
 925     0: ProtocolBuffer.Encoder.NUMERIC,
 926     1: ProtocolBuffer.Encoder.STRING,
 927     2: ProtocolBuffer.Encoder.NUMERIC,
 928     3: ProtocolBuffer.Encoder.STARTGROUP,
 929     4: ProtocolBuffer.Encoder.STRING,
 930     5: ProtocolBuffer.Encoder.STRING,
 931     6: ProtocolBuffer.Encoder.NUMERIC,
 932     7: ProtocolBuffer.Encoder.NUMERIC,
 933     8: ProtocolBuffer.Encoder.NUMERIC,
 934     9: ProtocolBuffer.Encoder.STRING,
 935     10: ProtocolBuffer.Encoder.NUMERIC,
 936     11: ProtocolBuffer.Encoder.NUMERIC,
 937     12: ProtocolBuffer.Encoder.NUMERIC,
 938   }, 12, ProtocolBuffer.Encoder.MAX_TYPE)
 939
 940   _STYLE = """"""
 941   _STYLE_CONTENT_TYPE = """"""
 942
 943 __all__ = ['URLFetchServiceError','URLFetchRequest','URLFetchRequest_Header','URLFetchResponse','URLFetchResponse_Header']