Vega strike Python Modules doc: HTTPResponse Class Reference

All Data Structures Namespaces Files Functions Variables

Public Member Functions
def	__init__

def	begin

def	close

def	isclosed

def	read

def	getheader

Data Fields
	fp

	debuglevel

	msg

	version

	status

	reason

	chunked

	chunk_left

	length
	note: we shouldn't have any trailers! More...

	will_close

Detailed Description

Definition at line 97 of file httplib.py.

Constructor & Destructor Documentation

def __init__	(	self,
		sock,
		debuglevel = `0`
	)

Definition at line 98 of file httplib.py.

 
     def __init__(self, sock, debuglevel=0):
         self.fp = sock.makefile('rb', 0)
         self.debuglevel = debuglevel
 
         self.msg = None
 
         # from the Status-Line of the response
         self.version = _UNKNOWN # HTTP-Version
         self.status = _UNKNOWN  # Status-Code
         self.reason = _UNKNOWN  # Reason-Phrase
 
         self.chunked = _UNKNOWN         # is "chunked" being used?
         self.chunk_left = _UNKNOWN      # bytes left to read in current chunk
         self.length = _UNKNOWN          # number of bytes left in response
         self.will_close = _UNKNOWN      # conn will close at end of response

Member Function Documentation

def begin ( self)

Definition at line 114 of file httplib.py.

References HTTPResponse.chunk_left, HTTPResponse.chunked, Chunk.close(), openrsrc.close(), _Hqxcoderengine.close(), FileInput.close(), _Rlecoderengine.close(), HTTPResponse.close(), BinHex.close(), GzipFile.close(), _Hqxdecoderengine.close(), Aifc_read.close(), _Rledecoderengine.close(), HexBin.close(), file_wrapper.close(), FTP.close(), HTTPResponse.debuglevel, HTTPResponse.fp, FieldStorage.fp, HTTPResponse.length, FieldStorage.length, GetoptError.msg, HTTPResponse.msg, HTTPResponse.reason, HTTPResponse.status, HTTPResponse.version, and HTTPResponse.will_close.

 
     def begin(self):
         if self.msg is not None:
             # we've already started reading the response
             return
 
         line = self.fp.readline()
         if self.debuglevel > 0:
             print "reply:", repr(line)
         try:
             [version, status, reason] = line.split(None, 2)
         except ValueError:
             try:
                 [version, status] = line.split(None, 1)
                 reason = ""
             except ValueError:
                 version = "HTTP/0.9"
                 status = "200"
                 reason = ""
         if version[:5] != 'HTTP/':
             self.close()
             raise BadStatusLine(line)
 
         # The status code is a three-digit number
         try:
             self.status = status = int(status)
             if status < 100 or status > 999:
                 raise BadStatusLine(line)
         except ValueError:
             raise BadStatusLine(line)
         self.reason = reason.strip()
 
         if version == 'HTTP/1.0':
             self.version = 10
         elif version.startswith('HTTP/1.'):
             self.version = 11   # use HTTP/1.1 code for HTTP/1.x where x>=1
         elif version == 'HTTP/0.9':
             self.version = 9
         else:
             raise UnknownProtocol(version)
 
         if self.version == 9:
             self.msg = mimetools.Message(StringIO())
             return
 
         self.msg = mimetools.Message(self.fp, 0)
         if self.debuglevel > 0:
             for hdr in self.msg.headers:
                 print "header:", hdr,
 
         # don't let the msg keep an fp
         self.msg.fp = None
 
         # are we using the chunked-style of transfer encoding?
         tr_enc = self.msg.getheader('transfer-encoding')
         if tr_enc:
             if tr_enc.lower() != 'chunked':
                 raise UnknownTransferEncoding()
             self.chunked = 1
             self.chunk_left = None
         else:
             self.chunked = 0
 
         # will the connection close at the end of the response?
         conn = self.msg.getheader('connection')
         if conn:
             conn = conn.lower()
             # a "Connection: close" will always close the connection. if we
             # don't see that and this is not HTTP/1.1, then the connection will
             # close unless we see a Keep-Alive header.
             self.will_close = conn.find('close') != -1 or \
                               ( self.version != 11 and \
                                 not self.msg.getheader('keep-alive') )
         else:
             # for HTTP/1.1, the connection will always remain open
             # otherwise, it will remain open IFF we see a Keep-Alive header
             self.will_close = self.version != 11 and \
                               not self.msg.getheader('keep-alive')
 
         # do we have a Content-Length?
         # NOTE: RFC 2616, S4.4, #3 says we ignore this if tr_enc is "chunked"
         length = self.msg.getheader('content-length')
         if length and not self.chunked:
             try:
                 self.length = int(length)
             except ValueError:
                 self.length = None
         else:
             self.length = None
 
         # does the body have a fixed length? (of zero)
         if (status == 204 or            # No Content
             status == 304 or            # Not Modified
             100 <= status < 200):       # 1xx codes
             self.length = 0
 
         # if the connection remains open, and we aren't using chunked, and
         # a content-length was not provided, then assume that the connection
         # WILL close.
         if not self.will_close and \
            not self.chunked and \
            self.length is None:
             self.will_close = 1

