add black-format & run black as check only

ref:8877577
sync: https://proxy.sandbox.yandex-team.ru/2587248720

Author: gridnevvvit

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py38,style,pylint,black,protoc
+envlist = py36,py38,style,pylint,black,protoc
 minversion = 3.14.4
 skipsdist = True
 ignore_basepython_conflict = true
@@ -17,6 +17,15 @@ deps =
 commands =
     python3 generate_protoc.py
 
+
+[testenv:py36]
+commands =
+    pytest -v -m "not tls" --docker-compose-remove-volumes --docker-compose=docker-compose.yml {posargs}
+
+[testenv:py36-tls]
+commands =
+    pytest -v -m tls --docker-compose-remove-volumes --docker-compose=docker-compose-tls.yml {posargs}
+
 [testenv:py38]
 commands =
     pytest -v -m "not tls" --docker-compose-remove-volumes --docker-compose=docker-compose.yml {posargs}
@@ -25,11 +34,17 @@ commands =
 commands =
     pytest -v -m tls --docker-compose-remove-volumes --docker-compose=docker-compose-tls.yml {posargs}
 
+[testenv:black-format]
+skip_install = true
+deps = black
+commands =
+    black ydb examples tests
+
 [testenv:black]
 skip_install = true
 deps = black
 commands =
-    black ydb examples
+    black --check ydb examples tests
 
 [testenv:pylint]
 deps = pylint

ydb/iam/auth.py

@@ -29,19 +29,25 @@
     requests = None
 
 
-DEFAULT_METADATA_URL = 'http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/token'
+DEFAULT_METADATA_URL = (
+    "http://169.254.169.254/computeMetadata/v1/instance/service-accounts/default/token"
+)
 
 
 def get_jwt(account_id, access_key_id, private_key, jwt_expiration_timeout):
     now = time.time()
     now_utc = datetime.utcfromtimestamp(now)
     exp_utc = datetime.utcfromtimestamp(now + jwt_expiration_timeout)
     return jwt.encode(
-        key=private_key, algorithm="PS256", headers={"typ": "JWT", "alg": "PS256", "kid": access_key_id},
+        key=private_key,
+        algorithm="PS256",
+        headers={"typ": "JWT", "alg": "PS256", "kid": access_key_id},
         payload={
             "iss": account_id,
-            "aud": "https://iam.api.cloud.yandex.net/iam/v1/tokens", "iat": now_utc, "exp": exp_utc
-        }
+            "aud": "https://iam.api.cloud.yandex.net/iam/v1/tokens",
+            "iat": now_utc,
+            "exp": exp_utc,
+        },
     )
 
 
@@ -110,25 +116,39 @@ def _get_iam_token(self):
     def _log_refresh_start(self, current_time):
         self.logger.debug("Start refresh token from metadata")
         if current_time > self._refresh_in:
-            self.logger.info("Cached token reached refresh_in deadline, current time %s, deadline %s", current_time,
-                             self._refresh_in)
+            self.logger.info(
+                "Cached token reached refresh_in deadline, current time %s, deadline %s",
+                current_time,
+                self._refresh_in,
+            )
 
         if current_time > self._expires_in and self._expires_in > 0:
-            self.logger.error("Cached token reached expires_in deadline, current time %s, deadline %s", current_time,
-                              self._expires_in)
+            self.logger.error(
+                "Cached token reached expires_in deadline, current time %s, deadline %s",
+                current_time,
+                self._expires_in,
+            )
 
     def _update_expiration_info(self, auth_metadata):
-        self._expires_in = time.time() + min(self._hour, auth_metadata['expires_in'] / 2)
-        self._refresh_in = time.time() + min(self._hour / 2, auth_metadata['expires_in'] / 4)
+        self._expires_in = time.time() + min(
+            self._hour, auth_metadata["expires_in"] / 2
+        )
+        self._refresh_in = time.time() + min(
+            self._hour / 2, auth_metadata["expires_in"] / 4
+        )
 
     def _refresh(self):
         current_time = time.time()
         self._log_refresh_start(current_time)
         try:
             auth_metadata = self._get_iam_token()
-            self._iam_token.update(auth_metadata['access_token'])
+            self._iam_token.update(auth_metadata["access_token"])
             self._update_expiration_info(auth_metadata)
-            self.logger.info("Token refresh successful. current_time %s, refresh_in %s", current_time, self._refresh_in)
+            self.logger.info(
+                "Token refresh successful. current_time %s, refresh_in %s",
+                current_time,
+                self._refresh_in,
+            )
 
         except (KeyboardInterrupt, SystemExit):
             return
@@ -143,41 +163,52 @@ def _refresh(self):
     def iam_token(self):
         current_time = time.time()
         if current_time > self._refresh_in:
