thirdparty/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 from google.appengine.api.api_base_pb import *
  26 class URLFetchServiceError(ProtocolBuffer.ProtocolMessage):
  27
  28   OK           =    0
  29   INVALID_URL  =    1
  30   FETCH_ERROR  =    2
  31   UNSPECIFIED_ERROR =    3
  32   RESPONSE_TOO_LARGE =    4
  33   DEADLINE_EXCEEDED =    5
  34
  35   _ErrorCode_NAMES = {
  36     0: "OK",
  37     1: "INVALID_URL",
  38     2: "FETCH_ERROR",
  39     3: "UNSPECIFIED_ERROR",
  40     4: "RESPONSE_TOO_LARGE",
  41     5: "DEADLINE_EXCEEDED",
  42   }
  43
  44   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")
  45   ErrorCode_Name = classmethod(ErrorCode_Name)
  46
  47
  48   def __init__(self, contents=None):
  49     pass
  50     if contents is not None: self.MergeFromString(contents)
  51
  52
  53   def MergeFrom(self, x):
  54     assert x is not self
  55
  56   def Equals(self, x):
  57     if x is self: return 1
  58     return 1
  59
  60   def IsInitialized(self, debug_strs=None):
  61     initialized = 1
  62     return initialized
  63
  64   def ByteSize(self):
  65     n = 0
  66     return n + 0
  67
  68   def Clear(self):
  69     pass
  70
  71   def OutputUnchecked(self, out):
  72     pass
  73
  74   def TryMerge(self, d):
  75     while d.avail() > 0:
  76       tt = d.getVarInt32()
  77       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
  78       d.skipData(tt)
  79
  80
  81   def __str__(self, prefix="", printElemNumber=0):
  82     res=""
  83     return res
  84
  85
  86   _TEXT = (
  87    "ErrorCode",
  88   )
  89
  90   _TYPES = (
  91    ProtocolBuffer.Encoder.NUMERIC,
  92   )
  93
  94   _STYLE = """"""
  95   _STYLE_CONTENT_TYPE = """"""
  96 class URLFetchRequest_Header(ProtocolBuffer.ProtocolMessage):
  97   has_key_ = 0
  98   key_ = ""
  99   has_value_ = 0
 100   value_ = ""
 101
 102   def __init__(self, contents=None):
 103     if contents is not None: self.MergeFromString(contents)
 104
 105   def key(self): return self.key_
 106
 107   def set_key(self, x):
 108     self.has_key_ = 1
 109     self.key_ = x
 110
 111   def clear_key(self):
 112     if self.has_key_:
 113       self.has_key_ = 0
 114       self.key_ = ""
 115
 116   def has_key(self): return self.has_key_
 117
 118   def value(self): return self.value_
 119
 120   def set_value(self, x):
 121     self.has_value_ = 1
 122     self.value_ = x
 123
 124   def clear_value(self):
 125     if self.has_value_:
 126       self.has_value_ = 0
 127       self.value_ = ""
 128
 129   def has_value(self): return self.has_value_
 130
 131
 132   def MergeFrom(self, x):
 133     assert x is not self
 134     if (x.has_key()): self.set_key(x.key())
 135     if (x.has_value()): self.set_value(x.value())
 136
 137   def Equals(self, x):
 138     if x is self: return 1
 139     if self.has_key_ != x.has_key_: return 0
 140     if self.has_key_ and self.key_ != x.key_: return 0
 141     if self.has_value_ != x.has_value_: return 0
 142     if self.has_value_ and self.value_ != x.value_: return 0
 143     return 1
 144
 145   def IsInitialized(self, debug_strs=None):
 146     initialized = 1
 147     if (not self.has_key_):
 148       initialized = 0
 149       if debug_strs is not None:
 150         debug_strs.append('Required field: key not set.')
 151     if (not self.has_value_):
 152       initialized = 0
 153       if debug_strs is not None:
 154         debug_strs.append('Required field: value not set.')
 155     return initialized
 156
 157   def ByteSize(self):
 158     n = 0
 159     n += self.lengthString(len(self.key_))
 160     n += self.lengthString(len(self.value_))
 161     return n + 2
 162
 163   def Clear(self):
 164     self.clear_key()
 165     self.clear_value()
 166
 167   def OutputUnchecked(self, out):
 168     out.putVarInt32(34)
 169     out.putPrefixedString(self.key_)
 170     out.putVarInt32(42)
 171     out.putPrefixedString(self.value_)
 172
 173   def TryMerge(self, d):
 174     while 1:
 175       tt = d.getVarInt32()
 176       if tt == 28: break
 177       if tt == 34:
 178         self.set_key(d.getPrefixedString())
 179         continue
 180       if tt == 42:
 181         self.set_value(d.getPrefixedString())
 182         continue
 183       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 184       d.skipData(tt)
 185
 186
 187   def __str__(self, prefix="", printElemNumber=0):
 188     res=""
 189     if self.has_key_: res+=prefix+("Key: %s\n" % self.DebugFormatString(self.key_))
 190     if self.has_value_: res+=prefix+("Value: %s\n" % self.DebugFormatString(self.value_))
 191     return res
 192
 193 class URLFetchRequest(ProtocolBuffer.ProtocolMessage):
 194
 195   GET          =    1
 196   POST         =    2
 197   HEAD         =    3
 198   PUT          =    4
 199   DELETE       =    5
 200
 201   _RequestMethod_NAMES = {
 202     1: "GET",
 203     2: "POST",
 204     3: "HEAD",
 205     4: "PUT",
 206     5: "DELETE",
 207   }
 208
 209   def RequestMethod_Name(cls, x): return cls._RequestMethod_NAMES.get(x, "")
 210   RequestMethod_Name = classmethod(RequestMethod_Name)
 211
 212   has_method_ = 0
 213   method_ = 0
 214   has_url_ = 0
 215   url_ = ""
 216   has_payload_ = 0
 217   payload_ = ""
 218   has_followredirects_ = 0
 219   followredirects_ = 1
 220
 221   def __init__(self, contents=None):
 222     self.header_ = []
 223     if contents is not None: self.MergeFromString(contents)
 224
 225   def method(self): return self.method_
 226
 227   def set_method(self, x):
 228     self.has_method_ = 1
 229     self.method_ = x
 230
 231   def clear_method(self):
 232     if self.has_method_:
 233       self.has_method_ = 0
 234       self.method_ = 0
 235
 236   def has_method(self): return self.has_method_
 237
 238   def url(self): return self.url_
 239
 240   def set_url(self, x):
 241     self.has_url_ = 1
 242     self.url_ = x
 243
 244   def clear_url(self):
 245     if self.has_url_:
 246       self.has_url_ = 0
 247       self.url_ = ""
 248
 249   def has_url(self): return self.has_url_
 250
 251   def header_size(self): return len(self.header_)
 252   def header_list(self): return self.header_
 253
 254   def header(self, i):
 255     return self.header_[i]
 256
 257   def mutable_header(self, i):
 258     return self.header_[i]
 259
 260   def add_header(self):
 261     x = URLFetchRequest_Header()
 262     self.header_.append(x)
 263     return x
 264
 265   def clear_header(self):
 266     self.header_ = []
 267   def payload(self): return self.payload_
 268
 269   def set_payload(self, x):
 270     self.has_payload_ = 1
 271     self.payload_ = x
 272
 273   def clear_payload(self):
 274     if self.has_payload_:
 275       self.has_payload_ = 0
 276       self.payload_ = ""
 277
 278   def has_payload(self): return self.has_payload_
 279
 280   def followredirects(self): return self.followredirects_
 281
 282   def set_followredirects(self, x):
 283     self.has_followredirects_ = 1
 284     self.followredirects_ = x
 285
 286   def clear_followredirects(self):
 287     if self.has_followredirects_:
 288       self.has_followredirects_ = 0
 289       self.followredirects_ = 1
 290
 291   def has_followredirects(self): return self.has_followredirects_
 292
 293
 294   def MergeFrom(self, x):
 295     assert x is not self
 296     if (x.has_method()): self.set_method(x.method())
 297     if (x.has_url()): self.set_url(x.url())
 298     for i in xrange(x.header_size()): self.add_header().CopyFrom(x.header(i))
 299     if (x.has_payload()): self.set_payload(x.payload())
 300     if (x.has_followredirects()): self.set_followredirects(x.followredirects())
 301
 302   def Equals(self, x):
 303     if x is self: return 1
 304     if self.has_method_ != x.has_method_: return 0
 305     if self.has_method_ and self.method_ != x.method_: return 0
 306     if self.has_url_ != x.has_url_: return 0
 307     if self.has_url_ and self.url_ != x.url_: return 0
 308     if len(self.header_) != len(x.header_): return 0
 309     for e1, e2 in zip(self.header_, x.header_):
 310       if e1 != e2: return 0
 311     if self.has_payload_ != x.has_payload_: return 0
 312     if self.has_payload_ and self.payload_ != x.payload_: return 0
 313     if self.has_followredirects_ != x.has_followredirects_: return 0
 314     if self.has_followredirects_ and self.followredirects_ != x.followredirects_: return 0
 315     return 1
 316
 317   def IsInitialized(self, debug_strs=None):
 318     initialized = 1
 319     if (not self.has_method_):
 320       initialized = 0
 321       if debug_strs is not None:
 322         debug_strs.append('Required field: method not set.')
 323     if (not self.has_url_):
 324       initialized = 0
 325       if debug_strs is not None:
 326         debug_strs.append('Required field: url not set.')
 327     for p in self.header_:
 328       if not p.IsInitialized(debug_strs): initialized=0
 329     return initialized
 330
 331   def ByteSize(self):
 332     n = 0
 333     n += self.lengthVarInt64(self.method_)
 334     n += self.lengthString(len(self.url_))
 335     n += 2 * len(self.header_)
 336     for i in xrange(len(self.header_)): n += self.header_[i].ByteSize()
 337     if (self.has_payload_): n += 1 + self.lengthString(len(self.payload_))
 338     if (self.has_followredirects_): n += 2
 339     return n + 2
 340
 341   def Clear(self):
 342     self.clear_method()
 343     self.clear_url()
 344     self.clear_header()
 345     self.clear_payload()
 346     self.clear_followredirects()
 347
 348   def OutputUnchecked(self, out):
 349     out.putVarInt32(8)
 350     out.putVarInt32(self.method_)
 351     out.putVarInt32(18)
 352     out.putPrefixedString(self.url_)
 353     for i in xrange(len(self.header_)):
 354       out.putVarInt32(27)
 355       self.header_[i].OutputUnchecked(out)
 356       out.putVarInt32(28)
 357     if (self.has_payload_):
 358       out.putVarInt32(50)
 359       out.putPrefixedString(self.payload_)
 360     if (self.has_followredirects_):
 361       out.putVarInt32(56)
 362       out.putBoolean(self.followredirects_)
 363
 364   def TryMerge(self, d):
 365     while d.avail() > 0:
 366       tt = d.getVarInt32()
 367       if tt == 8:
 368         self.set_method(d.getVarInt32())
 369         continue
 370       if tt == 18:
 371         self.set_url(d.getPrefixedString())
 372         continue
 373       if tt == 27:
 374         self.add_header().TryMerge(d)
 375         continue
 376       if tt == 50:
 377         self.set_payload(d.getPrefixedString())
 378         continue
 379       if tt == 56:
 380         self.set_followredirects(d.getBoolean())
 381         continue
 382       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 383       d.skipData(tt)
 384
 385
 386   def __str__(self, prefix="", printElemNumber=0):
 387     res=""
 388     if self.has_method_: res+=prefix+("Method: %s\n" % self.DebugFormatInt32(self.method_))
 389     if self.has_url_: res+=prefix+("Url: %s\n" % self.DebugFormatString(self.url_))
 390     cnt=0
 391     for e in self.header_:
 392       elm=""
 393       if printElemNumber: elm="(%d)" % cnt
 394       res+=prefix+("Header%s {\n" % elm)
 395       res+=e.__str__(prefix + "  ", printElemNumber)
 396       res+=prefix+"}\n"
 397       cnt+=1
 398     if self.has_payload_: res+=prefix+("Payload: %s\n" % self.DebugFormatString(self.payload_))
 399     if self.has_followredirects_: res+=prefix+("FollowRedirects: %s\n" % self.DebugFormatBool(self.followredirects_))
 400     return res
 401
 402   kMethod = 1
 403   kUrl = 2
 404   kHeaderGroup = 3
 405   kHeaderKey = 4
 406   kHeaderValue = 5
 407   kPayload = 6
 408   kFollowRedirects = 7
 409
 410   _TEXT = (
 411    "ErrorCode",
 412    "Method",
 413    "Url",
 414    "Header",
 415    "Key",
 416    "Value",
 417    "Payload",
 418    "FollowRedirects",
 419   )
 420
 421   _TYPES = (
 422    ProtocolBuffer.Encoder.NUMERIC,
 423    ProtocolBuffer.Encoder.NUMERIC,
 424
 425    ProtocolBuffer.Encoder.STRING,
 426
 427    ProtocolBuffer.Encoder.STARTGROUP,
 428
 429    ProtocolBuffer.Encoder.STRING,
 430
 431    ProtocolBuffer.Encoder.STRING,
 432
 433    ProtocolBuffer.Encoder.STRING,
 434
 435    ProtocolBuffer.Encoder.NUMERIC,
 436
 437   )
 438
 439   _STYLE = """"""
 440   _STYLE_CONTENT_TYPE = """"""
 441 class URLFetchResponse_Header(ProtocolBuffer.ProtocolMessage):
 442   has_key_ = 0
 443   key_ = ""
 444   has_value_ = 0
 445   value_ = ""
 446
 447   def __init__(self, contents=None):
 448     if contents is not None: self.MergeFromString(contents)
 449
 450   def key(self): return self.key_
 451
 452   def set_key(self, x):
 453     self.has_key_ = 1
 454     self.key_ = x
 455
 456   def clear_key(self):
 457     if self.has_key_:
 458       self.has_key_ = 0
 459       self.key_ = ""
 460
 461   def has_key(self): return self.has_key_
 462
 463   def value(self): return self.value_
 464
 465   def set_value(self, x):
 466     self.has_value_ = 1
 467     self.value_ = x
 468
 469   def clear_value(self):
 470     if self.has_value_:
 471       self.has_value_ = 0
 472       self.value_ = ""
 473
 474   def has_value(self): return self.has_value_
 475
 476
 477   def MergeFrom(self, x):
 478     assert x is not self
 479     if (x.has_key()): self.set_key(x.key())
 480     if (x.has_value()): self.set_value(x.value())
 481
 482   def Equals(self, x):
 483     if x is self: return 1
 484     if self.has_key_ != x.has_key_: return 0
 485     if self.has_key_ and self.key_ != x.key_: return 0
 486     if self.has_value_ != x.has_value_: return 0
 487     if self.has_value_ and self.value_ != x.value_: return 0
 488     return 1
 489
 490   def IsInitialized(self, debug_strs=None):
 491     initialized = 1
 492     if (not self.has_key_):
 493       initialized = 0
 494       if debug_strs is not None:
 495         debug_strs.append('Required field: key not set.')
 496     if (not self.has_value_):
 497       initialized = 0
 498       if debug_strs is not None:
 499         debug_strs.append('Required field: value not set.')
 500     return initialized
 501
 502   def ByteSize(self):
 503     n = 0
 504     n += self.lengthString(len(self.key_))
 505     n += self.lengthString(len(self.value_))
 506     return n + 2
 507
 508   def Clear(self):
 509     self.clear_key()
 510     self.clear_value()
 511
 512   def OutputUnchecked(self, out):
 513     out.putVarInt32(34)
 514     out.putPrefixedString(self.key_)
 515     out.putVarInt32(42)
 516     out.putPrefixedString(self.value_)
 517
 518   def TryMerge(self, d):
 519     while 1:
 520       tt = d.getVarInt32()
 521       if tt == 28: break
 522       if tt == 34:
 523         self.set_key(d.getPrefixedString())
 524         continue
 525       if tt == 42:
 526         self.set_value(d.getPrefixedString())
 527         continue
 528       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError
 529       d.skipData(tt)
 530
 531
 532   def __str__(self, prefix="", printElemNumber=0):
 533     res=""
 534     if self.has_key_: res+=prefix+("Key: %s\n" % self.DebugFormatString(self.key_))
 535     if self.has_value_: res+=prefix+("Value: %s\n" % self.DebugFormatString(self.value_))
 536     return res
 537
 538 class URLFetchResponse(ProtocolBuffer.ProtocolMessage):
 539   has_content_ = 0
 540   content_ = ""
 541   has_statuscode_ = 0
 542   statuscode_ = 0
 543   has_contentwastruncated_ = 0
 544   contentwastruncated_ = 0
 545
 546   def __init__(self, contents=None):
 547     self.header_ = []
 548     if contents is not None: self.MergeFromString(contents)
 549
 550   def content(self): return self.content_
 551
 552   def set_content(self, x):
 553     self.has_content_ = 1
 554     self.content_ = x
 555
 556   def clear_content(self):
 557     if self.has_content_:
 558       self.has_content_ = 0
 559       self.content_ = ""
 560
 561   def has_content(self): return self.has_content_
 562
 563   def statuscode(self): return self.statuscode_
 564
 565   def set_statuscode(self, x):
 566     self.has_statuscode_ = 1
 567     self.statuscode_ = x
 568
 569   def clear_statuscode(self):
 570     if self.has_statuscode_:
 571       self.has_statuscode_ = 0
 572       self.statuscode_ = 0
 573
 574   def has_statuscode(self): return self.has_statuscode_
 575
 576   def header_size(self): return len(self.header_)
 577   def header_list(self): return self.header_
 578
 579   def header(self, i):
 580     return self.header_[i]
 581
 582   def mutable_header(self, i):
 583     return self.header_[i]
 584
 585   def add_header(self):
 586     x = URLFetchResponse_Header()
 587     self.header_.append(x)
 588     return x
 589
 590   def clear_header(self):
 591     self.header_ = []
 592   def contentwastruncated(self): return self.contentwastruncated_
 593
 594   def set_contentwastruncated(self, x):
 595     self.has_contentwastruncated_ = 1
 596     self.contentwastruncated_ = x
 597
 598   def clear_contentwastruncated(self):
 599     if self.has_contentwastruncated_:
 600       self.has_contentwastruncated_ = 0
 601       self.contentwastruncated_ = 0
 602
 603   def has_contentwastruncated(self): return self.has_contentwastruncated_
 604
 605
 606   def MergeFrom(self, x):
 607     assert x is not self
 608     if (x.has_content()): self.set_content(x.content())
 609     if (x.has_statuscode()): self.set_statuscode(x.statuscode())
 610     for i in xrange(x.header_size()): self.add_header().CopyFrom(x.header(i))
 611     if (x.has_contentwastruncated()): self.set_contentwastruncated(x.contentwastruncated())
 612
 613   def Equals(self, x):
 614     if x is self: return 1
 615     if self.has_content_ != x.has_content_: return 0
 616     if self.has_content_ and self.content_ != x.content_: return 0
 617     if self.has_statuscode_ != x.has_statuscode_: return 0
 618     if self.has_statuscode_ and self.statuscode_ != x.statuscode_: return 0
 619     if len(self.header_) != len(x.header_): return 0
 620     for e1, e2 in zip(self.header_, x.header_):
 621       if e1 != e2: return 0
 622     if self.has_contentwastruncated_ != x.has_contentwastruncated_: return 0
 623     if self.has_contentwastruncated_ and self.contentwastruncated_ != x.contentwastruncated_: return 0
 624     return 1
 625
 626   def IsInitialized(self, debug_strs=None):
 627     initialized = 1
 628     if (not self.has_statuscode_):
 629       initialized = 0
 630       if debug_strs is not None:
 631         debug_strs.append('Required field: statuscode not set.')
 632     for p in self.header_:
 633       if not p.IsInitialized(debug_strs): initialized=0
 634     return initialized
 635
 636   def ByteSize(self):
 637     n = 0
 638     if (self.has_content_): n += 1 + self.lengthString(len(self.content_))
 639     n += self.lengthVarInt64(self.statuscode_)
 640     n += 2 * len(self.header_)
 641     for i in xrange(len(self.header_)): n += self.header_[i].ByteSize()
 642     if (self.has_contentwastruncated_): n += 2
 643     return n + 1
 644
 645   def Clear(self):
 646     self.clear_content()
 647     self.clear_statuscode()
 648     self.clear_header()
 649     self.clear_contentwastruncated()
 650
 651   def OutputUnchecked(self, out):
 652     if (self.has_content_):
 653       out.putVarInt32(10)
 654       out.putPrefixedString(self.content_)
 655     out.putVarInt32(16)
 656     out.putVarInt32(self.statuscode_)
 657     for i in xrange(len(self.header_)):
 658       out.putVarInt32(27)
 659       self.header_[i].OutputUnchecked(out)
 660       out.putVarInt32(28)
 661     if (self.has_contentwastruncated_):
 662       out.putVarInt32(48)
 663       out.putBoolean(self.contentwastruncated_)
 664
 665   def TryMerge(self, d):
 666     while d.avail() > 0:
 667       tt = d.getVarInt32()
 668       if tt == 10:
 669         self.set_content(d.getPrefixedString())
 670         continue
 671       if tt == 16:
 672         self.set_statuscode(d.getVarInt32())
 673         continue
 674       if tt == 27:
 675         self.add_header().TryMerge(d)
 676         continue
 677       if tt == 48:
 678         self.set_contentwastruncated(d.getBoolean())
 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_content_: res+=prefix+("Content: %s\n" % self.DebugFormatString(self.content_))
 687     if self.has_statuscode_: res+=prefix+("StatusCode: %s\n" % self.DebugFormatInt32(self.statuscode_))
 688     cnt=0
 689     for e in self.header_:
 690       elm=""
 691       if printElemNumber: elm="(%d)" % cnt
 692       res+=prefix+("Header%s {\n" % elm)
 693       res+=e.__str__(prefix + "  ", printElemNumber)
 694       res+=prefix+"}\n"
 695       cnt+=1
 696     if self.has_contentwastruncated_: res+=prefix+("ContentWasTruncated: %s\n" % self.DebugFormatBool(self.contentwastruncated_))
 697     return res
 698
 699   kContent = 1
 700   kStatusCode = 2
 701   kHeaderGroup = 3
 702   kHeaderKey = 4
 703   kHeaderValue = 5
 704   kContentWasTruncated = 6
 705
 706   _TEXT = (
 707    "ErrorCode",
 708    "Content",
 709    "StatusCode",
 710    "Header",
 711    "Key",
 712    "Value",
 713    "ContentWasTruncated",
 714   )
 715
 716   _TYPES = (
 717    ProtocolBuffer.Encoder.NUMERIC,
 718    ProtocolBuffer.Encoder.STRING,
 719
 720    ProtocolBuffer.Encoder.NUMERIC,
 721
 722    ProtocolBuffer.Encoder.STARTGROUP,
 723
 724    ProtocolBuffer.Encoder.STRING,
 725
 726    ProtocolBuffer.Encoder.STRING,
 727
 728    ProtocolBuffer.Encoder.NUMERIC,
 729
 730   )
 731
 732   _STYLE = """"""
 733   _STYLE_CONTENT_TYPE = """"""
 734
 735 __all__ = ['URLFetchServiceError','URLFetchRequest','URLFetchRequest_Header','URLFetchResponse','URLFetchResponse_Header']