no changes other than indentation level (now 4) and comment reflow.

use "cvs diff -b" to verify.

2 files changed, 1067 insertions, 1058 deletions

diff --git a/Lib/httplib.py b/Lib/httplib.py
index 5c0dacd..2a9546f 100644
--- a/Lib/httplib.py
+++ b/Lib/httplib.py
@@ -77,9 +77,9 @@ import string
 import mimetools
 
 try:
-  from cStringIO import StringIO
+    from cStringIO import StringIO
 except ImportError:
-  from StringIO import StringIO
+    from StringIO import StringIO
 
 HTTP_PORT = 80
 HTTPS_PORT = 443
@@ -93,632 +93,636 @@ _CS_REQ_SENT = 'Request-sent'
 
 
 class HTTPResponse:
-  def __init__(self, sock):
-    self.fp = sock.makefile('rb', 0)
-
-    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	# connection will close at end of response
-
-  def begin(self):
-    if self.msg is not None:
-      # we've already started reading the response
-      return
-
-    line = self.fp.readline()
-    try:
-      [version, status, reason] = string.split(line, None, 2)
-    except ValueError:
-      try:
-        [version, status] = string.split(line, None, 1)
-        reason = ""
-      except ValueError:
-        self.close()
-        raise BadStatusLine(line)
-    if version[:5] != 'HTTP/':
-      self.close()
-      raise BadStatusLine(line)
-
-    self.status = status = int(status)
-    self.reason = string.strip(reason)
-
-    if version == 'HTTP/1.0':
-      self.version = 10
-    elif version[:7] == 'HTTP/1.':
-      self.version = 11	# use HTTP/1.1 code for HTTP/1.x where x>=1
-    else:
-      raise UnknownProtocol(version)
-
-    self.msg = mimetools.Message(self.fp, 0)
-
-    # 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 string.lower(tr_enc) != '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 = string.lower(conn)
-      # 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 = string.find(conn, '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:
-      self.length = int(length)
-    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
-
-    # if there is no body, then close NOW. read() may never be called, thus
-    # we will never mark self as closed.
-    if self.length == 0:
-      self.close()
-
-  def close(self):
-    if self.fp:
-      self.fp.close()
-      self.fp = None
-
-  def isclosed(self):
-    # NOTE: it is possible that we will not ever call self.close(). This
-    #       case occurs when will_close is TRUE, length is None, and we
-    #       read up to the last byte, but NOT past it.
-    #
-    # IMPLIES: if will_close is FALSE, then self.close() will ALWAYS be
-    #          called, meaning self.isclosed() is meaningful.
-    return self.fp is None
-
-  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 = string.find(line, ';')
-          if i >= 0:
-            line = line[:i]	# strip chunk-extensions
-          chunk_left = string.atoi(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
+    def __init__(self, sock):
+        self.fp = sock.makefile('rb', 0)
+
+        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
 
-        # we read the whole chunk, get another
-        self._safe_read(2)	# toss the CRLF at the end of the chunk
-        chunk_left = None
+        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
+
+    def begin(self):
+        if self.msg is not None:
+            # we've already started reading the response
+            return
 
-      # 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)
-
-    # close our "file" if we know we should
-    ### I'm not sure about the len(s) < amt part; we should be safe because
-    ### we shouldn't be using non-blocking sockets
-    if self.length == 0 or len(s) < amt:
-      self.close()
-
-    return s
-
-  def _safe_read(self, amt):
-    """Read the number of bytes requested, compensating for partial reads.
-
-    Normally, we have a blocking socket, but a read() can be interrupted
-    by a signal (resulting in a partial read).
-
-    Note that we cannot distinguish between EOF and an interrupt when zero
-    bytes have been read. IncompleteRead() will be raised in this situation.
-
-    This function should be used when <amt> bytes "should" be present for
-    reading. If the bytes are truly not available (due to EOF), then the
-    IncompleteRead exception can be used to detect the problem.
-    """
-    s = ''
-    while amt > 0:
-      chunk = self.fp.read(amt)
-      if not chunk:
-        raise IncompleteRead(s)
-      s = s + chunk
-      amt = amt - len(chunk)
-    return s
+        try:
+            [version, status, reason] = string.split(line, None, 2)
+        except ValueError:
+            try:
+                [version, status] = string.split(line, None, 1)
+                reason = ""
+            except ValueError:
+                self.close()
+                raise BadStatusLine(line)
+        if version[:5] != 'HTTP/':
+            self.close()
+            raise BadStatusLine(line)
+
+        self.status = status = int(status)
+        self.reason = string.strip(reason)
+
+        if version == 'HTTP/1.0':
+            self.version = 10
+        elif version[:7] == 'HTTP/1.':
+            self.version = 11	# use HTTP/1.1 code for HTTP/1.x where x>=1
+        else:
+            raise UnknownProtocol(version)
 
-  def getheader(self, name, default=None):
-    if self.msg is None:
-      raise ResponseNotReady()
-    return self.msg.getheader(name, default)
+        self.msg = mimetools.Message(self.fp, 0)
+
+        # 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 string.lower(tr_enc) != '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 = string.lower(conn)
+            # 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 = string.find(conn, '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:
+            self.length = int(length)
+        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
+
+        # if there is no body, then close NOW. read() may never be called, thus
+        # we will never mark self as closed.
+        if self.length == 0:
+            self.close()
+
+    def close(self):
+        if self.fp:
+            self.fp.close()
+            self.fp = None
+
+    def isclosed(self):
+        # NOTE: it is possible that we will not ever call self.close(). This
+        #       case occurs when will_close is TRUE, length is None, and we
+        #       read up to the last byte, but NOT past it.
+        #
+        # IMPLIES: if will_close is FALSE, then self.close() will ALWAYS be
+        #          called, meaning self.isclosed() is meaningful.
+        return self.fp is None
+
+    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 = string.find(line, ';')
+                    if i >= 0:
+                        line = line[:i]	# strip chunk-extensions
+                    chunk_left = string.atoi(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)
+
+        # close our "file" if we know we should
+        ### I'm not sure about the len(s) < amt part; we should be safe because
+        ### we shouldn't be using non-blocking sockets
+        if self.length == 0 or len(s) < amt:
+            self.close()
+
+        return s
+
+    def _safe_read(self, amt):
+        """Read the number of bytes requested, compensating for partial reads.
+
+        Normally, we have a blocking socket, but a read() can be interrupted
+        by a signal (resulting in a partial read).
+
+        Note that we cannot distinguish between EOF and an interrupt when zero
+        bytes have been read. IncompleteRead() will be raised in this
+        situation.
+
+        This function should be used when <amt> bytes "should" be present for
+        reading. If the bytes are truly not available (due to EOF), then the
+        IncompleteRead exception can be used to detect the problem.
+        """
+        s = ''
+        while amt > 0:
+            chunk = self.fp.read(amt)
+            if not chunk:
+                raise IncompleteRead(s)
+            s = s + chunk
+            amt = amt - len(chunk)
+        return s
+
+    def getheader(self, name, default=None):
+        if self.msg is None:
+            raise ResponseNotReady()
+        return self.msg.getheader(name, default)
 
 
 class HTTPConnection:
 
-  _http_vsn = 11
-  _http_vsn_str = 'HTTP/1.1'
-
-  response_class = HTTPResponse
-  default_port = HTTP_PORT
-  auto_open = 1
-
-  def __init__(self, host, port=None):
-    self.sock = None
-    self.__response = None
-    self.__state = _CS_IDLE
-
-    self._set_hostport(host, port)
-
-  def _set_hostport(self, host, port):
-    if port is None:
-      i = string.find(host, ':')
-      if i >= 0:
-        port = int(host[i+1:])
-        host = host[:i]
-      else:
-        port = self.default_port
-    self.host = host
-    self.port = port
-
-  def connect(self):
-    """Connect to the host and port specified in __init__."""
-    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    self.sock.connect((self.host, self.port))
-
-  def close(self):
-    """Close the connection to the HTTP server."""
-    if self.sock:
-      self.sock.close()	# close it manually... there may be other refs
-      self.sock = None
-    if self.__response:
-      self.__response.close()
-      self.__response = None
-    self.__state = _CS_IDLE
-
-  def send(self, str):
-    """Send `str' to the server."""
-    if self.sock is None:
-      if self.auto_open:
-        self.connect()
-      else:
-        raise NotConnected()
-
-    # send the data to the server. if we get a broken pipe, then close
-    # the socket. we want to reconnect when somebody tries to send again.
-    #
-    # NOTE: we DO propagate the error, though, because we cannot simply
-    #       ignore the error... the caller will know if they can retry.
-    try:
-      self.sock.send(str)
-    except socket.error, v:
-      if v[0] == 32:	# Broken pipe
-        self.close()
-      raise
-
-  def putrequest(self, method, url):
-    """Send a request to the server.
-
-    `method' specifies an HTTP request method, e.g. 'GET'.
-    `url' specifies the object being requested, e.g. '/index.html'.
-    """
+    _http_vsn = 11
+    _http_vsn_str = 'HTTP/1.1'
+
+    response_class = HTTPResponse
+    default_port = HTTP_PORT
+    auto_open = 1
+
+    def __init__(self, host, port=None):
+        self.sock = None
+        self.__response = None
+        self.__state = _CS_IDLE
+
+        self._set_hostport(host, port)
+
+    def _set_hostport(self, host, port):
+        if port is None:
+            i = string.find(host, ':')
+            if i >= 0:
+                port = int(host[i+1:])
+                host = host[:i]
+            else:
+                port = self.default_port
+        self.host = host
+        self.port = port
+
+    def connect(self):
+        """Connect to the host and port specified in __init__."""
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.connect((self.host, self.port))
+
+    def close(self):
+        """Close the connection to the HTTP server."""
+        if self.sock:
+            self.sock.close()	# close it manually... there may be other refs
+            self.sock = None
+        if self.__response:
+            self.__response.close()
+            self.__response = None
+        self.__state = _CS_IDLE
+
+    def send(self, str):
+        """Send `str' to the server."""
+        if self.sock is None:
+            if self.auto_open:
+                self.connect()
+            else:
+                raise NotConnected()
+
+        # send the data to the server. if we get a broken pipe, then close
+        # the socket. we want to reconnect when somebody tries to send again.
+        #
+        # NOTE: we DO propagate the error, though, because we cannot simply
+        #       ignore the error... the caller will know if they can retry.
+        try:
+            self.sock.send(str)
+        except socket.error, v:
+            if v[0] == 32:	# Broken pipe
+                self.close()
+            raise
+
+    def putrequest(self, method, url):
+        """Send a request to the server.
+
+        `method' specifies an HTTP request method, e.g. 'GET'.
+        `url' specifies the object being requested, e.g. '/index.html'.
+        """
+
+        # check if a prior response has been completed
+        if self.__response and self.__response.isclosed():
+            self.__response = None
+
+        #
+        # in certain cases, we cannot issue another request on this connection.
+        # this occurs when:
+        #   1) we are in the process of sending a request.   (_CS_REQ_STARTED)
+        #   2) a response to a previous request has signalled that it is going
+        #      to close the connection upon completion.
+        #   3) the headers for the previous response have not been read, thus
+        #      we cannot determine whether point (2) is true.   (_CS_REQ_SENT)
+        #
+        # if there is no prior response, then we can request at will.
+        #
+        # if point (2) is true, then we will have passed the socket to the
+        # response (effectively meaning, "there is no prior response"), and
+        # will open a new one when a new request is made.
+        #
+        # Note: if a prior response exists, then we *can* start a new request.
+        #       We are not allowed to begin fetching the response to this new
+        #       request, however, until that prior response is complete.
+        #
+        if self.__state == _CS_IDLE:
+            self.__state = _CS_REQ_STARTED
+        else:
+            raise CannotSendRequest()
+
+        if not url:
+            url = '/'
+        str = '%s %s %s\r\n' % (method, url, self._http_vsn_str)
+
+        try:
+            self.send(str)
+        except socket.error, v:
+            # trap 'Broken pipe' if we're allowed to automatically reconnect
+            if v[0] != 32 or not self.auto_open:
+                raise
+            # try one more time (the socket was closed; this will reopen)
+            self.send(str)
+
+        if self._http_vsn == 11:
+            # Issue some standard headers for better HTTP/1.1 compliance
+
+            # this header is issued *only* for HTTP/1.1 connections. more
+            # specifically, this means it is only issued when the client uses
+            # the new HTTPConnection() class. backwards-compat clients will
+            # be using HTTP/1.0 and those clients may be issuing this header
+            # themselves. we should NOT issue it twice; some web servers (such
+            # as Apache) barf when they see two Host: headers
+            self.putheader('Host', self.host)
+
+            # note: we are assuming that clients will not attempt to set these
+            #       headers since *this* library must deal with the
+            #       consequences. this also means that when the supporting
+            #       libraries are updated to recognize other forms, then this
+            #       code should be changed (removed or updated).
+
+            # we only want a Content-Encoding of "identity" since we don't
+            # support encodings such as x-gzip or x-deflate.
+            self.putheader('Accept-Encoding', 'identity')
+
+            # we can accept "chunked" Transfer-Encodings, but no others
+            # NOTE: no TE header implies *only* "chunked"
+            #self.putheader('TE', 'chunked')
+
+            # if TE is supplied in the header, then it must appear in a
+            # Connection header.
+            #self.putheader('Connection', 'TE')
 
-    # check if a prior response has been completed
-    if self.__response and self.__response.isclosed():
-      self.__response = None
-
-    #
-    # in certain cases, we cannot issue another request on this connection.
-    # this occurs when:
-    #   1) we are in the process of sending a request.   (_CS_REQ_STARTED)
-    #   2) a response to a previous request has signalled that it is going
-    #      to close the connection upon completion.
-    #   3) the headers for the previous response have not been read, thus
-    #      we cannot determine whether point (2) is true.   (_CS_REQ_SENT)
-    #
-    # if there is no prior response, then we can request at will.
-    #
-    # if point (2) is true, then we will have passed the socket to the
-    # response (effectively meaning, "there is no prior response"), and will
-    # open a new one when a new request is made.
-    #
-    # Note: if a prior response exists, then we *can* start a new request.
-    #       We are not allowed to begin fetching the response to this new
-    #       request, however, until that prior response is complete.
-    #
-    if self.__state == _CS_IDLE:
-      self.__state = _CS_REQ_STARTED
-    else:
-      raise CannotSendRequest()
-
-    if not url:
-      url = '/'
-    str = '%s %s %s\r\n' % (method, url, self._http_vsn_str)
-
-    try:
-      self.send(str)
-    except socket.error, v:
-      # trap 'Broken pipe' if we're allowed to automatically reconnect
-      if v[0] != 32 or not self.auto_open:
-        raise
-      # try one more time (the socket was closed; this will reopen)
-      self.send(str)
-
-    if self._http_vsn == 11:
-      # Issue some standard headers for better HTTP/1.1 compliance
-
-      # this header is issued *only* for HTTP/1.1 connections. more
-      # specifically, this means it is only issued when the client uses
-      # the new HTTPConnection() class. backwards-compat clients will
-      # be using HTTP/1.0 and those clients may be issuing this header
-      # themselves. we should NOT issue it twice; some web servers (such
-      # as Apache) barf when they see two Host: headers
-      self.putheader('Host', self.host)
-
-      # note: we are assuming that clients will not attempt to set these
-      #       headers since *this* library must deal with the consequences.
-      #       this also means that when the supporting libraries are
-      #       updated to recognize other forms, then this code should be
-      #       changed (removed or updated).
-
-      # we only want a Content-Encoding of "identity" since we don't
-      # support encodings such as x-gzip or x-deflate.
-      self.putheader('Accept-Encoding', 'identity')
-
-      # we can accept "chunked" Transfer-Encodings, but no others
-      # NOTE: no TE header implies *only* "chunked"
-      #self.putheader('TE', 'chunked')
-
-      # if TE is supplied in the header, then it must appear in a
-      # Connection header.
-      #self.putheader('Connection', 'TE')
-
-    else:
-      # For HTTP/1.0, the server will assume "not chunked"
-      pass
-
-  def putheader(self, header, value):
-    """Send a request header line to the server.
-
-    For example: h.putheader('Accept', 'text/html')
-    """
-    if self.__state != _CS_REQ_STARTED:
-      raise CannotSendHeader()
-
-    str = '%s: %s\r\n' % (header, value)
-    self.send(str)
-
-  def endheaders(self):
-    """Indicate that the last header line has been sent to the server."""
-
-    if self.__state == _CS_REQ_STARTED:
-      self.__state = _CS_REQ_SENT
-    else:
-      raise CannotSendHeader()
-
-    self.send('\r\n')
-
-  def request(self, method, url, body=None, headers={}):
-    """Send a complete request to the server."""
-
-    try:
-      self._send_request(method, url, body, headers)
-    except socket.error, v:
-      # trap 'Broken pipe' if we're allowed to automatically reconnect
-      if v[0] != 32 or not self.auto_open:
-        raise
-      # try one more time
-      self._send_request(method, url, body, headers)
-
-  def _send_request(self, method, url, body, headers):
-    self.putrequest(method, url)
-
-    if body:
-      self.putheader('Content-Length', str(len(body)))
-    for hdr, value in headers.items():
-      self.putheader(hdr, value)
-    self.endheaders()
-
-    if body:
-      self.send(body)
-
-  def getresponse(self):
-    "Get the response from the server."
-
-    # check if a prior response has been completed
-    if self.__response and self.__response.isclosed():
-      self.__response = None
-
-    #
-    # if a prior response exists, then it must be completed (otherwise, we
-    # cannot read this response's header to determine the connection-close
-    # behavior)
-    #
-    # note: if a prior response existed, but was connection-close, then the
-    # socket and response were made independent of this HTTPConnection object
-    # since a new request requires that we open a whole new connection
-    #
-    # this means the prior response had one of two states:
-    #   1) will_close: this connection was reset and the prior socket and
-    #                  response operate independently
-    #   2) persistent: the response was retained and we await its isclosed()
-    #                  status to become true.
-    #
-    if self.__state != _CS_REQ_SENT or self.__response:
-      raise ResponseNotReady()
-
-    response = self.response_class(self.sock)
-
-    response.begin()
-    self.__state = _CS_IDLE
-
-    if response.will_close:
-      # this effectively passes the connection to the response
-      self.close()
-    else:
-      # remember this, so we can tell when it is complete
-      self.__response = response
-
-    return response
+        else:
+            # For HTTP/1.0, the server will assume "not chunked"
+            pass
+
+    def putheader(self, header, value):
+        """Send a request header line to the server.
+
+        For example: h.putheader('Accept', 'text/html')
+        """
+        if self.__state != _CS_REQ_STARTED:
+            raise CannotSendHeader()
+
+        str = '%s: %s\r\n' % (header, value)
+        self.send(str)
+
+    def endheaders(self):
+        """Indicate that the last header line has been sent to the server."""
+
+        if self.__state == _CS_REQ_STARTED:
+            self.__state = _CS_REQ_SENT
+        else:
+            raise CannotSendHeader()
+
+        self.send('\r\n')
+
+    def request(self, method, url, body=None, headers={}):
+        """Send a complete request to the server."""
+
+        try:
+            self._send_request(method, url, body, headers)
+        except socket.error, v:
+            # trap 'Broken pipe' if we're allowed to automatically reconnect
+            if v[0] != 32 or not self.auto_open:
+                raise
+            # try one more time
+            self._send_request(method, url, body, headers)
+
+    def _send_request(self, method, url, body, headers):
+        self.putrequest(method, url)
+
+        if body:
+            self.putheader('Content-Length', str(len(body)))
+        for hdr, value in headers.items():
+            self.putheader(hdr, value)
+        self.endheaders()
+
+        if body:
+            self.send(body)
+
+    def getresponse(self):
+        "Get the response from the server."
+
+        # check if a prior response has been completed
+        if self.__response and self.__response.isclosed():
+            self.__response = None
+
+        #
+        # if a prior response exists, then it must be completed (otherwise, we
+        # cannot read this response's header to determine the connection-close
+        # behavior)
+        #
+        # note: if a prior response existed, but was connection-close, then the
+        # socket and response were made independent of this HTTPConnection
+        # object since a new request requires that we open a whole new
+        # connection
+        #
+        # this means the prior response had one of two states:
+        #   1) will_close: this connection was reset and the prior socket and
+        #                  response operate independently
+        #   2) persistent: the response was retained and we await its
+        #                  isclosed() status to become true.
+        #
+        if self.__state != _CS_REQ_SENT or self.__response:
+            raise ResponseNotReady()
+
+        response = self.response_class(self.sock)
+
+        response.begin()
+        self.__state = _CS_IDLE
+
+        if response.will_close:
+            # this effectively passes the connection to the response
+            self.close()
+        else:
+            # remember this, so we can tell when it is complete
+            self.__response = response
+
+        return response
 
 
 class FakeSocket:
-  def __init__(self, sock, ssl):
-    self.__sock = sock
-    self.__ssl = ssl
+    def __init__(self, sock, ssl):
+        self.__sock = sock
+        self.__ssl = ssl
 
-  def makefile(self, mode):           # hopefully, never have to write
-    if mode != 'r' and mode != 'rb':
-      raise UnimplementedFileMode()
+    def makefile(self, mode):           # hopefully, never have to write
+        if mode != 'r' and mode != 'rb':
+            raise UnimplementedFileMode()
 
-    msgbuf = ""
-    while 1:
-      try:
-        msgbuf = msgbuf + self.__ssl.read()
-      except socket.sslerror, msg:
-        break
-    return StringIO(msgbuf)
+        msgbuf = ""
+        while 1:
+            try:
+                msgbuf = msgbuf + self.__ssl.read()
+            except socket.sslerror, msg:
+                break
+        return StringIO(msgbuf)
 
-  def send(self, stuff, flags = 0):
-    return self.__ssl.write(stuff)
+    def send(self, stuff, flags = 0):
+        return self.__ssl.write(stuff)
 
-  def recv(self, len = 1024, flags = 0):
-    return self.__ssl.read(len)
+    def recv(self, len = 1024, flags = 0):
+        return self.__ssl.read(len)
 
-  def __getattr__(self, attr):
-    return getattr(self.__sock, attr)
+    def __getattr__(self, attr):
+        return getattr(self.__sock, attr)
 
 
 class HTTPSConnection(HTTPConnection):
-  "This class allows communication via SSL."
-
-  default_port = HTTPS_PORT
-
-  def __init__(self, host, port=None, **x509):
-    keys = x509.keys()
-    try:
-      keys.remove('key_file')
-    except ValueError:
-      pass
-    try:
-      keys.remove('cert_file')
-    except ValueError:
-      pass
-    if keys:
-      raise IllegalKeywordArgument()
-    HTTPConnection.__init__(self, host, port)
-    self.key_file = x509.get('key_file')
-    self.cert_file = x509.get('cert_file')
-
-  def connect(self):
-    "Connect to a host on a given (SSL) port."
-
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.connect((self.host, self.port))
-    ssl = socket.ssl(sock, self.key_file, self.cert_file)
-    self.sock = FakeSocket(sock, ssl)
+    "This class allows communication via SSL."
+
+    default_port = HTTPS_PORT
+
+    def __init__(self, host, port=None, **x509):
+        keys = x509.keys()
+        try:
+            keys.remove('key_file')
+        except ValueError:
+            pass
+        try:
+            keys.remove('cert_file')
+        except ValueError:
+            pass
+        if keys:
+            raise IllegalKeywordArgument()
+        HTTPConnection.__init__(self, host, port)
+        self.key_file = x509.get('key_file')
+        self.cert_file = x509.get('cert_file')
+
+    def connect(self):
+        "Connect to a host on a given (SSL) port."
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((self.host, self.port))
+        ssl = socket.ssl(sock, self.key_file, self.cert_file)
+        self.sock = FakeSocket(sock, ssl)
 
 
 class HTTP(HTTPConnection):
-  "Compatibility class with httplib.py from 1.5."
+    "Compatibility class with httplib.py from 1.5."
 
-  _http_vsn = 10
-  _http_vsn_str = 'HTTP/1.0'
+    _http_vsn = 10
+    _http_vsn_str = 'HTTP/1.0'
 
-  debuglevel = 0
+    debuglevel = 0
 
-  def __init__(self, host='', port=None, **x509):
-    "Provide a default host, since the superclass requires one."
+    def __init__(self, host='', port=None, **x509):
+        "Provide a default host, since the superclass requires one."
 
-    # some joker passed 0 explicitly, meaning default port
-    if port == 0:
-      port = None
+        # some joker passed 0 explicitly, meaning default port
+        if port == 0:
+            port = None
 
-    # Note that we may pass an empty string as the host; this will throw
-    # an error when we attempt to connect. Presumably, the client code
-    # will call connect before then, with a proper host.
-    HTTPConnection.__init__(self, host, port)
+        # Note that we may pass an empty string as the host; this will throw
+        # an error when we attempt to connect. Presumably, the client code
+        # will call connect before then, with a proper host.
+        HTTPConnection.__init__(self, host, port)
 
-    # we never actually use these for anything, but we keep them here for
-    # compatibility with post-1.5.2 CVS.
-    self.key_file = x509.get('key_file')
-    self.cert_file = x509.get('cert_file')
+        # we never actually use these for anything, but we keep them here for
+        # compatibility with post-1.5.2 CVS.
+        self.key_file = x509.get('key_file')
+        self.cert_file = x509.get('cert_file')
 
-    self.file = None
+        self.file = None
 
-  def connect(self, host=None, port=None):
-    "Accept arguments to set the host/port, since the superclass doesn't."
+    def connect(self, host=None, port=None):
+        "Accept arguments to set the host/port, since the superclass doesn't."
 
-    if host is not None:
-      self._set_hostport(host, port)
-    HTTPConnection.connect(self)
+        if host is not None:
+            self._set_hostport(host, port)
+        HTTPConnection.connect(self)
 
-  def set_debuglevel(self, debuglevel):
-    "The class no longer supports the debuglevel."
-    pass
+    def set_debuglevel(self, debuglevel):
+        "The class no longer supports the debuglevel."
+        pass
 
-  def getfile(self):
-    "Provide a getfile, since the superclass' does not use this concept."
-    return self.file
+    def getfile(self):
+        "Provide a getfile, since the superclass' does not use this concept."
+        return self.file
 
-  def putheader(self, header, *values):
-    "The superclass allows only one value argument."
-    HTTPConnection.putheader(self, header, string.joinfields(values, '\r\n\t'))
+    def putheader(self, header, *values):
+        "The superclass allows only one value argument."
+        HTTPConnection.putheader(self, header,
+                                 string.joinfields(values, '\r\n\t'))
 
-  def getreply(self):
-    """Compat definition since superclass does not define it.
+    def getreply(self):
+        """Compat definition since superclass does not define it.
 
-    Returns a tuple consisting of:
-    - server status code (e.g. '200' if all goes well)
-    - server "reason" corresponding to status code
-    - any RFC822 headers in the response from the server
-    """
-    try:
-      response = self.getresponse()
-    except BadStatusLine, e:
-      ### hmm. if getresponse() ever closes the socket on a bad request,
-      ### then we are going to have problems with self.sock
+        Returns a tuple consisting of:
+        - server status code (e.g. '200' if all goes well)
+        - server "reason" corresponding to status code
+        - any RFC822 headers in the response from the server
+        """
+        try:
+            response = self.getresponse()
+        except BadStatusLine, e:
+            ### hmm. if getresponse() ever closes the socket on a bad request,
+            ### then we are going to have problems with self.sock
 
-      ### should we keep this behavior? do people use it?
-      # keep the socket open (as a file), and return it
-      self.file = self.sock.makefile('rb', 0)
+            ### should we keep this behavior? do people use it?
+            # keep the socket open (as a file), and return it
+            self.file = self.sock.makefile('rb', 0)
 
-      # close our socket -- we want to restart after any protocol error
-      self.close()
+            # close our socket -- we want to restart after any protocol error
+            self.close()
 
-      self.headers = None
-      return -1, e.line, None
+            self.headers = None
+            return -1, e.line, None
 
-    self.headers = response.msg
-    self.file = response.fp
-    return response.status, response.reason, response.msg
+        self.headers = response.msg
+        self.file = response.fp
+        return response.status, response.reason, response.msg
 
-  def close(self):
-    HTTPConnection.close(self)
+    def close(self):
+        HTTPConnection.close(self)
 
-    # note that self.file == response.fp, which gets closed by the
-    # superclass. just clear the object ref here.
-    ### hmm. messy. if status==-1, then self.file is owned by us.
-    ### well... we aren't explicitly closing, but losing this ref will do it
-    self.file = None
+        # note that self.file == response.fp, which gets closed by the
+        # superclass. just clear the object ref here.
+        ### hmm. messy. if status==-1, then self.file is owned by us.
+        ### well... we aren't explicitly closing, but losing this ref will
+        ### do it
+        self.file = None
 
 
 class HTTPException(Exception):
-  pass
+    pass
 
 class NotConnected(HTTPException):
-  pass
+    pass
 
 class UnknownProtocol(HTTPException):
-  def __init__(self, version):
-    self.version = version
+    def __init__(self, version):
+        self.version = version
 
 class UnknownTransferEncoding(HTTPException):
-  pass
+    pass
 
 class IllegalKeywordArgument(HTTPException):
-  pass
+    pass
 
 class UnimplementedFileMode(HTTPException):
-  pass
+    pass
 
 class IncompleteRead(HTTPException):
-  def __init__(self, partial):
-    self.partial = partial
+    def __init__(self, partial):
+        self.partial = partial
 
 class ImproperConnectionState(HTTPException):
-  pass
+    pass
 
 class CannotSendRequest(ImproperConnectionState):
-  pass
+    pass
 
 class CannotSendHeader(ImproperConnectionState):
-  pass
+    pass
 
 class ResponseNotReady(ImproperConnectionState):
-  pass
+    pass
 
 class BadStatusLine(HTTPException):
-  def __init__(self, line):
-    self.line = line
+    def __init__(self, line):
+        self.line = line
 
 # for backwards compatibility
 error = HTTPException
@@ -760,19 +764,19 @@ def test():
     print h.getfile().read()
 
     if hasattr(socket, 'ssl'):
-      host = 'www.c2.net'
-      hs = HTTPS()
-      hs.connect(host)
-      hs.putrequest('GET', selector)
-      hs.endheaders()
-      status, reason, headers = hs.getreply()
-      print 'status =', status
-      print 'reason =', reason
-      print
-      if headers:
-          for header in headers.headers: print string.strip(header)
-      print
-      print hs.getfile().read()
+        host = 'www.c2.net'
+        hs = HTTPS()
+        hs.connect(host)
+        hs.putrequest('GET', selector)
+        hs.endheaders()
+        status, reason, headers = hs.getreply()
+        print 'status =', status
+        print 'reason =', reason
+        print
+        if headers:
+            for header in headers.headers: print string.strip(header)
+        print
+        print hs.getfile().read()
 
 
 if __name__ == '__main__':
diff --git a/Lib/imputil.py b/Lib/imputil.py
index b2a643a..d442d9f 100644
--- a/Lib/imputil.py
+++ b/Lib/imputil.py
@@ -18,346 +18,351 @@ _StringType = type('')
 _ModuleType = type(sys)		### doesn't work in JPython...
 
 class ImportManager:
-  "Manage the import process."
-
-  def install(self, namespace=vars(__builtin__)):
-    "Install this ImportManager into the specified namespace."
-
-    if isinstance(namespace, _ModuleType):
-      namespace = vars(namespace)
-
-    ### Note that we have no notion of "uninstall" or "chaining"
-
-    namespace['__import__'] = self._import_hook
-    ### fix this
-    #namespace['reload'] = self._reload_hook
-
-  def add_suffix(self, suffix, importFunc):
-    assert callable(importFunc)
-    self.fs_imp.add_suffix(suffix, importFunc)
-
-  ######################################################################
-  #
-  # PRIVATE METHODS
-  #
-  
-  clsFilesystemImporter = None
-
-  def __init__(self, fs_imp=None):
-    # we're definitely going to be importing something in the future,
-    # so let's just load the OS-related facilities.
-    if not _os_stat:
-      _os_bootstrap()
-
-    # This is the Importer that we use for grabbing stuff from the
-    # filesystem. It defines one more method (import_from_dir) for our use.
-    if not fs_imp:
-      cls = self.clsFilesystemImporter or _FilesystemImporter
-      fs_imp = cls()
-    self.fs_imp = fs_imp
-
-    # Initialize the set of suffixes that we recognize and import.
-    # The default will import dynamic-load modules first, followed by
-    # .py files (or a .py file's cached bytecode)
-    for desc in imp.get_suffixes():
-      if desc[2] == imp.C_EXTENSION:
-        self.add_suffix(desc[0], DynLoadSuffixImporter(desc).import_file)
-    self.add_suffix('.py', py_suffix_importer)
-
-  def _import_hook(self, fqname, globals=None, locals=None, fromlist=None):
-    """Python calls this hook to locate and import a module."""
-
-    parts = strop.split(fqname, '.')
-
-    # determine the context of this import
-    parent = self._determine_import_context(globals)
-
-    # if there is a parent, then its importer should manage this import
-    if parent:
-      module = parent.__importer__._do_import(parent, parts, fromlist)
-      if module:
-        return module
+    "Manage the import process."
 
-    # has the top module already been imported?
-    try:
-      top_module = sys.modules[parts[0]]
-    except KeyError:
+    def install(self, namespace=vars(__builtin__)):
+        "Install this ImportManager into the specified namespace."
 
-      # look for the topmost module
-      top_module = self._import_top_module(parts[0])
-      if not top_module:
-        # the topmost module wasn't found at all.
-        raise ImportError, 'No module named ' + fqname
+        if isinstance(namespace, _ModuleType):
+            namespace = vars(namespace)
 
-    # fast-path simple imports
-    if len(parts) == 1:
-      if not fromlist:
-        return top_module
+        ### Note that we have no notion of "uninstall" or "chaining"
 
-      if not top_module.__dict__.get('__ispkg__'):
-        # __ispkg__ isn't defined (the module was not imported by us), or
-        # it is zero.
-        #
-        # In the former case, there is no way that we could import
-        # sub-modules that occur in the fromlist (but we can't raise an
-        # error because it may just be names) because we don't know how
-        # to deal with packages that were imported by other systems.
-        #
-        # In the latter case (__ispkg__ == 0), there can't be any sub-
-        # modules present, so we can just return.
-        #
-        # In both cases, since len(parts) == 1, the top_module is also
-        # the "bottom" which is the defined return when a fromlist exists.
-        return top_module
-
-    importer = top_module.__dict__.get('__importer__')
-    if importer:
-      return importer._finish_import(top_module, parts[1:], fromlist)
-
-    # If the importer does not exist, then we have to bail. A missing importer
-    # means that something else imported the module, and we have no knowledge
-    # of how to get sub-modules out of the thing.
-    raise ImportError, 'No module named ' + fqname
-
-  def _determine_import_context(self, globals):
-    """Returns the context in which a module should be imported.
-
-    The context could be a loaded (package) module and the imported module
-    will be looked for within that package. The context could also be None,
-    meaning there is no context -- the module should be looked for as a
-    "top-level" module.
-    """
+        namespace['__import__'] = self._import_hook
+        ### fix this
+        #namespace['reload'] = self._reload_hook
 
-    if not globals or not globals.get('__importer__'):
-      # globals does not refer to one of our modules or packages. That
-      # implies there is no relative import context (as far as we are
-      # concerned), and it should just pick it off the standard path.
-      return None
-
-    # The globals refer to a module or package of ours. It will define
-    # the context of the new import. Get the module/package fqname.
-    parent_fqname = globals['__name__']
-
-    # if a package is performing the import, then return itself (imports
-    # refer to pkg contents)
-    if globals['__ispkg__']:
-      parent = sys.modules[parent_fqname]
-      assert globals is parent.__dict__
-      return parent
-
-    i = strop.rfind(parent_fqname, '.')
-
-    # a module outside of a package has no particular import context
-    if i == -1:
-      return None
-
-    # if a module in a package is performing the import, then return the
-    # package (imports refer to siblings)
-    parent_fqname = parent_fqname[:i]
-    parent = sys.modules[parent_fqname]
-    assert parent.__name__ == parent_fqname
-    return parent
-
-  def _import_top_module(self, name):
-    # scan sys.path looking for a location in the filesystem that contains
-    # the module, or an Importer object that can import the module.
-    for item in sys.path:
-      if isinstance(item, _StringType):
-        module = self.fs_imp.import_from_dir(item, name)
-      else:
-        module = item.import_top(name)
-      if module:
-        return module
-    return None
+    def add_suffix(self, suffix, importFunc):
+        assert callable(importFunc)
+        self.fs_imp.add_suffix(suffix, importFunc)
 
-  def _reload_hook(self, module):
-    "Python calls this hook to reload a module."
+    ######################################################################
+    #
+    # PRIVATE METHODS
+    #
 
-    # reloading of a module may or may not be possible (depending on the
-    # importer), but at least we can validate that it's ours to reload
-    importer = module.__dict__.get('__importer__')
-    if not importer:
-      ### oops. now what...
-      pass
+    clsFilesystemImporter = None
+
+    def __init__(self, fs_imp=None):
+        # we're definitely going to be importing something in the future,
+        # so let's just load the OS-related facilities.
+        if not _os_stat:
+            _os_bootstrap()
+
+        # This is the Importer that we use for grabbing stuff from the
+        # filesystem. It defines one more method (import_from_dir) for our use.
+        if not fs_imp:
+            cls = self.clsFilesystemImporter or _FilesystemImporter
+            fs_imp = cls()
+        self.fs_imp = fs_imp
+
+        # Initialize the set of suffixes that we recognize and import.
+        # The default will import dynamic-load modules first, followed by
+        # .py files (or a .py file's cached bytecode)
+        for desc in imp.get_suffixes():
+            if desc[2] == imp.C_EXTENSION:
+                self.add_suffix(desc[0],
+                                DynLoadSuffixImporter(desc).import_file)
+        self.add_suffix('.py', py_suffix_importer)
+
+    def _import_hook(self, fqname, globals=None, locals=None, fromlist=None):
+        """Python calls this hook to locate and import a module."""
+
+        parts = strop.split(fqname, '.')
+
+        # determine the context of this import
+        parent = self._determine_import_context(globals)
+
+        # if there is a parent, then its importer should manage this import
+        if parent:
+            module = parent.__importer__._do_import(parent, parts, fromlist)
+            if module:
+                return module
+
+        # has the top module already been imported?
+        try:
+            top_module = sys.modules[parts[0]]
+        except KeyError:
+
+            # look for the topmost module
+            top_module = self._import_top_module(parts[0])
+            if not top_module:
+                # the topmost module wasn't found at all.
+                raise ImportError, 'No module named ' + fqname
+
+        # fast-path simple imports
+        if len(parts) == 1:
+            if not fromlist:
+                return top_module
+
+            if not top_module.__dict__.get('__ispkg__'):
+                # __ispkg__ isn't defined (the module was not imported by us),
+                # or it is zero.
+                #
+                # In the former case, there is no way that we could import
+                # sub-modules that occur in the fromlist (but we can't raise an
+                # error because it may just be names) because we don't know how
+                # to deal with packages that were imported by other systems.
+                #
+                # In the latter case (__ispkg__ == 0), there can't be any sub-
+                # modules present, so we can just return.
+                #
+                # In both cases, since len(parts) == 1, the top_module is also
+                # the "bottom" which is the defined return when a fromlist
+                # exists.
+                return top_module
+
+        importer = top_module.__dict__.get('__importer__')
+        if importer:
+            return importer._finish_import(top_module, parts[1:], fromlist)
+
+        # If the importer does not exist, then we have to bail. A missing
+        # importer means that something else imported the module, and we have
+        # no knowledge of how to get sub-modules out of the thing.
+        raise ImportError, 'No module named ' + fqname
 
-    # okay. it is using the imputil system, and we must delegate it, but
-    # we don't know what to do (yet)
-    ### we should blast the module dict and do another get_code(). need to
-    ### flesh this out and add proper docco...
-    raise SystemError, "reload not yet implemented"
+    def _determine_import_context(self, globals):
+        """Returns the context in which a module should be imported.
+
+        The context could be a loaded (package) module and the imported module
+        will be looked for within that package. The context could also be None,
+        meaning there is no context -- the module should be looked for as a
+        "top-level" module.
+        """
+
+        if not globals or not globals.get('__importer__'):
+            # globals does not refer to one of our modules or packages. That
+            # implies there is no relative import context (as far as we are
+            # concerned), and it should just pick it off the standard path.
+            return None
+
+        # The globals refer to a module or package of ours. It will define
+        # the context of the new import. Get the module/package fqname.
+        parent_fqname = globals['__name__']
+
+        # if a package is performing the import, then return itself (imports
+        # refer to pkg contents)
+        if globals['__ispkg__']:
+            parent = sys.modules[parent_fqname]
+            assert globals is parent.__dict__
+            return parent
+
+        i = strop.rfind(parent_fqname, '.')
+
+        # a module outside of a package has no particular import context
+        if i == -1:
+            return None
+
+        # if a module in a package is performing the import, then return the
+        # package (imports refer to siblings)
+        parent_fqname = parent_fqname[:i]
+        parent = sys.modules[parent_fqname]
+        assert parent.__name__ == parent_fqname
+        return parent
+
+    def _import_top_module(self, name):
+        # scan sys.path looking for a location in the filesystem that contains
+        # the module, or an Importer object that can import the module.
+        for item in sys.path:
+            if isinstance(item, _StringType):
+                module = self.fs_imp.import_from_dir(item, name)
+            else:
+                module = item.import_top(name)
+            if module:
+                return module
+        return None
+
+    def _reload_hook(self, module):
+        "Python calls this hook to reload a module."
+
+        # reloading of a module may or may not be possible (depending on the
+        # importer), but at least we can validate that it's ours to reload
+        importer = module.__dict__.get('__importer__')
+        if not importer:
+            ### oops. now what...
+            pass
+
+        # okay. it is using the imputil system, and we must delegate it, but
+        # we don't know what to do (yet)
+        ### we should blast the module dict and do another get_code(). need to
+        ### flesh this out and add proper docco...
+        raise SystemError, "reload not yet implemented"
 
 
 class Importer:
-  "Base class for replacing standard import functions."
-
-  def import_top(self, name):
-    "Import a top-level module."
-    return self._import_one(None, name, name)
-
-  ######################################################################
-  #
-  # PRIVATE METHODS
-  #
-  def _finish_import(self, top, parts, fromlist):
-    # if "a.b.c" was provided, then load the ".b.c" portion down from
-    # below the top-level module.
-    bottom = self._load_tail(top, parts)
-
-    # if the form is "import a.b.c", then return "a"
-    if not fromlist:
-      # no fromlist: return the top of the import tree
-      return top
-
-    # the top module was imported by self.
-    #
-    # this means that the bottom module was also imported by self (just
-    # now, or in the past and we fetched it from sys.modules).
-    #
-    # since we imported/handled the bottom module, this means that we can
-    # also handle its fromlist (and reliably use __ispkg__).
+    "Base class for replacing standard import functions."
 
-    # if the bottom node is a package, then (potentially) import some modules.
-    #
-    # note: if it is not a package, then "fromlist" refers to names in
-    #       the bottom module rather than modules.
-    # note: for a mix of names and modules in the fromlist, we will
-    #       import all modules and insert those into the namespace of
-    #       the package module. Python will pick up all fromlist names
-    #       from the bottom (package) module; some will be modules that
-    #       we imported and stored in the namespace, others are expected
-    #       to be present already.
-    if bottom.__ispkg__:
-      self._import_fromlist(bottom, fromlist)
-
-    # if the form is "from a.b import c, d" then return "b"
-    return bottom
-
-  def _import_one(self, parent, modname, fqname):
-    "Import a single module."
-
-    # has the module already been imported?
-    try:
-      return sys.modules[fqname]
-    except KeyError:
-      pass
-
-    # load the module's code, or fetch the module itself
-    result = self.get_code(parent, modname, fqname)
-    if result is None:
-      return None
+    def import_top(self, name):
+        "Import a top-level module."
+        return self._import_one(None, name, name)
 
-    module = self._process_result(result, fqname)
+    ######################################################################
+    #
+    # PRIVATE METHODS
+    #
+    def _finish_import(self, top, parts, fromlist):
+        # if "a.b.c" was provided, then load the ".b.c" portion down from
+        # below the top-level module.
+        bottom = self._load_tail(top, parts)
 
-    # insert the module into its parent
-    if parent:
-      setattr(parent, modname, module)
-    return module
+        # if the form is "import a.b.c", then return "a"
+        if not fromlist:
+            # no fromlist: return the top of the import tree
+            return top
 
-  def _process_result(self, (ispkg, code, values), fqname):
-    # did get_code() return an actual module? (rather than a code object)
-    is_module = isinstance(code, _ModuleType)
+        # the top module was imported by self.
+        #
+        # this means that the bottom module was also imported by self (just
+        # now, or in the past and we fetched it from sys.modules).
+        #
+        # since we imported/handled the bottom module, this means that we can
+        # also handle its fromlist (and reliably use __ispkg__).
 
-    # use the returned module, or create a new one to exec code into
-    if is_module:
-      module = code
-    else:
-      module = imp.new_module(fqname)
+        # if the bottom node is a package, then (potentially) import some
+        # modules.
+        #
+        # note: if it is not a package, then "fromlist" refers to names in
+        #       the bottom module rather than modules.
+        # note: for a mix of names and modules in the fromlist, we will
+        #       import all modules and insert those into the namespace of
+        #       the package module. Python will pick up all fromlist names
+        #       from the bottom (package) module; some will be modules that
+        #       we imported and stored in the namespace, others are expected
+        #       to be present already.
+        if bottom.__ispkg__:
+            self._import_fromlist(bottom, fromlist)
+
+        # if the form is "from a.b import c, d" then return "b"
+        return bottom
+
+    def _import_one(self, parent, modname, fqname):
+        "Import a single module."
+
+        # has the module already been imported?
+        try:
+            return sys.modules[fqname]
+        except KeyError:
+            pass
+
+        # load the module's code, or fetch the module itself
+        result = self.get_code(parent, modname, fqname)
+        if result is None:
+            return None
+
+        module = self._process_result(result, fqname)
+
+        # insert the module into its parent
+        if parent:
+            setattr(parent, modname, module)
+        return module
 
-    ### record packages a bit differently??
-    module.__importer__ = self
-    module.__ispkg__ = ispkg
+    def _process_result(self, (ispkg, code, values), fqname):
+        # did get_code() return an actual module? (rather than a code object)
+        is_module = isinstance(code, _ModuleType)
 
-    # insert additional values into the module (before executing the code)
-    module.__dict__.update(values)
+        # use the returned module, or create a new one to exec code into
+        if is_module:
+            module = code
+        else:
+            module = imp.new_module(fqname)
 
-    # the module is almost ready... make it visible
-    sys.modules[fqname] = module
+        ### record packages a bit differently??
+        module.__importer__ = self
+        module.__ispkg__ = ispkg
 
-    # execute the code within the module's namespace
-    if not is_module:
-      exec code in module.__dict__
+        # insert additional values into the module (before executing the code)
+        module.__dict__.update(values)
 
-    return module
+        # the module is almost ready... make it visible
+        sys.modules[fqname] = module
 
-  def _load_tail(self, m, parts):
-    """Import the rest of the modules, down from the top-level module.
+        # execute the code within the module's namespace
+        if not is_module:
+            exec code in module.__dict__
 
-    Returns the last module in the dotted list of modules.
-    """
-    for part in parts:
-      fqname = "%s.%s" % (m.__name__, part)
-      m = self._import_one(m, part, fqname)
-      if not m:
-        raise ImportError, "No module named " + fqname
-    return m
-
-  def _import_fromlist(self, package, fromlist):
-    'Import any sub-modules in the "from" list.'
-
-    # if '*' is present in the fromlist, then look for the '__all__' variable
-    # to find additional items (modules) to import.
-    if '*' in fromlist:
-      fromlist = list(fromlist) + list(package.__dict__.get('__all__', []))
-
-    for sub in fromlist:
-      # if the name is already present, then don't try to import it (it
-      # might not be a module!).
-      if sub != '*' and not hasattr(package, sub):
-        subname = "%s.%s" % (package.__name__, sub)
-        submod = self._import_one(package, sub, subname)
-        if not submod:
-          raise ImportError, "cannot import name " + subname
-
-  def _do_import(self, parent, parts, fromlist):
-    """Attempt to import the module relative to parent.
-
-    This method is used when the import context specifies that <self>
-    imported the parent module.
-    """
-    top_name = parts[0]
-    top_fqname = parent.__name__ + '.' + top_name
-    top_module = self._import_one(parent, top_name, top_fqname)
-    if not top_module:
-      # this importer and parent could not find the module (relatively)
-      return None
-
-    return self._finish_import(top_module, parts[1:], fromlist)
+        return module
 
-  ######################################################################
-  #
-  # METHODS TO OVERRIDE
-  #
-  def get_code(self, parent, modname, fqname):
-    """Find and retrieve the code for the given module.
+    def _load_tail(self, m, parts):
+        """Import the rest of the modules, down from the top-level module.
+
+        Returns the last module in the dotted list of modules.
+        """
+        for part in parts:
+            fqname = "%s.%s" % (m.__name__, part)
+            m = self._import_one(m, part, fqname)
+            if not m:
+                raise ImportError, "No module named " + fqname
+        return m
+
+    def _import_fromlist(self, package, fromlist):
+        'Import any sub-modules in the "from" list.'
+
+        # if '*' is present in the fromlist, then look for the '__all__'
+        # variable to find additional items (modules) to import.
+        if '*' in fromlist:
+            fromlist = list(fromlist) + \
+                       list(package.__dict__.get('__all__', []))
+
+        for sub in fromlist:
+            # if the name is already present, then don't try to import it (it
+            # might not be a module!).
+            if sub != '*' and not hasattr(package, sub):
+                subname = "%s.%s" % (package.__name__, sub)
+                submod = self._import_one(package, sub, subname)
+                if not submod:
+                    raise ImportError, "cannot import name " + subname
+
+    def _do_import(self, parent, parts, fromlist):
+        """Attempt to import the module relative to parent.
+
+        This method is used when the import context specifies that <self>
+        imported the parent module.
+        """
+        top_name = parts[0]
+        top_fqname = parent.__name__ + '.' + top_name
+        top_module = self._import_one(parent, top_name, top_fqname)
+        if not top_module:
+            # this importer and parent could not find the module (relatively)
+            return None
+
+        return self._finish_import(top_module, parts[1:], fromlist)
+
+    ######################################################################
+    #
+    # METHODS TO OVERRIDE
+    #
+    def get_code(self, parent, modname, fqname):
+        """Find and retrieve the code for the given module.
 
-    parent specifies a parent module to define a context for importing. It
-    may be None, indicating no particular context for the search.
+        parent specifies a parent module to define a context for importing. It
+        may be None, indicating no particular context for the search.
 
-    modname specifies a single module (not dotted) within the parent.
+        modname specifies a single module (not dotted) within the parent.
 
-    fqname specifies the fully-qualified module name. This is a (potentially)
-    dotted name from the "root" of the module namespace down to the modname.
-    If there is no parent, then modname==fqname.
+        fqname specifies the fully-qualified module name. This is a
+        (potentially) dotted name from the "root" of the module namespace
+        down to the modname.
+        If there is no parent, then modname==fqname.
 
-    This method should return None, or a 3-tuple.
+        This method should return None, or a 3-tuple.
 
-    * If the module was not found, then None should be returned.
+        * If the module was not found, then None should be returned.
 
-    * The first item of the 2- or 3-tuple should be the integer 0 or 1,
-      specifying whether the module that was found is a package or not.
+        * The first item of the 2- or 3-tuple should be the integer 0 or 1,
+            specifying whether the module that was found is a package or not.
 
-    * The second item is the code object for the module (it will be
-      executed within the new module's namespace). This item can also
-      be a fully-loaded module object (e.g. loaded from a shared lib).
+        * The second item is the code object for the module (it will be
+            executed within the new module's namespace). This item can also
+            be a fully-loaded module object (e.g. loaded from a shared lib).
 
-    * The third item is a dictionary of name/value pairs that will be
-      inserted into new module before the code object is executed. This
-      is provided in case the module's code expects certain values (such
-      as where the module was found). When the second item is a module
-      object, then these names/values will be inserted *after* the module
-      has been loaded/initialized.
-    """
-    raise RuntimeError, "get_code not implemented"
+        * The third item is a dictionary of name/value pairs that will be
+            inserted into new module before the code object is executed. This
+            is provided in case the module's code expects certain values (such
+            as where the module was found). When the second item is a module
+            object, then these names/values will be inserted *after* the module
+            has been loaded/initialized.
+        """
+        raise RuntimeError, "get_code not implemented"
 
 
 ######################################################################
@@ -372,99 +377,99 @@ _suffix_char = __debug__ and 'c' or 'o'
 _suffix = '.py' + _suffix_char
 
 def _compile(pathname, timestamp):
-  """Compile (and cache) a Python source file.
-
-  The file specified by <pathname> is compiled to a code object and
-  returned.
-
-  Presuming the appropriate privileges exist, the bytecodes will be
-  saved back to the filesystem for future imports. The source file's
-  modification timestamp must be provided as a Long value.
-  """
-  codestring = open(pathname, 'r').read()
-  if codestring and codestring[-1] != '\n':
-    codestring = codestring + '\n'
-  code = __builtin__.compile(codestring, pathname, 'exec')
-
-  # try to cache the compiled code
-  try:
-    f = open(pathname + _suffix_char, 'wb')
-  except IOError:
-    pass
-  else:
-    f.write('\0\0\0\0')
-    f.write(struct.pack('<I', timestamp))
-    marshal.dump(code, f)
-    f.flush()
-    f.seek(0, 0)
-    f.write(imp.get_magic())
-    f.close()
-
-  return code
+    """Compile (and cache) a Python source file.
+
+    The file specified by <pathname> is compiled to a code object and
+    returned.
+
+    Presuming the appropriate privileges exist, the bytecodes will be
+    saved back to the filesystem for future imports. The source file's
+    modification timestamp must be provided as a Long value.
+    """
+    codestring = open(pathname, 'r').read()
+    if codestring and codestring[-1] != '\n':
+        codestring = codestring + '\n'
+    code = __builtin__.compile(codestring, pathname, 'exec')
+
+    # try to cache the compiled code
+    try:
+        f = open(pathname + _suffix_char, 'wb')
+    except IOError:
+        pass
+    else:
+        f.write('\0\0\0\0')
+        f.write(struct.pack('<I', timestamp))
+        marshal.dump(code, f)
+        f.flush()
+        f.seek(0, 0)
+        f.write(imp.get_magic())
+        f.close()
+
+    return code
 
 _os_stat = _os_path_join = None
 def _os_bootstrap():
-  "Set up 'os' module replacement functions for use during import bootstrap."
-
-  names = sys.builtin_module_names
-
-  join = None
-  if 'posix' in names:
-    sep = '/'
-    from posix import stat
-  elif 'nt' in names:
-    sep = '\\'
-    from nt import stat
-  elif 'dos' in names:
-    sep = '\\'
-    from dos import stat
-  elif 'os2' in names:
-    sep = '\\'
-    from os2 import stat
-  elif 'mac' in names:
-    from mac import stat
-    def join(a, b):
-      if a == '':
-        return b
-      path = s
-      if ':' not in a:
-        a = ':' + a
-      if a[-1:] <> ':':
-        a = a + ':'
-      return a + b
-  else:
-    raise ImportError, 'no os specific module found'
-  
-  if join is None:
-    def join(a, b, sep=sep):
-      if a == '':
-        return b
-      lastchar = a[-1:]
-      if lastchar == '/' or lastchar == sep:
-        return a + b
-      return a + sep + b
-
-  global _os_stat
-  _os_stat = stat
-
-  global _os_path_join
-  _os_path_join = join
+    "Set up 'os' module replacement functions for use during import bootstrap."
+
+    names = sys.builtin_module_names
+
+    join = None
+    if 'posix' in names:
+        sep = '/'
+        from posix import stat
+    elif 'nt' in names:
+        sep = '\\'
+        from nt import stat
+    elif 'dos' in names:
+        sep = '\\'
+        from dos import stat
+    elif 'os2' in names:
+        sep = '\\'
+        from os2 import stat
+    elif 'mac' in names:
+        from mac import stat
+        def join(a, b):
+            if a == '':
+                return b
+            path = s
+            if ':' not in a:
+                a = ':' + a
+            if a[-1:] <> ':':
+                a = a + ':'
+            return a + b
+    else:
+        raise ImportError, 'no os specific module found'
+
+    if join is None:
+        def join(a, b, sep=sep):
+            if a == '':
+                return b
+            lastchar = a[-1:]
+            if lastchar == '/' or lastchar == sep:
+                return a + b
+            return a + sep + b
+
+    global _os_stat
+    _os_stat = stat
+
+    global _os_path_join
+    _os_path_join = join
 
 def _os_path_isdir(pathname):
-  "Local replacement for os.path.isdir()."
-  try:
-    s = _os_stat(pathname)
-  except OSError:
-    return None
-  return (s[0] & 0170000) == 0040000
+    "Local replacement for os.path.isdir()."
+    try:
+        s = _os_stat(pathname)
+    except OSError:
+        return None
+    return (s[0] & 0170000) == 0040000
 
 def _timestamp(pathname):
-  "Return the file modification time as a Long."
-  try:
-    s = _os_stat(pathname)
-  except OSError:
-    return None
-  return long(s[8])
+    "Return the file modification time as a Long."
+    try:
+        s = _os_stat(pathname)
+    except OSError:
+        return None
+    return long(s[8])
 
 
 ######################################################################
@@ -472,23 +477,23 @@ def _timestamp(pathname):
 # Emulate the import mechanism for builtin and frozen modules
 #
 class BuiltinImporter(Importer):
-  def get_code(self, parent, modname, fqname):
-    if parent:
-      # these modules definitely do not occur within a package context
-      return None
-
-    # look for the module
-    if imp.is_builtin(modname):
-      type = imp.C_BUILTIN
-    elif imp.is_frozen(modname):
-      type = imp.PY_FROZEN
-    else:
-      # not found
-      return None
+    def get_code(self, parent, modname, fqname):
+        if parent:
+            # these modules definitely do not occur within a package context
+            return None
+
+        # look for the module
+        if imp.is_builtin(modname):
+            type = imp.C_BUILTIN
+        elif imp.is_frozen(modname):
+            type = imp.PY_FROZEN
+        else:
+            # not found
+            return None
 
-    # got it. now load and return it.
-    module = imp.load_module(modname, None, modname, ('', '', type))
-    return 0, module, { }
+        # got it. now load and return it.
+        module = imp.load_module(modname, None, modname, ('', '', type))
+        return 0, module, { }
 
 
 ######################################################################
@@ -496,49 +501,49 @@ class BuiltinImporter(Importer):
 # Internal importer used for importing from the filesystem
 #
 class _FilesystemImporter(Importer):
-  def __init__(self):
-    self.suffixes = [ ]
-
-  def add_suffix(self, suffix, importFunc):
-    assert callable(importFunc)
-    self.suffixes.append((suffix, importFunc))
-
-  def import_from_dir(self, dir, fqname):
-    result = self._import_pathname(_os_path_join(dir, fqname), fqname)
-    if result:
-      return self._process_result(result, fqname)
-    return None
-
-  def get_code(self, parent, modname, fqname):
-    # This importer is never used with an empty parent. Its existence is
-    # private to the ImportManager. The ImportManager uses the
-    # import_from_dir() method to import top-level modules/packages.
-    # This method is only used when we look for a module within a package.
-    assert parent
-
-    return self._import_pathname(_os_path_join(parent.__pkgdir__, modname),
-                                 fqname)
-
-  def _import_pathname(self, pathname, fqname):
-    if _os_path_isdir(pathname):
-      result = self._import_pathname(_os_path_join(pathname, '__init__'),
+    def __init__(self):
+        self.suffixes = [ ]
+
+    def add_suffix(self, suffix, importFunc):
+        assert callable(importFunc)
+        self.suffixes.append((suffix, importFunc))
+
+    def import_from_dir(self, dir, fqname):
+        result = self._import_pathname(_os_path_join(dir, fqname), fqname)
+        if result:
+            return self._process_result(result, fqname)
+        return None
+
+    def get_code(self, parent, modname, fqname):
+        # This importer is never used with an empty parent. Its existence is
+        # private to the ImportManager. The ImportManager uses the
+        # import_from_dir() method to import top-level modules/packages.
+        # This method is only used when we look for a module within a package.
+        assert parent
+
+        return self._import_pathname(_os_path_join(parent.__pkgdir__, modname),
                                      fqname)
-      if result:
-        values = result[2]
-        values['__pkgdir__'] = pathname
-        values['__path__'] = [ pathname ]
-        return 1, result[1], values
-      return None
-
-    for suffix, importFunc in self.suffixes:
-      filename = pathname + suffix
-      try:
-        finfo = _os_stat(filename)
-      except OSError:
-        pass
-      else:
-        return importFunc(filename, finfo, fqname)
-    return None
+
+    def _import_pathname(self, pathname, fqname):
+        if _os_path_isdir(pathname):
+            result = self._import_pathname(_os_path_join(pathname, '__init__'),
+                                           fqname)
+            if result:
+                values = result[2]
+                values['__pkgdir__'] = pathname
+                values['__path__'] = [ pathname ]
+                return 1, result[1], values
+            return None
+
+        for suffix, importFunc in self.suffixes:
+            filename = pathname + suffix
+            try:
+                finfo = _os_stat(filename)
+            except OSError:
+                pass
+            else:
+                return importFunc(filename, finfo, fqname)
+        return None
 
 ######################################################################
 #
@@ -546,49 +551,49 @@ class _FilesystemImporter(Importer):
 #
 
 def py_suffix_importer(filename, finfo, fqname):
-  file = filename[:-3] + _suffix
-  t_py = long(finfo[8])
-  t_pyc = _timestamp(file)
-
-  code = None
-  if t_pyc is not None and t_pyc >= t_py:
-    f = open(file, 'rb')
-    if f.read(4) == imp.get_magic():
-      t = struct.unpack('<I', f.read(4))[0]
-      if t == t_py:
-        code = marshal.load(f)
-    f.close()
-  if code is None:
-    file = filename
-    code = _compile(file, t_py)
-
-  return 0, code, { '__file__' : file }
+    file = filename[:-3] + _suffix
+    t_py = long(finfo[8])
+    t_pyc = _timestamp(file)
+
+    code = None
+    if t_pyc is not None and t_pyc >= t_py:
+        f = open(file, 'rb')
+        if f.read(4) == imp.get_magic():
+            t = struct.unpack('<I', f.read(4))[0]
+            if t == t_py:
+                code = marshal.load(f)
+        f.close()
+    if code is None:
+        file = filename
+        code = _compile(file, t_py)
+
+    return 0, code, { '__file__' : file }
 
 class DynLoadSuffixImporter:
-  def __init__(self, desc):
-    self.desc = desc
+    def __init__(self, desc):
+        self.desc = desc
 
-  def import_file(self, filename, finfo, fqname):
-    fp = open(filename, self.desc[1])
-    module = imp.load_module(fqname, fp, filename, self.desc)
-    module.__file__ = filename
-    return 0, module, { }
+    def import_file(self, filename, finfo, fqname):
+        fp = open(filename, self.desc[1])
+        module = imp.load_module(fqname, fp, filename, self.desc)
+        module.__file__ = filename
+        return 0, module, { }
 
 
 ######################################################################
 
 def _print_importers():
-  items = sys.modules.items()
-  items.sort()
-  for name, module in items:
-    if module:
-      print name, module.__dict__.get('__importer__', '-- no importer')
-    else:
-      print name, '-- non-existent module'
+    items = sys.modules.items()
+    items.sort()
+    for name, module in items:
+        if module:
+            print name, module.__dict__.get('__importer__', '-- no importer')
+        else:
+            print name, '-- non-existent module'
 
 def _test_revamp():
-  ImportManager().install()
-  sys.path.insert(0, BuiltinImporter())
+    ImportManager().install()
+    sys.path.insert(0, BuiltinImporter())
 
 ######################################################################