-            tracing.trace(self.tracer, {
-                "refresh": True
-            })
+            tracing.trace(self.tracer, {"refresh": True})
             self._tp.submit(self._refresh)
         iam_token = self._iam_token.consume(timeout=3)
-        tracing.trace(
-            self.tracer, {
-                "consumed": True
-            }
-        )
+        tracing.trace(self.tracer, {"consumed": True})
         if iam_token is None:
             if self.last_error is None:
-                raise issues.ConnectionError("%s: timeout occurred while waiting for token.\n%s" % self.__class__.__name__, self.extra_error_message)
-            raise issues.ConnectionError("%s: %s.\n%s" % (self.__class__.__name__, self.last_error, self.extra_error_message))
+                raise issues.ConnectionError(
+                    "%s: timeout occurred while waiting for token.\n%s"
+                    % self.__class__.__name__,
+                    self.extra_error_message,
+                )
+            raise issues.ConnectionError(
+                "%s: %s.\n%s"
+                % (self.__class__.__name__, self.last_error, self.extra_error_message)
+            )
         return iam_token
 
     def auth_metadata(self):
-        return [
-            (credentials.YDB_AUTH_TICKET_HEADER, self.iam_token)
-        ]
+        return [(credentials.YDB_AUTH_TICKET_HEADER, self.iam_token)]
 
 
 @six.add_metaclass(abc.ABCMeta)
 class TokenServiceCredentials(IamTokenCredentials):
     def __init__(self, iam_endpoint=None, iam_channel_credentials=None, tracer=None):
         super(TokenServiceCredentials, self).__init__(tracer)
-        self._iam_endpoint = 'iam.api.cloud.yandex.net:443' if iam_endpoint is None else iam_endpoint
-        self._iam_channel_credentials = {} if iam_channel_credentials is None else iam_channel_credentials
+        self._iam_endpoint = (
+            "iam.api.cloud.yandex.net:443" if iam_endpoint is None else iam_endpoint
+        )
+        self._iam_channel_credentials = (
+            {} if iam_channel_credentials is None else iam_channel_credentials
+        )
         self._get_token_request_timeout = 10
-        if iam_token_service_pb2_grpc is None or jwt is None or iam_token_service_pb2 is None:
+        if (
+            iam_token_service_pb2_grpc is None
+            or jwt is None
+            or iam_token_service_pb2 is None
+        ):
             raise RuntimeError(
-                "Install jwt & yandex python cloud library to use service account credentials provider")
+                "Install jwt & yandex python cloud library to use service account credentials provider"
+            )
 
     def _channel_factory(self):
-        return grpc.secure_channel(self._iam_endpoint, grpc.ssl_channel_credentials(**self._iam_channel_credentials))
+        return grpc.secure_channel(
+            self._iam_endpoint,
+            grpc.ssl_channel_credentials(**self._iam_channel_credentials),
+        )
 
     @abc.abstractmethod
     def _get_token_request(self):
@@ -186,20 +217,20 @@ def _get_token_request(self):
     @tracing.with_trace()
     def _get_iam_token(self):
         with self._channel_factory() as channel:
-            tracing.trace(self.tracer, {
-                "iam_token.from_service": True
-            })
+            tracing.trace(self.tracer, {"iam_token.from_service": True})
             stub = iam_token_service_pb2_grpc.IamTokenServiceStub(channel)
-            response = stub.Create(self._get_token_request(), timeout=self._get_token_request_timeout)
+            response = stub.Create(
+                self._get_token_request(), timeout=self._get_token_request_timeout
+            )
             expires_in = max(0, response.expires_at.seconds - int(time.time()))
-            return {'access_token': response.iam_token, 'expires_in': expires_in}
+            return {"access_token": response.iam_token, "expires_in": expires_in}
 
 
 @six.add_metaclass(abc.ABCMeta)
 class BaseJWTCredentials(object):
     def __init__(self, account_id, access_key_id, private_key):
         self._account_id = account_id
-        self._jwt_expiration_timeout = 60. * 60
+        self._jwt_expiration_timeout = 60.0 * 60
         self._token_expiration_timeout = 120
         self._access_key_id = access_key_id
         self._private_key = private_key
@@ -210,40 +241,59 @@ def set_token_expiration_timeout(self, value):
 
     @classmethod
     def from_file(cls, key_file, iam_endpoint=None, iam_channel_credentials=None):
-        with open(os.path.expanduser(key_file), 'r') as r:
+        with open(os.path.expanduser(key_file), "r") as r:
             output = json.loads(r.read())
-        account_id = output.get('service_account_id', None)
+        account_id = output.get("service_account_id", None)
         if account_id is None:
