Apply new black formatting

Signed-off-by: George Melikov <mail@gmelikov.ru>

Author: gmelikov

httpetcd/base/client.py

@@ -30,8 +30,9 @@ class HTTPEtcdClient(obj.BaseObject):
     def __init__(self, conf):
         super(HTTPEtcdClient, self).__init__()
         self._conf = conf
-        self._s = session.get_session(endpoints=conf.endpoints,
-                                      timeout=conf.timeout)
+        self._s = session.get_session(
+            endpoints=conf.endpoints, timeout=conf.timeout
+        )
 
     @property
     def conf(self):

httpetcd/clients.py

@@ -25,15 +25,17 @@
 
 class Config(obj.BaseObject):
 
-    _NS_REGEXP_STR = '^[a-z0-9._-]+$'
+    _NS_REGEXP_STR = "^[a-z0-9._-]+$"
     _NS_REGEXP = re.compile(_NS_REGEXP_STR, re.IGNORECASE)
 
     def __init__(self, endpoints, namespace, timeout):
         super(Config, self).__init__()
         self._endpoints = endpoints
         if not self._NS_REGEXP.match(namespace):
-            raise ValueError("Namespace %r does not match %r"
-                             % (namespace, self._NS_REGEXP_STR))
+            raise ValueError(
+                "Namespace %r does not match %r"
+                % (namespace, self._NS_REGEXP_STR)
+            )
         self._namespace = namespace
         self._timeout = timeout
 
@@ -51,14 +53,14 @@ def timeout(self):
 
 
 def _get_client(client_cls, endpoints, namespace, timeout):
-    conf = Config(endpoints=endpoints,
-                  namespace=namespace,
-                  timeout=timeout)
+    conf = Config(endpoints=endpoints, namespace=namespace, timeout=timeout)
     return client_cls(conf=conf)
 
 
 def get_wrapped_client(endpoints, namespace, timeout):
-    return _get_client(client_cls=wrapped_client.WrappedHTTPEtcdClient,
-                       endpoints=endpoints,
-                       namespace=namespace,
-                       timeout=timeout)
+    return _get_client(
+        client_cls=wrapped_client.WrappedHTTPEtcdClient,
+        endpoints=endpoints,
+        namespace=namespace,
+        timeout=timeout,
+    )

httpetcd/common/exc.py

@@ -37,8 +37,9 @@ def suppress_any(msg=None, level=logging.ERROR, exc_info=True, adapter=None):
 
 
 @contextlib.contextmanager
-def reraise_original(msg=None, level=logging.ERROR, exc_info=True,
-                     adapter=None):
+def reraise_original(
+    msg=None, level=logging.ERROR, exc_info=True, adapter=None
+):
     _exc_info = sys.exc_info()
     try:
         yield

httpetcd/exceptions.py

@@ -59,5 +59,6 @@ class UnsuccessfulResponse(EtcdException):
     def __init__(self, code, resp):
         self.code = code
         self.resp = resp
-        super(UnsuccessfulResponse, self).__init__("Server returned code: %s"
-                                                   % self.code)
+        super(UnsuccessfulResponse, self).__init__(
+            "Server returned code: %s" % self.code
+        )

httpetcd/library/session.py

@@ -55,39 +55,52 @@ def __init__(self, endpoints, api_path, timeout):
     def _shift_endpoint(self, reason):
         old_ep = self._endpoint
         self._endpoint = next(self._ep_cycled)
-        self._l(LOG).info("Shifted endpoint from %s to %s for reason: %r",
-                          old_ep, self._endpoint, reason)
+        self._l(LOG).info(
+            "Shifted endpoint from %s to %s for reason: %r",
+            old_ep,
+            self._endpoint,
+            reason,
+        )
 
     def request(self, path, data, codes=enum.IntEnum):
         url = compat.urljoin(self._endpoint, path)
         try:
