remove unused imports; PEP 8 compliance

maxcountryman · maxcountryman · commit 8a47f57013f6 · 2013-07-08T17:41:05.000-07:00
diff --git a/nrepl/__init__.py b/nrepl/__init__.py
@@ -1,20 +1,22 @@
 #!/usr/bin/env python
 
-import socket, re, sys
+import socket
 import nrepl.bencode as bencode
 import threading
 try:
     from urlparse import urlparse, ParseResult
 except ImportError:
     from urllib.parse import urlparse, ParseResult
 
-def _bencode_connect (uri):
+
+def _bencode_connect(uri):
     s = socket.create_connection(uri.netloc.split(":"))
     # TODO I don't think .close() will propagate to the socket automatically...
     f = s.makefile('rw')
     return bencode.BencodeIO(f)
 
-def _match_criteria (criteria, msg):
+
+def _match_criteria(criteria, msg):
     for k, v in criteria.items():
         mv = msg.get(k, None)
         if isinstance(v, set):
@@ -26,59 +28,67 @@ def _match_criteria (criteria, msg):
             return False
     return True
 
-class WatchableConnection (object):
-    def __init__ (self, IO):
-        """Create a new WatchableConnection with an nREPL message transport
+
+class WatchableConnection(object):
+    def __init__(self, IO):
+        """
+        Create a new WatchableConnection with an nREPL message transport
         supporting `read()` and `write()` methods that return and accept nREPL
-        messages, e.g. bencode.BencodeIO."""
+        messages, e.g. bencode.BencodeIO.
+        """
         self._IO = IO
         self._watches = {}
         self._watches_lock = threading.RLock()
-        class Monitor (threading.Thread):
-            def run (_):
+
+        class Monitor(threading.Thread):
+            def run(_):
                 watches = None
                 for incoming in self._IO:
                     with self._watches_lock:
                         watches = dict(self._watches)
                     for key, (pred, callback) in watches.items():
-                        if pred(incoming): 
+                        if pred(incoming):
                             callback(incoming, self, key)
         self._thread = Monitor()
         self._thread.daemon = True
         self._thread.start()
 
-    def close (self):
+    def close(self):
         self._IO.close()
 
-    def send (self, message):
+    def send(self, message):
         "Send an nREPL message."
         self._IO.write(message)
 
-    def unwatch (self, key):
+    def unwatch(self, key):
         "Removes the watch previously registered with [key]."
         with self._watches_lock:
             self._watches.pop(key, None)
 
-    def watch (self, key, criteria, callback):
-        """Registers a new watch under [key] (which can be used with `unwatch()`
+    def watch(self, key, criteria, callback):
+        """
+        Registers a new watch under [key] (which can be used with `unwatch()`
         to remove the watch) that filters messages using [criteria] (may be a
         predicate or a 'criteria dict' [see the README for more info there]).
         Matching messages are passed to [callback], which must accept three
         arguments: the matched incoming message, this instance of
         `WatchableConnection`, and the key under which the watch was
-        registered."""
+        registered.
+        """
         if hasattr(criteria, '__call__'):
             pred = criteria
         else:
-            pred = lambda incoming: _match_criteria(criteria, incoming) 
+            pred = lambda incoming: _match_criteria(criteria, incoming)
         with self._watches_lock:
             self._watches[key] = (pred, callback)
 
 # others can add in implementations here
 _connect_fns = {"nrepl": _bencode_connect}
 
-def connect (uri):
-    """Connects to an nREPL endpoint identified by the given URL/URI.  Valid
+
+def connect(uri):
+    """
+    Connects to an nREPL endpoint identified by the given URL/URI.  Valid
     examples include:
 
       nrepl://192.168.0.12:7889
@@ -87,15 +97,16 @@ def connect (uri):
 
     This fn delegates to another looked up in  that dispatches on the scheme of
     the URI provided (which can be a string or java.net.URI).  By default, only
-    `nrepl` (corresponding to using the default bencode transport) is supported.
-    Alternative implementations may add support for other schemes, such as
-    http/https, JMX, various message queues, etc."""
+    `nrepl` (corresponding to using the default bencode transport) is
+    supported. Alternative implementations may add support for other schemes,
+    such as http/https, JMX, various message queues, etc.
+    """
     #
     uri = uri if isinstance(uri, ParseResult) else urlparse(uri)
     if not uri.scheme:
         raise ValueError("uri has no scheme: " + uri)
     f = _connect_fns.get(uri.scheme.lower(), None)
     if not f:
-        raise Exception("No connect function registered for scheme `%s`" % uri.scheme)
+        err = "No connect function registered for scheme `%s`" % uri.scheme
+        raise Exception(err)
     return f(uri)
-
diff --git a/nrepl/bencode.py b/nrepl/bencode.py
@@ -5,26 +5,25 @@
 except ImportError:
     from io import StringIO
 
