Merge pull request #446 from python-zk/feat/issue-445

feat: pep8 all the things

Author: bbangert

.hound.yml

@@ -0,0 +1,3 @@
+fail_on_violations: true
+python:
+  enabled: true

kazoo/__init__.py

@@ -1 +1 @@
-from .version import __version__
+from .version import __version__  # noqa

kazoo/client.py

@@ -1384,7 +1384,8 @@ def reconfig(self, joining, leaving, new_members, from_config=-1):
               joining=joining, leaving=None, new_members=None)
 
             # wait and then remove it (just by using its id) (incremental)
-            data, _ = zk.reconfig(joining=None, leaving='100', new_members=None)
+            data, _ = zk.reconfig(joining=None, leaving='100',
+                                  new_members=None)
 
             # now do a full change of the cluster (non-incremental)
             new = [
@@ -1418,7 +1419,8 @@ def reconfig(self, joining, leaving, new_members, from_config=-1):
             returns a non-zero error code.
 
         """
-        result = self.reconfig_async(joining, leaving, new_members, from_config)
+        result = self.reconfig_async(joining, leaving, new_members,
+                                     from_config)
         return result.get()
 
     def reconfig_async(self, joining, leaving, new_members, from_config):

kazoo/handlers/threading.py

@@ -149,8 +149,11 @@ def select(self, *args, **kwargs):
         end = (time.time() + timeout) if timeout else None
         while end is None or time.time() < end:
             if end is not None:
-                args = list(args)  # make a list, since tuples aren't mutable
-                args[3] = end - time.time()  # set the timeout to the remaining time
+                # make a list, since tuples aren't mutable
+                args = list(args)
+
+                # set the timeout to the remaining time
+                args[3] = end - time.time()
             try:
                 return select.select(*args, **kwargs)
             except select.error as ex:

kazoo/protocol/connection.py

@@ -491,7 +491,8 @@ def _expand_client_hosts(self):
         host_ports = []
         for host, port in self.client.hosts:
             try:
-                for rhost in socket.getaddrinfo(host.strip(), port, 0, 0, socket.IPPROTO_TCP):
+                for rhost in socket.getaddrinfo(host.strip(), port, 0, 0,
+                                                socket.IPPROTO_TCP):
                     host_ports.append((rhost[4][0], rhost[4][1]))
             except socket.gaierror as e:
                 # Skip hosts that don't resolve
@@ -618,7 +619,8 @@ def _connect(self, host, port):
                           client._session_id or 0, client._session_passwd,
                           client.read_only)
 
-        # save the client's last_zxid before it gets overwritten by the server's.
+        # save the client's last_zxid before it gets overwritten by the
+        # server's.
         # we'll need this to reset watches via SetWatches further below.
         last_zxid = client.last_zxid
 
@@ -667,7 +669,8 @@ def _connect(self, host, port):
                             client._data_watchers.keys(),
                             client._data_watchers.keys(),
                             client._child_watchers.keys())
-            zxid = self._invoke(connect_timeout / 1000.0, sw, xid=SET_WATCHES_XID)
+            zxid = self._invoke(connect_timeout / 1000.0, sw,
+                                xid=SET_WATCHES_XID)
             if zxid:
                 client.last_zxid = zxid
 

kazoo/protocol/serialization.py

@@ -359,7 +359,8 @@ def unchroot(client, response):
         return resp
 
 
-class Reconfig(namedtuple('Reconfig', 'joining leaving new_members config_id')):
+class Reconfig(namedtuple('Reconfig',
+                          'joining leaving new_members config_id')):
     type = 16
 
     def serialize(self):

kazoo/protocol/states.py

@@ -105,7 +105,7 @@ class EventType(object):
     NONE = 'NONE'
 
 EVENT_TYPE_MAP = {
-    -1:EventType.NONE,
+    -1: EventType.NONE,
     1: EventType.CREATED,
     2: EventType.DELETED,
     3: EventType.CHANGED,

kazoo/recipe/lease.py

@@ -15,24 +15,28 @@
 class NonBlockingLease(object):
     """Exclusive lease that does not block.
 
-    An exclusive lease ensures that only one client at a time owns the lease.  The client may
-    renew the lease without losing it by obtaining a new lease with the same path and same
-    identity.  The lease object evaluates to True if the lease was obtained.
+    An exclusive lease ensures that only one client at a time owns the lease.
+    The client may renew the lease without losing it by obtaining a new lease
+    with the same path and same identity.  The lease object evaluates to True
+    if the lease was obtained.
 
-    A common use case is a situation where a task should only run on a single host.  In this
-    case, the clients that did not obtain the lease should exit without performing the protected
-    task.
+    A common use case is a situation where a task should only run on a single
+    host.  In this case, the clients that did not obtain the lease should exit
+    without performing the protected task.
 
-    The lease stores time stamps using client clocks, and will therefore only work if client clocks
-    are roughly synchronised.  It uses UTC, and works across time zones and daylight savings.
+    The lease stores time stamps using client clocks, and will therefore only
+    work if client clocks are roughly synchronised.  It uses UTC, and works
+    across time zones and daylight savings.
 
     Example usage: with a :class:`~kazoo.client.KazooClient` instance::
 
         zk = KazooClient()
         zk.start()
-        # Hold lease over an hour in order to keep job on same machine, with failover if it dies.
-        lease = zk.NonBlockingLease("/db_leases/hourly_cleanup", datetime.timedelta(minutes = 70),
-          identifier = "DB hourly cleanup on " + socket.gethostname())
+        # Hold lease over an hour in order to keep job on same machine,
+        # with failover if it dies.
+        lease = zk.NonBlockingLease(
+            "/db_leases/hourly_cleanup", datetime.timedelta(minutes = 70),
+            identifier = "DB hourly cleanup on " + socket.gethostname())
         if lease:
             do_hourly_database_cleanup()
     """
@@ -42,15 +46,20 @@ class NonBlockingLease(object):
     _date_format = "%Y-%m-%dT%H:%M:%S"
     _byte_encoding = 'utf-8'
 
-    def __init__(self, client, path, duration, identifier=None, utcnow=datetime.datetime.utcnow):
+    def __init__(self, client, path, duration, identifier=None,
+                 utcnow=datetime.datetime.utcnow):
         """Create a non-blocking lease.
 
         :param client: A :class:`~kazoo.client.KazooClient` instance.
         :param path: The lease path to use.
-        :param duration: Duration during which the lease is reserved.  A :class:`~datetime.timedelta` instance.
-        :param identifier: Unique name to use for this lease holder. Reuse in order to renew the lease.
-               Defaults do :meth:`socket.gethostname()`.
-        :param utcnow: Clock function, by default returning :meth:`datetime.datetime.utcnow()`.  Used for testing.
+        :param duration: Duration during which the lease is reserved.  A
+                         :class:`~datetime.timedelta` instance.
+        :param identifier: Unique name to use for this lease holder. Reuse in
+                           order to renew the lease. Defaults to
+                           :meth:`socket.gethostname()`.
+        :param utcnow: Clock function, by default returning
+                       :meth:`datetime.datetime.utcnow()`. Used for testing.
+
         """
         ident = identifier or socket.gethostname()
         self.obtained = False
@@ -69,13 +78,15 @@ def _attempt_obtaining(self, client, path, duration, ident, utcnow):
                     if data["version"] != self._version:
                         # We need an upgrade, let someone else take the lease
                         return
-                    current_end = datetime.datetime.strptime(data['end'], self._date_format)
+                    current_end = datetime.datetime.strptime(data['end'],
+                                                             self._date_format)
                     if data['holder'] != ident and now < current_end:
                         # Another client is still holding the lease
                         return
                     client.delete(holder_path)
                 end_lease = (now + duration).strftime(self._date_format)
-                new_data = {'version': self._version, 'holder': ident, 'end': end_lease}
+                new_data = {'version': self._version, 'holder': ident,
+                            'end': end_lease}
                 client.create(holder_path, self._encode(new_data))
                 self.obtained = True
 
@@ -100,16 +111,21 @@ def __bool__(self):
 class MultiNonBlockingLease(object):
     """Exclusive lease for multiple clients.
 
-    This type of lease is useful when a limited set of hosts should run a particular task.
-    It will attempt to obtain leases trying a sequence of ZooKeeper lease paths.
+    This type of lease is useful when a limited set of hosts should run a
+    particular task. It will attempt to obtain leases trying a sequence of
+    ZooKeeper lease paths.
 
     :param client: A :class:`~kazoo.client.KazooClient` instance.
     :param count: Number of host leases allowed.
     :param path: ZooKeeper path under which lease files are stored.
-    :param duration: Duration during which the lease is reserved.  A :class:`~datetime.timedelta` instance.
-    :param identifier: Unique name to use for this lease holder. Reuse in order to renew the lease.
+    :param duration: Duration during which the lease is reserved.  A
+                     :class:`~datetime.timedelta` instance.
+    :param identifier: Unique name to use for this lease holder. Reuse in order
+                       to renew the lease.
            Defaults do :meth:`socket.gethostname()`.
-    :param utcnow: Clock function, by default returning :meth:`datetime.datetime.utcnow()`.  Used for testing.
+    :param utcnow: Clock function, by default returning
+                   :meth:`datetime.datetime.utcnow()`.  Used for testing.
+
     """
 
     def __init__(self, client, count, path, duration, identifier=None,

kazoo/recipe/lock.py

@@ -68,8 +68,8 @@ class Lock(object):
     Note: This lock is not *re-entrant*. Repeated calls after already
     acquired will block.
 
-    This is an exclusive lock. For a read/write lock, see :class:`WriteLock` and
-    :class:`ReadLock`.
+    This is an exclusive lock. For a read/write lock, see :class:`WriteLock`
+    and :class:`ReadLock`.
 
     """
 
@@ -267,8 +267,8 @@ def _get_sorted_children(self):
 
         # Node names are prefixed by a type: strip the prefix first, which may
         # be one of multiple values in case of a read-write lock, and return
-        # only the sequence number (as a string since it is padded and will sort
-        # correctly anyway).
+        # only the sequence number (as a string since it is padded and will
+        # sort correctly anyway).
         #
         # In some cases, the lock path may contain nodes with other prefixes
         # (eg. in case of a lease), just sort them last ('~' sorts after all

kazoo/recipe/queue.py

@@ -100,7 +100,7 @@ def _inner_get(self):
             # get another one
             self._children = []
             raise ForceRetryError()
-            
+
         self._children.pop(0)
         return data
 
@@ -269,8 +269,9 @@ def release(self):
 
         :returns: True if the lock was removed successfully, False otherwise.
         :rtype: bool
+
         """
-        if not self.processing_element is None and self.holds_lock:
+        if self.processing_element is not None and self.holds_lock:
             id_, value = self.processing_element
             with self.client.transaction() as transaction:
                 transaction.delete("{path}/{id}".format(
@@ -281,7 +282,6 @@ def release(self):
         else:
             return False
 
-
     def _inner_get(self, timeout):
         flag = self.client.handler.event_object()
         lock = self.client.handler.lock_object()