-            self._l(LOG).debug("Requesting url %s with timeout %d",
-                               url, self._timeout)
-            resp = self._session.post(url=url,
-                                      json=data,
-                                      timeout=self._timeout)
+            self._l(LOG).debug(
+                "Requesting url %s with timeout %d", url, self._timeout
+            )
+            resp = self._session.post(
+                url=url, json=data, timeout=self._timeout
+            )
         except req_exc.ConnectionError as e:
             self._shift_endpoint(e)
             exc_info = sys.exc_info()
-            six.reraise(exceptions.ConnectionError,
-                        exceptions.ConnectionError((self._endpoint,),
-                                                   repr(exc_info[1])),
-                        exc_info[2])
+            six.reraise(
+                exceptions.ConnectionError,
+                exceptions.ConnectionError(
+                    (self._endpoint,), repr(exc_info[1])
+                ),
+                exc_info[2],
+            )
         except req_exc.ReadTimeout:
             # May happen when master etcd node location is controlled by
             # switching IP address in DNS record pointing to the master node.
             # We have to reestablish connection to fetch correct IP address.
             self._session.close()
             exc_info = sys.exc_info()
-            six.reraise(exceptions.ConnectionError,
-                        exceptions.ConnectionError((self._endpoint,),
-                                                   repr(exc_info[1])),
-                        exc_info[2])
+            six.reraise(
+                exceptions.ConnectionError,
+                exceptions.ConnectionError(
+                    (self._endpoint,), repr(exc_info[1])
+                ),
+                exc_info[2],
+            )
         except Exception:
             exc_info = sys.exc_info()
-            six.reraise(exceptions.EtcdException,
-                        exceptions.EtcdException(repr(exc_info[1])),
-                        exc_info[2])
+            six.reraise(
+                exceptions.EtcdException,
+                exceptions.EtcdException(repr(exc_info[1])),
+                exc_info[2],
+            )
         resp.raise_for_status()
         result = resp.json()
         self._l(LOG).debug("Response: %s", result)
@@ -98,13 +111,16 @@ def request(self, path, data, codes=enum.IntEnum):
         try:
             code = codes(result["code"])
         except ValueError:
-            raise exceptions.UnknownResponseCode("path=%s, data=%r, result=%r"
-                                                 % (path, data, result))
+            raise exceptions.UnknownResponseCode(
+                "path=%s, data=%r, result=%r" % (path, data, result)
+            )
 
         raise exceptions.UnsuccessfulResponse(code=code, resp=result)
 
 
 def get_session(endpoints, timeout):
-    return Session(endpoints=endpoints,
-                   api_path=constants.APIVersions.V3BETA.value + "/",
-                   timeout=timeout)
+    return Session(
+        endpoints=endpoints,
+        api_path=constants.APIVersions.V3BETA.value + "/",
+        timeout=timeout,
+    )

httpetcd/raw/entities/lease.py

@@ -46,8 +46,9 @@ def id(self):
 
     def refresh(self):
         self._l(LOG).debug("Refreshing...")
-        resp = self._session.request(path="lease/keepalive",
-                                     data={"ID": self._id})
+        resp = self._session.request(
+            path="lease/keepalive", data={"ID": self._id}
+        )
 
         try:
             result = resp["result"]
@@ -62,9 +63,9 @@ def refresh(self):
             raise exceptions.LeaseExpired()
 
     def _ttl(self, with_keys):
-        return self._session.request(path="lease/timetolive",
-                                     data={"ID": self._id,
-                                           "keys": with_keys})
+        return self._session.request(
+            path="lease/timetolive", data={"ID": self._id, "keys": with_keys}
+        )
 
     def ttl(self):
         resp = self._ttl(with_keys=False)
@@ -97,9 +98,9 @@ def revoke(self):
         self._l(LOG).debug("Revoking...")
         lr_codes = codes.LeaseRevokeCodes
         try:
-            self._session.request(path="lease/revoke",
-                                  data={"ID": self._id},
-                                  codes=lr_codes)
+            self._session.request(
+                path="lease/revoke", data={"ID": self._id}, codes=lr_codes
+            )
             self._l(LOG).info("Revoked.")
             return True
         except exceptions.UnsuccessfulResponse as e: