diff --git a/httplib2/socks.py b/httplib2/socks.py
index b65fb38..a458e1c 100644
--- a/httplib2/socks.py
+++ b/httplib2/socks.py
@@ -3,8 +3,8 @@
 
 Copyright 2006 Dan-Haim. All rights reserved.
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 1. Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
@@ -13,7 +13,7 @@
 3. Neither the name of Dan Haim nor the names of his contributors may be used
    to endorse or promote products derived from this software without specific
    prior written permission.
-
+   
 THIS SOFTWARE IS PROVIDED BY DAN HAIM "AS IS" AND ANY EXPRESS OR IMPLIED
 WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
@@ -22,7 +22,7 @@
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA
 OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
-OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMANGE.
 
 
 This module provides a standard socket-like interface for Python
@@ -41,95 +41,57 @@
 """
 
 import socket
+import struct
+import sys
 
 if getattr(socket, 'socket', None) is None:
     raise ImportError('socket.socket missing, proxy support unusable')
 
-import struct
-import sys
-
 PROXY_TYPE_SOCKS4 = 1
 PROXY_TYPE_SOCKS5 = 2
 PROXY_TYPE_HTTP = 3
 
 _defaultproxy = None
+_orgsocket = socket.socket
 
-# Small hack for Python 2.x
-if sys.version_info[0] <= 2:
-    def bytes(obj, enc=None):
-        return obj
-
-class ProxyError(Exception):
-    def __init__(self, value):
-        self.value = value
-    def __str__(self):
-        return repr(self.value)
-
-class GeneralProxyError(ProxyError):
-    def __init__(self, value):
-        self.value = value
-    def __str__(self):
-        return repr(self.value)
-
-class Socks5AuthError(ProxyError):
-    def __init__(self, value):
-        self.value = value
-    def __str__(self):
-        return repr(self.value)
-
-class Socks5Error(ProxyError):
-    def __init__(self, value):
-        self.value = value
-    def __str__(self):
-        return repr(self.value)
-
-class Socks4Error(ProxyError):
-    def __init__(self, value):
-        self.value = value
-    def __str__(self):
-        return repr(self.value)
-
-class HTTPError(ProxyError):
-    def __init__(self, value):
-        self.value = value
-    def __str__(self):
-        return repr(self.value)
+class ProxyError(Exception): pass
+class GeneralProxyError(ProxyError): pass
+class Socks5AuthError(ProxyError): pass
+class Socks5Error(ProxyError): pass
+class Socks4Error(ProxyError): pass
+class HTTPError(ProxyError): pass
 
 _generalerrors = ("success",
-                  "invalid data",
-                  "not connected",
-                  "not available",
-                  "bad proxy type",
-                  "bad input")
+    "invalid data",
+    "not connected",
+    "not available",
+    "bad proxy type",
+    "bad input")
 
 _socks5errors = ("succeeded",
-                 "general SOCKS server failure",
-                 "connection not allowed by ruleset",
-                 "Network unreachable",
-                 "Host unreachable",
-                 "Connection refused",
-                 "TTL expired",
-                 "Command not supported",
-                 "Address type not supported",
-                 "Unknown error")
+    "general SOCKS server failure",
+    "connection not allowed by ruleset",
+    "Network unreachable",
+    "Host unreachable",
+    "Connection refused",
+    "TTL expired",
+    "Command not supported",
+    "Address type not supported",
+    "Unknown error")
 
 _socks5autherrors = ("succeeded",
-                     "authentication is required",
-                     "all offered authentication methods were rejected",
-                     "unknown username or invalid password",
-                     "unknown error")
+    "authentication is required",
+    "all offered authentication methods were rejected",
+    "unknown username or invalid password",
+    "unknown error")
 
 _socks4errors = ("request granted",
-                 "request rejected or failed",
-                 ("request rejected because SOCKS server cannot connect to "
-                  "identd on the client"),
-                 ("request rejected because the client program and identd"
-                  " report different user-ids"),
-                 "unknown error")
+    "request rejected or failed",
+    "request rejected because SOCKS server cannot connect to identd on the client",
+    "request rejected because the client program and identd report different user-ids",
+    "unknown error")
 
-
-def setdefaultproxy(proxytype=None, addr=None, port=None, rdns=True,
-                    username=None, password=None):
+def setdefaultproxy(proxytype=None, addr=None, port=None, rdns=True, username=None, password=None):
     """setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
     Sets a default proxy which all further socksocket objects will use,
     unless explicitly changed.
@@ -137,18 +99,27 @@
     global _defaultproxy
     _defaultproxy = (proxytype, addr, port, rdns, username, password)
 
+def wrapmodule(module):
+    """wrapmodule(module)
+    Attempts to replace a module's socket library with a SOCKS socket. Must set
+    a default proxy using setdefaultproxy(...) first.
+    This will only work on modules that import socket directly into the namespace;
+    most of the Python Standard Library falls into this category.
+    """
+    if _defaultproxy != None:
+        module.socket.socket = socksocket
+    else:
+        raise GeneralProxyError((4, "no proxy specified"))
 
 class socksocket(socket.socket):
     """socksocket([family[, type[, proto]]]) -> socket object
-
     Open a SOCKS enabled socket. The parameters are the same as
     those of the standard socket init. In order for SOCKS to work,
     you must specify family=AF_INET, type=SOCK_STREAM and proto=0.
     """
 
-    def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM,
-                 proto=0, _sock=None):
-        socket.socket.__init__(self, family, type, proto, _sock)
+    def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None):
+        _orgsocket.__init__(self, family, type, proto, _sock)
         if _defaultproxy != None:
             self.__proxy = _defaultproxy
         else:
@@ -156,41 +127,19 @@
         self.__proxysockname = None
         self.__proxypeername = None
 
-    def __decode(self, bytes):
-        if getattr(bytes, 'decode', False):
-            try:
-                bytes = bytes.decode()
-            except Exception:
-                pass
-        return bytes
-
-    def __encode(self, bytes):
-        if getattr(bytes, 'encode', False):
-            try:
-                bytes = bytes.encode()
-            except Exception:
-                pass
-        return bytes
-
     def __recvall(self, count):
         """__recvall(count) -> data
         Receive EXACTLY the number of bytes requested from the socket.
         Blocks until the required number of bytes have been received.
         """
-        data = bytes("")
+        data = self.recv(count)
         while len(data) < count:
-            d = self.recv(count - len(data))
-            if not d:
-                raise GeneralProxyError(
-                    (0, "connection closed unexpectedly"))
-            data = data + self.__decode(d)
+            d = self.recv(count-len(data))
+            if not d: raise GeneralProxyError((0, "connection closed unexpectedly"))
+            data = data + d
         return data
 
-    def sendall(self, bytes):
-        socket.socket.sendall(self, self.__encode(bytes))
-
-    def setproxy(self, proxytype=None, addr=None, port=None, rdns=True,
-                 username=None, password=None):
+    def setproxy(self, proxytype=None, addr=None, port=None, rdns=True, username=None, password=None):
         """setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
         Sets the proxy to be used.
         proxytype -    The type of the proxy to be used. Three types
@@ -214,36 +163,35 @@
         Negotiates a connection through a SOCKS5 server.
         """
         # First we'll send the authentication packages we support.
-        if (self.__proxy[4] != None) and (self.__proxy[5] != None):
+        if (self.__proxy[4]!=None) and (self.__proxy[5]!=None):
             # The username/password details were supplied to the
             # setproxy method so we support the USERNAME/PASSWORD
             # authentication (in addition to the standard none).
-            self.sendall("\x05\x02\x00\x02")
+            self.sendall(struct.pack('BBBB', 0x05, 0x02, 0x00, 0x02))
         else:
             # No username/password were entered, therefore we
             # only support connections with no authentication.
-            self.sendall("\x05\x01\x00")
+            self.sendall(struct.pack('BBB', 0x05, 0x01, 0x00))
         # We'll receive the server's response to determine which
         # method was selected
         chosenauth = self.__recvall(2)
-        if chosenauth[0] != "\x05":
+        if chosenauth[0:1] != chr(0x05).encode():
             self.close()
             raise GeneralProxyError((1, _generalerrors[1]))
         # Check the chosen authentication method
-        if chosenauth[1] == "\x00":
+        if chosenauth[1:2] == chr(0x00).encode():
             # No authentication is required
             pass
-        elif chosenauth[1] == "\x02":
+        elif chosenauth[1:2] == chr(0x02).encode():
             # Okay, we need to perform a basic username/password
             # authentication.
-            self.sendall("\x01" + chr(len(self.__proxy[4])) + self.__proxy[4] +
-                         chr(len(self.__proxy[5])) + self.__proxy[5])
+            self.sendall(chr(0x01).encode() + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.__proxy[5])) + self.__proxy[5])
             authstat = self.__recvall(2)
-            if authstat[0] != "\x01":
+            if authstat[0:1] != chr(0x01).encode():
                 # Bad response
                 self.close()
                 raise GeneralProxyError((1, _generalerrors[1]))
-            if authstat[1] != "\x00":
+            if authstat[1:2] != chr(0x00).encode():
                 # Authentication failed
                 self.close()
                 raise Socks5AuthError((3, _socks5autherrors[3]))
@@ -251,52 +199,52 @@
         else:
             # Reaching here is always bad
             self.close()
-            if chosenauth[1] == "\xFF":
+            if chosenauth[1] == chr(0xFF).encode():
                 raise Socks5AuthError((2, _socks5autherrors[2]))
             else:
                 raise GeneralProxyError((1, _generalerrors[1]))
         # Now we can request the actual connection
-        req = "\x05\x01\x00"
+        req = struct.pack('BBB', 0x05, 0x01, 0x00)
         # If the given destination address is an IP address, we'll
         # use the IPv4 address request even if remote resolving was specified.
         try:
             ipaddr = socket.inet_aton(destaddr)
-            req = req + "\x01" + ipaddr
+            req = req + chr(0x01).encode() + ipaddr
         except socket.error:
             # Well it's not an IP number,  so it's probably a DNS name.
-            if self.__proxy[3] == True:
+            if self.__proxy[3]:
                 # Resolve remotely
                 ipaddr = None
-                req = req + "\x03" + chr(len(destaddr)) + destaddr
+                req = req + chr(0x03).encode() + chr(len(destaddr)).encode() + destaddr
             else:
                 # Resolve locally
                 ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
-                req = req + "\x01" + ipaddr
-        req = req + self.__decode(struct.pack(">H", destport))
+                req = req + chr(0x01).encode() + ipaddr
+        req = req + struct.pack(">H", destport)
         self.sendall(req)
         # Get the response
         resp = self.__recvall(4)
-        if resp[0] != "\x05":
+        if resp[0:1] != chr(0x05).encode():
             self.close()
             raise GeneralProxyError((1, _generalerrors[1]))
-        elif resp[1] != "\x00":
+        elif resp[1:2] != chr(0x00).encode():
             # Connection failed
             self.close()
-            if ord(resp[1]) <= 8:
-                raise Socks5Error((ord(resp[1]), _socks5errors[ord(resp[1])]))
+            if ord(resp[1:2])<=8:
+                raise Socks5Error((ord(resp[1:2]), _socks5errors[ord(resp[1:2])]))
             else:
                 raise Socks5Error((9, _socks5errors[9]))
         # Get the bound address/port
-        elif resp[3] == "\x01":
+        elif resp[3:4] == chr(0x01).encode():
             boundaddr = self.__recvall(4)
-        elif resp[3] == "\x03":
+        elif resp[3:4] == chr(0x03).encode():
             resp = resp + self.recv(1)
-            boundaddr = self.__recvall(ord(resp[4]))
+            boundaddr = self.__recvall(ord(resp[4:5]))
         else:
             self.close()
-            raise GeneralProxyError((1, _generalerrors[1]))
-        boundport = struct.unpack(">H", bytes(self.__recvall(2), 'utf8'))[0]
-        self.__proxysockname = boundaddr, boundport
+            raise GeneralProxyError((1,_generalerrors[1]))
+        boundport = struct.unpack(">H", self.__recvall(2))[0]
+        self.__proxysockname = (boundaddr, boundport)
         if ipaddr != None:
             self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
         else:
@@ -312,7 +260,7 @@
         """getproxypeername() -> address info
         Returns the IP and port number of the proxy.
         """
-        return socket.socket.getpeername(self)
+        return _orgsocket.getpeername(self)
 
     def getpeername(self):
         """getpeername() -> address info
@@ -321,7 +269,7 @@
         """
         return self.__proxypeername
 
-    def __negotiatesocks4(self, destaddr, destport):
+    def __negotiatesocks4(self,destaddr,destport):
         """__negotiatesocks4(self,destaddr,destport)
         Negotiates a connection through a SOCKS4 server.
         """
@@ -331,41 +279,41 @@
             ipaddr = socket.inet_aton(destaddr)
         except socket.error:
             # It's a DNS name. Check where it should be resolved.
-            if self.__proxy[3] == True:
-                ipaddr = "\x00\x00\x00\x01"
+            if self.__proxy[3]:
+                ipaddr = struct.pack("BBBB", 0x00, 0x00, 0x00, 0x01)
                 rmtrslv = True
             else:
                 ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
         # Construct the request packet
-        req = "\x04\x01" + self.__decode(struct.pack(">H", destport)) + ipaddr
+        req = struct.pack(">BBH", 0x04, 0x01, destport) + ipaddr
         # The username parameter is considered userid for SOCKS4
         if self.__proxy[4] != None:
             req = req + self.__proxy[4]
-        req = req + "\x00"
+        req = req + chr(0x00).encode()
         # DNS name if remote resolving is required
         # NOTE: This is actually an extension to the SOCKS4 protocol
         # called SOCKS4A and may not be supported in all cases.
-        if rmtrslv==True:
-            req = req + destaddr + "\x00"
+        if rmtrslv:
+            req = req + destaddr + chr(0x00).encode()
         self.sendall(req)
         # Get the response from the server
         resp = self.__recvall(8)
-        if resp[0] != "\x00":
+        if resp[0:1] != chr(0x00).encode():
             # Bad data
             self.close()