-            account_id = output.get('user_account_id', None)
+            account_id = output.get("user_account_id", None)
         return cls(
             account_id,
-            output['id'],
-            output['private_key'],
+            output["id"],
+            output["private_key"],
             iam_endpoint=iam_endpoint,
-            iam_channel_credentials=iam_channel_credentials
+            iam_channel_credentials=iam_channel_credentials,
         )
 
 
 class JWTIamCredentials(TokenServiceCredentials, BaseJWTCredentials):
-    def __init__(self, account_id, access_key_id, private_key, iam_endpoint=None, iam_channel_credentials=None):
+    def __init__(
+        self,
+        account_id,
+        access_key_id,
+        private_key,
+        iam_endpoint=None,
+        iam_channel_credentials=None,
+    ):
         TokenServiceCredentials.__init__(self, iam_endpoint, iam_channel_credentials)
         BaseJWTCredentials.__init__(self, account_id, access_key_id, private_key)
 
     def _get_token_request(self):
         return iam_token_service_pb2.CreateIamTokenRequest(
             jwt=get_jwt(
-                self._account_id, self._access_key_id, self._private_key, self._jwt_expiration_timeout
+                self._account_id,
+                self._access_key_id,
+                self._private_key,
+                self._jwt_expiration_timeout,
             )
         )
 
 
 class YandexPassportOAuthIamCredentials(TokenServiceCredentials):
-    def __init__(self, yandex_passport_oauth_token, iam_endpoint=None, iam_channel_credentials=None):
+    def __init__(
+        self,
+        yandex_passport_oauth_token,
+        iam_endpoint=None,
+        iam_channel_credentials=None,
+    ):
         self._yandex_passport_oauth_token = yandex_passport_oauth_token
-        super(YandexPassportOAuthIamCredentials, self).__init__(iam_endpoint, iam_channel_credentials)
+        super(YandexPassportOAuthIamCredentials, self).__init__(
+            iam_endpoint, iam_channel_credentials
+        )
 
     def _get_token_request(self):
-        return iam_token_service_pb2.CreateIamTokenRequest(yandex_passport_oauth_token=self._yandex_passport_oauth_token)
+        return iam_token_service_pb2.CreateIamTokenRequest(
+            yandex_passport_oauth_token=self._yandex_passport_oauth_token
+        )
 
 
 class MetadataUrlCredentials(IamTokenCredentials):
@@ -256,18 +306,36 @@ def __init__(self, metadata_url=None, tracer=None):
         super(MetadataUrlCredentials, self).__init__(tracer)
         if requests is None:
             raise RuntimeError(
-                "Install requests library to use metadata credentials provider")
-        self._metadata_url = DEFAULT_METADATA_URL if metadata_url is None else metadata_url
+                "Install requests library to use metadata credentials provider"
+            )
+        self._metadata_url = (
+            DEFAULT_METADATA_URL if metadata_url is None else metadata_url
+        )
         self._tp.submit(self._refresh)
         self.extra_error_message = "Check that metadata service configured properly and application deployed in VM or function at Yandex.Cloud."
 
     @tracing.with_trace()
     def _get_iam_token(self):
-        response = requests.get(self._metadata_url, headers={'Metadata-Flavor': 'Google'}, timeout=3)
+        response = requests.get(
+            self._metadata_url, headers={"Metadata-Flavor": "Google"}, timeout=3
+        )
         response.raise_for_status()
         return json.loads(response.text)
 
 
 class ServiceAccountCredentials(JWTIamCredentials):
-    def __init__(self, service_account_id, access_key_id, private_key, iam_endpoint=None, iam_channel_credentials=None):
-        super(ServiceAccountCredentials, self).__init__(service_account_id, access_key_id, private_key, iam_endpoint, iam_channel_credentials)
+    def __init__(
+        self,
+        service_account_id,
+        access_key_id,
+        private_key,
+        iam_endpoint=None,
+        iam_channel_credentials=None,
+    ):
+        super(ServiceAccountCredentials, self).__init__(
+            service_account_id,
+            access_key_id,
+            private_key,
+            iam_endpoint,
+            iam_channel_credentials,
+        )

ydb/tornado/tornado_helpers.py

@@ -20,9 +20,7 @@ def on_timeout():
             foreign_future.cancel()
 
         timeout_timer.add(
-            tornado.ioloop.IOLoop.current().call_later(
-                timeout, on_timeout
-            )
+            tornado.ioloop.IOLoop.current().call_later(timeout, on_timeout)
         )
 
     def copy_to_result_future(foreign_future):
@@ -36,9 +34,9 @@ def copy_to_result_future(foreign_future):
             return
 
         if (
-                isinstance(foreign_future, TracebackFuture)
-                and isinstance(result_future, TracebackFuture)
-                and result_future.exc_info() is not None
+            isinstance(foreign_future, TracebackFuture)
+            and isinstance(result_future, TracebackFuture)
+            and result_future.exc_info() is not None
         ):
             result_future.set_exc_info(foreign_future.exc_info())
         elif foreign_future.cancelled():