(k, v) for k, v in vars().items()
             if k != 'self' and v is not None)
 
+
 class Command(dict):
     """
     Helper class to declare options for COMMANDS list.
         if record.levelno >= self.level:
             self._module._ceph_log(self.format(record))
 
+
 class ClusterLogHandler(logging.Handler):
     def __init__(self, module_inst):
         super().__init__()
                                      level,
                                      self.format(record))
 
+
 class FileHandler(logging.FileHandler):
     def __init__(self, module_inst):
         path = module_inst.get_ceph_option("log_file")
         self._root_logger.setLevel(logging.NOTSET)
         self._set_log_level(mgr_level, module_level, cluster_level)
 
-
     def _unconfigure_logging(self):
         # remove existing handlers:
         rm_handlers = [
         # Keep a librados instance for those that need it.
         self._rados = None
 
-
     def __del__(self):
         self._unconfigure_logging()
 
     def update_progress_event(self, evid, desc, progress, add_to_ceph_s):
         return self._ceph_update_progress_event(str(evid),
                                                 str(desc),
-                                                float(progress), 
+                                                float(progress),
                                                 bool(add_to_ceph_s))
 
     def complete_progress_event(self, evid):
 
             with contextlib.closing(sock):
                 sock.bind(("::1", 0))
                 return True
-        except (AttributeError, socket.error) as e:
-           return False
+        except (AttributeError, socket.error):
+            return False
 
     try:
         return get_default_addr.result  # type: ignore
             'Private key {} and certificate {} do not match up: {}'.format(
                 pkey_fname, cert_fname, str(e)))
 
+
 def get_most_recent_rate(rates):
     """ Get most recent rate from rates
 
     return [(data2[0], _derivative(data1, data2)) for data1, data2 in
             _pairwise(data)]
 
+
 def _filter_time_series(data):
     """ Filters time series data
 
     filtered.append(data[-1])
     return filtered
 
+
 def _derivative(p1, p2):
     """ Derivative between two time series data points
 
     """
     return (p2[1] - p1[1]) / float(p2[0] - p1[0])
 
+
 def _pairwise(iterable):
     it = iter(iterable)
     a = next(it, None)
         yield (a, b)
         a = b
 
+
 def to_pretty_timedelta(n):
     if n < datetime.timedelta(seconds=120):
         return str(n.seconds) + 's'