-            raise GeneralProxyError((1, _generalerrors[1]))
-        if resp[1] != "\x5A":
+            raise GeneralProxyError((1,_generalerrors[1]))
+        if resp[1:2] != chr(0x5A).encode():
             # Server returned an error
             self.close()
-            if ord(resp[1]) in (91,92,93):
+            if ord(resp[1:2]) in (91, 92, 93):
                 self.close()
-                raise Socks4Error((ord(resp[1]), _socks4errors[ord(resp[1])-90]))
+                raise Socks4Error((ord(resp[1:2]), _socks4errors[ord(resp[1:2]) - 90]))
             else:
-                raise Socks4Error((94,_socks4errors[4]))
+                raise Socks4Error((94, _socks4errors[4]))
         # Get the bound address/port
-        self.__proxysockname = (socket.inet_ntoa(resp[4:]),struct.unpack(">H",bytes(resp[2:4],'utf8'))[0])
+        self.__proxysockname = (socket.inet_ntoa(resp[4:]), struct.unpack(">H", resp[2:4])[0])
         if rmtrslv != None:
-            self.__proxypeername = (socket.inet_ntoa(ipaddr),destport)
+            self.__proxypeername = (socket.inet_ntoa(ipaddr), destport)
         else:
             self.__proxypeername = (destaddr, destport)
 
@@ -374,20 +322,19 @@
         Negotiates a connection through an HTTP server.
         """
         # If we need to resolve locally, we do this now
-        if self.__proxy[3] == False:
+        if not self.__proxy[3]:
             addr = socket.gethostbyname(destaddr)
         else:
             addr = destaddr
-        self.sendall(("CONNECT %s:%s HTTP/1.1\r\n"
-                      "Host: %s\r\n\r\n") % (addr, destport, destaddr))
+        self.sendall(("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n").encode())
         # We read the response until we get the string "\r\n\r\n"
         resp = self.recv(1)
-        while resp.find("\r\n\r\n") == -1:
+        while resp.find("\r\n\r\n".encode()) == -1:
             resp = resp + self.recv(1)
         # We just need the first line to check if the connection
         # was successful
-        statusline = resp.splitlines()[0].split(" ", 2)
-        if statusline[0] not in ("HTTP/1.0", "HTTP/1.1"):
+        statusline = resp.splitlines()[0].split(" ".encode(), 2)
+        if statusline[0] not in ("HTTP/1.0".encode(), "HTTP/1.1".encode()):
             self.close()
             raise GeneralProxyError((1, _generalerrors[1]))
         try:
@@ -402,39 +349,37 @@
         self.__proxypeername = (addr, destport)
 
     def connect(self, destpair):
-        """connect(self,despair)
+        """connect(self, despair)
         Connects to the specified destination through a proxy.
         destpar - A tuple of the IP/DNS address and the port number.
         (identical to socket's connect).
         To select the proxy server use setproxy().
         """
         # Do a minimal input check first
-        # TODO(durin42): seriously? type checking? do we care?
-        if ((not isinstance(destpair, (list, tuple))) or len(destpair) < 2
-            or not isinstance(destpair[0], str) or not isinstance(destpair[1], int)):
+        if (not type(destpair) in (list,tuple)) or (len(destpair) < 2) or (type(destpair[0]) != type('')) or (type(destpair[1]) != int):
             raise GeneralProxyError((5, _generalerrors[5]))
         if self.__proxy[0] == PROXY_TYPE_SOCKS5:
             if self.__proxy[2] != None:
                 portnum = self.__proxy[2]
             else:
                 portnum = 1080
-            socket.socket.connect(self,(self.__proxy[1], portnum))
+            _orgsocket.connect(self, (self.__proxy[1], portnum))
             self.__negotiatesocks5(destpair[0], destpair[1])
         elif self.__proxy[0] == PROXY_TYPE_SOCKS4:
             if self.__proxy[2] != None:
                 portnum = self.__proxy[2]
             else:
                 portnum = 1080
-            socket.socket.connect(self, (self.__proxy[1], portnum))
+            _orgsocket.connect(self,(self.__proxy[1], portnum))
             self.__negotiatesocks4(destpair[0], destpair[1])
         elif self.__proxy[0] == PROXY_TYPE_HTTP:
             if self.__proxy[2] != None:
                 portnum = self.__proxy[2]
             else:
                 portnum = 8080
-            socket.socket.connect(self, (self.__proxy[1], portnum))
+            _orgsocket.connect(self,(self.__proxy[1], portnum))
             self.__negotiatehttp(destpair[0], destpair[1])
         elif self.__proxy[0] == None:
-            socket.socket.connect(self, (destpair[0], destpair[1]))
+            _orgsocket.connect(self, (destpair[0], destpair[1]))
         else:
             raise GeneralProxyError((4, _generalerrors[4]))