-import socket, sys
-
 import sys
 
 # Some code so we can use different features without worrying about versions.
 PY2 = sys.version_info[0] == 2
 if not PY2:
     text_type = str
-    string_types = (str,bytes)
+    string_types = (str, bytes)
     unichr = chr
 else:
     text_type = unicode
     string_types = (str, unicode)
     unichr = unichr
 
 
-def _read_byte (s):
+def _read_byte(s):
     return s.read(1)
 
-def _read_int (s, terminator=None, init_data=None):
+
+def _read_int(s, terminator=None, init_data=None):
     int_chrs = init_data or []
     while True:
         c = _read_byte(s)
@@ -34,12 +33,14 @@ def _read_int (s, terminator=None, init_data=None):
             int_chrs.append(c)
     return int(''.join(int_chrs))
 
-def _read_bytes (s, n):
+
+def _read_bytes(s, n):
     data = StringIO()
     cnt = 0
     while cnt < n:
         m = s.read(n - cnt)
-        if not m: raise Exception("Invalid bytestring, unexpected end of input.")
+        if not m:
+            raise Exception("Invalid bytestring, unexpected end of input.")
         data.write(m)
         cnt += len(m)
     data.flush()
@@ -50,40 +51,48 @@ def _read_bytes (s, n):
         ret = data.getvalue()
     return ret
 
-def _read_delimiter (s):
+
+def _read_delimiter(s):
     d = _read_byte(s)
-    if d.isdigit(): d = _read_int(s, ":", [d])
+    if d.isdigit():
+        d = _read_int(s, ":", [d])
     return d
 
-def _read_list (s):
+
+def _read_list(s):
     data = []
     while True:
         datum = _read_datum(s)
-        if not datum: break
+        if not datum:
+            break
         data.append(datum)
     return data
 
-def _read_map (s):
+
+def _read_map(s):
     i = iter(_read_list(s))
     return dict(zip(i, i))
 
+
 _read_fns = {"i": _read_int,
              "l": _read_list,
              "d": _read_map,
              "e": lambda _: None,
              # EOF
              None: lambda _: None}
 
-def _read_datum (s):
+
+def _read_datum(s):
     delim = _read_delimiter(s)
     if delim:
         return _read_fns.get(delim, lambda s: _read_bytes(s, delim))(s)
 
-def _write_datum (x, out):
+
+def _write_datum(x, out):
     if isinstance(x, string_types):
-        #x = x.encode("UTF-8")
-        # TODO revisit encodings, this is surely not right. Python (2.x, anyway)
-        # conflates bytes and strings, but 3.x does not...
+        # x = x.encode("UTF-8")
+        # TODO revisit encodings, this is surely not right. Python
+        # (2.x, anyway) conflates bytes and strings, but 3.x does not...
         out.write(str(len(x)))
         out.write(":")
         out.write(x)
@@ -93,7 +102,8 @@ def _write_datum (x, out):
         out.write("e")
     elif isinstance(x, (list, tuple)):
         out.write("l")
-        for v in x: _write_datum(v, out)
+        for v in x:
+            _write_datum(v, out)
         out.write("e")
     elif isinstance(x, dict):
         out.write("d")
@@ -103,49 +113,56 @@ def _write_datum (x, out):
         out.write("e")
     out.flush()
 
-def encode (v):
+
+def encode(v):
     "bencodes the given value, may be a string, integer, list, or dict."
     s = StringIO()
     _write_datum(v, s)
     return s.getvalue()
 
-def decode_file (file):
+
+def decode_file(file):
     while True:
         x = _read_datum(file)
-        if not x: break
+        if not x:
+            break
         yield x
 
-def decode (string):
+
+def decode(string):
     "Generator that yields decoded values from the input string."
     return decode_file(StringIO(string))
 
-class BencodeIO (object):
-    def __init__ (self, file):
+
+class BencodeIO(object):
+    def __init__(self, file):
         self._file = file
 
-    def read (self):
+    def read(self):
         return _read_datum(self._file)
 
-    def __iter__ (self): 
+    def __iter__(self):
         return self
 
     def next(self):
         v = self.read()
-        if not v: raise StopIteration
+        if not v:
+            raise StopIteration
         return v
 
     def __next__(self):
         # In Python3, __next__ it is an own special class.
         v = self.read()
-        if not v: raise StopIteration
+        if not v:
+            raise StopIteration
         return v
 
-    def write (self, v):
+    def write(self, v):
         return _write_datum(v, self._file)
 
-    def flush (self):
-        if self._file.flush: self._file.flush()
+    def flush(self):
+        if self._file.flush:
+            self._file.flush()
 
-    def close (self):
+    def close(self):
         self._file.close()
-    