def read	(	self,
		amt = `None`
	)

Definition at line 231 of file httplib.py.

References HTTPResponse._safe_read(), HTTPResponse.chunk_left, HTTPResponse.chunked, Chunk.close(), openrsrc.close(), _Hqxcoderengine.close(), FileInput.close(), _Rlecoderengine.close(), HTTPResponse.close(), BinHex.close(), GzipFile.close(), _Hqxdecoderengine.close(), Aifc_read.close(), _Rledecoderengine.close(), HexBin.close(), file_wrapper.close(), FTP.close(), HTTPResponse.fp, FieldStorage.fp, HTTPResponse.length, FieldStorage.length, and HTTPResponse.will_close.

 
     def read(self, amt=None):
         if self.fp is None:
             return ''
 
         if self.chunked:
             chunk_left = self.chunk_left
             value = ''
             while 1:
                 if chunk_left is None:
                     line = self.fp.readline()
                     i = line.find(';')
                     if i >= 0:
                         line = line[:i] # strip chunk-extensions
                     chunk_left = int(line, 16)
                     if chunk_left == 0:
                         break
                 if amt is None:
                     value = value + self._safe_read(chunk_left)
                 elif amt < chunk_left:
                     value = value + self._safe_read(amt)
                     self.chunk_left = chunk_left - amt
                     return value
                 elif amt == chunk_left:
                     value = value + self._safe_read(amt)
                     self._safe_read(2)  # toss the CRLF at the end of the chunk
                     self.chunk_left = None
                     return value
                 else:
                     value = value + self._safe_read(chunk_left)
                     amt = amt - chunk_left
 
                 # we read the whole chunk, get another
                 self._safe_read(2)      # toss the CRLF at the end of the chunk
                 chunk_left = None
 
             # read and discard trailer up to the CRLF terminator
             ### note: we shouldn't have any trailers!
             while 1:
                 line = self.fp.readline()
                 if line == '\r\n':
                     break
 
             # we read everything; close the "file"
             self.close()
 
             return value
 
         elif amt is None:
             # unbounded read
             if self.will_close:
                 s = self.fp.read()
             else:
                 s = self._safe_read(self.length)
             self.close()        # we read everything
             return s
 
         if self.length is not None:
             if amt > self.length:
                 # clip the read to the "end of response"
                 amt = self.length
             self.length = self.length - amt
 
         # we do not use _safe_read() here because this may be a .will_close
         # connection, and the user is reading more bytes than will be provided
         # (for example, reading in 1k chunks)
         s = self.fp.read(amt)
 
         return s

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation