yandexcloud 0.287.0__py3-none-any.whl → 0.289.0__py3-none-any.whl

yandexcloud/_helpers.py

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+from typing import TYPE_CHECKING, Optional
 
 from yandex.cloud.iam.v1.service_account_service_pb2 import ListServiceAccountsRequest
 from yandex.cloud.iam.v1.service_account_service_pb2_grpc import (
@@ -9,64 +10,51 @@ from yandex.cloud.vpc.v1.network_service_pb2_grpc import NetworkServiceStub
 from yandex.cloud.vpc.v1.subnet_service_pb2 import ListSubnetsRequest
 from yandex.cloud.vpc.v1.subnet_service_pb2_grpc import SubnetServiceStub
 
+if TYPE_CHECKING:
+    from yandexcloud._sdk import SDK
 
-class Helpers(object):
-    def __init__(self, sdk):
+
+class Helpers:
+    def __init__(self, sdk: "SDK"):
         self.sdk = sdk
 
-    def find_service_account_id(self, folder_id):
+    def find_service_account_id(self, folder_id: str) -> str:
         """
         Get service account id in case the folder has the only one service account
 
         :param folder_id: ID of the folder
-        :type folder_id: str
         :return ID of the service account
-        :rtype str
         """
         service = self.sdk.client(ServiceAccountServiceStub)
         service_accounts = service.List(ListServiceAccountsRequest(folder_id=folder_id)).service_accounts
         if len(service_accounts) == 1:
             return service_accounts[0].id
         if len(service_accounts) == 0:
-            raise RuntimeError(
-                "There are no service accounts in folder {folder_id}, please create it.".format(folder_id=folder_id)
-            )
-        raise RuntimeError(
-            "There are more than one service account in folder {folder_id}, please specify it".format(
-                folder_id=folder_id
-            )
-        )
+            raise RuntimeError(f"There are no service accounts in folder {folder_id}, please create it.")
+        raise RuntimeError(f"There are more than one service account in folder {folder_id}, please specify it")
 
-    def find_network_id(self, folder_id):
+    def find_network_id(self, folder_id: str) -> str:
         """
         Get ID of the first network in folder
 
         :param folder_id: ID of the folder
-        :type folder_id: str
         :return ID of the network
-        :rtype str
         """
         networks = self.sdk.client(NetworkServiceStub).List(ListNetworksRequest(folder_id=folder_id)).networks
         if not networks:
-            raise RuntimeError("No networks in folder: {folder_id}".format(folder_id=folder_id))
+            raise RuntimeError(f"No networks in folder: {folder_id}")
         if len(networks) > 1:
-            raise RuntimeError(
-                "There are more than one network in folder {folder_id}, please specify it".format(folder_id=folder_id)
-            )
+            raise RuntimeError("There are more than one network in folder {folder_id}, please specify it")
         return networks[0].id
 
-    def find_subnet_id(self, folder_id, zone_id, network_id=None):
+    def find_subnet_id(self, folder_id: str, zone_id: str, network_id: Optional[str] = None) -> str:
         """
         Get ID of the subnetwork of specified network in specified availability zone
 
         :param folder_id: ID of the folder
-        :type folder_id: str
         :param zone_id: ID of the availability zone
-        :type zone_id: str
         :param network_id: ID of the network
-        :type network_id: str
         :return ID of the subnetwork
-        :rtype str
         """
         subnet_service = self.sdk.client(SubnetServiceStub)
         subnets = subnet_service.List(ListSubnetsRequest(folder_id=folder_id)).subnets
@@ -77,7 +65,5 @@ class Helpers(object):
         if len(applicable) == 1:
             return applicable[0].id
         if len(applicable) == 0:
-            raise RuntimeError("There are no subnets in {zone_id} zone, please create it.".format(zone_id=zone_id))
-        raise RuntimeError(
-            "There are more than one subnet in {zone_id} zone, please specify it".format(zone_id=zone_id)
-        )
+            raise RuntimeError(f"There are no subnets in {zone_id} zone, please create it.")
+        raise RuntimeError(f"There are more than one subnet in {zone_id} zone, please specify it")

yandexcloud/_operation_waiter.py

@@ -1,6 +1,7 @@
 import logging
 import time
 from datetime import datetime
+from typing import TYPE_CHECKING, Optional, Type, Union
 
 import grpc
 from google.protobuf.empty_pb2 import Empty
@@ -11,8 +12,14 @@ from yandexcloud._backoff import backoff_exponential_jittered_min_interval
 from yandexcloud._retry_interceptor import RetryInterceptor
 from yandexcloud.operations import OperationError, OperationResult
 
+if TYPE_CHECKING:
+    import google.protobuf.message
 
-def operation_waiter(sdk, operation_id, timeout):
+    from yandex.cloud.operation.operation_pb2 import Operation
+    from yandexcloud._sdk import SDK
+
+
+def operation_waiter(sdk: "SDK", operation_id: str, timeout: Optional[float]) -> "OperationWaiter":
     retriable_codes = (
         grpc.StatusCode.UNAVAILABLE,
         grpc.StatusCode.RESOURCE_EXHAUSTED,
@@ -32,14 +39,21 @@ def operation_waiter(sdk, operation_id, timeout):
     return OperationWaiter(operation_id, operation_service, timeout)
 
 
-def wait_for_operation(sdk, operation_id, timeout):
+def wait_for_operation(sdk: "SDK", operation_id: str, timeout: Optional[float]) -> Optional["Operation"]:
     waiter = operation_waiter(sdk, operation_id, timeout)
     for _ in waiter:
         time.sleep(1)
     return waiter.operation
 
 
-def get_operation_result(sdk, operation, response_type=None, meta_type=None, timeout=None, logger=None):
+def get_operation_result(
+    sdk: "SDK",
+    operation: "Operation",
+    response_type: Optional[Type["google.protobuf.message.Message"]] = None,
+    meta_type: Optional[Type["google.protobuf.message.Message"]] = None,
+    timeout: Optional[float] = None,
+    logger: Optional[logging.Logger] = None,
+) -> Union["OperationResult", "OperationError"]:
     if not logger:
         logger = logging.getLogger()
         logger.addHandler(logging.NullHandler())
@@ -47,8 +61,8 @@ def get_operation_result(sdk, operation, response_type=None, meta_type=None, tim
     created_at = datetime.fromtimestamp(operation.created_at.seconds)
     message = (
         "Running Yandex.Cloud operation. ID: {id}. "
-        + "Description: {description}. Created at: {created_at}. "
-        + "Created by: {created_by}."
+        "Description: {description}. Created at: {created_at}. "
+        "Created by: {created_by}."
     )
     message = message.format(
         id=operation.id,
@@ -60,14 +74,14 @@ def get_operation_result(sdk, operation, response_type=None, meta_type=None, tim
         unpacked_meta = meta_type()
         operation.metadata.Unpack(unpacked_meta)
         operation_result.meta = unpacked_meta
-        message += " Meta: {unpacked_meta}.".format(unpacked_meta=unpacked_meta)
+        message += f" Meta: {unpacked_meta}."
     logger.info(message)
     result = wait_for_operation(sdk, operation.id, timeout=timeout)
+    if result is None:
+        return OperationError(message="Unexpected operation result", operation_result=OperationResult(operation))
     if result.error and result.error.code:
         error_message = (
-            "Error Yandex.Cloud operation. ID: {id}. "
-            + "Error code: {code}. Details: {details}. "
-            + "Message: {message}."
+            "Error Yandex.Cloud operation. ID: {id}. Error code: {code}. Details: {details}. Message: {message}."
         )
         error_message = error_message.format(
             id=result.id,
@@ -76,38 +90,38 @@ def get_operation_result(sdk, operation, response_type=None, meta_type=None, tim
             message=result.error.message,
         )
         logger.error(error_message)
-        raise OperationError(message=error_message, operation_result=result)
+        raise OperationError(message=error_message, operation_result=OperationResult(operation))
 
-    log_message = "Done Yandex.Cloud operation. ID: {id}.".format(id=operation.id)
+    log_message = f"Done Yandex.Cloud operation. ID: {operation.id}."
     if response_type and response_type is not Empty:
         unpacked_response = response_type()
         result.response.Unpack(unpacked_response)
         operation_result.response = unpacked_response
-        log_message += " Response: {unpacked_response}.".format(unpacked_response=unpacked_response)
+        log_message += f" Response: {unpacked_response}."
     logger.info(log_message)
     return operation_result
 
 
 class OperationWaiter:
-    def __init__(self, operation_id, operation_service, timeout=None):
-        self.__operation = None
+    def __init__(self, operation_id: str, operation_service: "OperationServiceStub", timeout: Optional[float] = None):
+        self.__operation: Optional["Operation"] = None
         self.__operation_id = operation_id
         self.__operation_service = operation_service
         self.__deadline = time.time() + timeout if timeout else None
 
     @property
-    def operation(self):
+    def operation(self) -> Optional["Operation"]:
         return self.__operation
 
     @property
-    def done(self):
+    def done(self) -> bool:
         self.__operation = self.__operation_service.Get(GetOperationRequest(operation_id=self.__operation_id))
         return self.__operation is not None and self.__operation.done
 
-    def __iter__(self):
+    def __iter__(self) -> "OperationWaiter":
         return self
 
-    def __next__(self):
+    def __next__(self) -> None:
         if self.done or self.__deadline is not None and time.time() >= self.__deadline:
             raise StopIteration()
 

yandexcloud/_retry_interceptor.py

@@ -1,6 +1,7 @@
 import collections
 import time
 import uuid
+from typing import Callable, Iterable, Optional
 
 import grpc
 
@@ -41,11 +42,11 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
 
     def __init__(
         self,
-        max_retry_count=0,
-        retriable_codes=_DEFAULT_RETRIABLE_CODES,
-        add_retry_count_to_header=False,
-        back_off_func=None,
-        per_call_timeout=None,
+        max_retry_count: int = 0,
+        retriable_codes: Iterable["grpc.StatusCode"] = _DEFAULT_RETRIABLE_CODES,
+        add_retry_count_to_header: bool = False,
+        back_off_func: Optional[Callable[[int], float]] = None,
+        per_call_timeout: Optional[float] = None,
     ):
         # pylint: disable=super-init-not-called
         self.__max_retry_count = max_retry_count
@@ -54,7 +55,12 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
         self.__back_off_func = back_off_func
         self.__per_call_timeout = per_call_timeout
 
-    def intercept_unary_unary(self, continuation, client_call_details, request):
+    def intercept_unary_unary(
+        self,
+        continuation: Callable[["grpc.ClientCallDetails", "grpc.TRequest"], "grpc.CallFuture[grpc.TResponse]"],
+        client_call_details: "grpc.ClientCallDetails",
+        request: "grpc.TRequest",
+    ) -> "grpc.CallFuture[grpc.TResponse]":
         client_call_details = self.__add_idempotency_token(client_call_details)
 
         attempt = 0
@@ -66,7 +72,7 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
             except _RetryCall:
                 attempt += 1
 
-    def __wait_backoff(self, attempt, deadline):
+    def __wait_backoff(self, attempt: int, deadline: Optional[float]) -> None:
         if self.__back_off_func is None:
             return
 
@@ -82,10 +88,10 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
             time.sleep(backoff_timeout)
 
     @staticmethod
-    def __deadline(timeout):
+    def __deadline(timeout: Optional[float]) -> Optional[float]:
         return time.time() + timeout if timeout is not None else None
 
-    def __is_retriable(self, error):
+    def __is_retriable(self, error: "grpc.StatusCode") -> bool:
         if error in self._NON_RETRIABLE_CODES:
             return False
 
@@ -95,7 +101,9 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
         return False
 
     @staticmethod
-    def __min_deadline(d1, d2):
+    def __min_deadline(d1: Optional[float], d2: Optional[float]) -> Optional[float]:
+        if d2 is None and d1 is None:
+            return None
         if d1 is None:
             return d2
 
@@ -104,7 +112,14 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
 
         return min(d1, d2)
 
-    def __grpc_call(self, attempt, deadline, continuation, client_call_details, request):
+    def __grpc_call(
+        self,
+        attempt: int,
+        deadline: Optional[float],
+        continuation: Callable[["grpc.ClientCallDetails", "grpc.TRequest"], "grpc.CallFuture[grpc.TResponse]"],
+        client_call_details: "grpc.ClientCallDetails",
+        request: "grpc.TRequest",
+    ) -> "grpc.CallFuture[grpc.TResponse]":
         if attempt > 0:
             if self.__add_retry_count_to_header:
                 client_call_details = self.__append_retry_attempt_header(client_call_details, attempt)
@@ -115,24 +130,21 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
             if call_deadline is not None:
                 client_call_details = self.__adjust_timeout(client_call_details, call_deadline)
 
-        def retry():
+        def retry() -> None:
             self.__wait_backoff(attempt, deadline)
             raise _RetryCall()
 
         try:
             result = continuation(client_call_details, request)
-            if isinstance(result, grpc.RpcError):
+            if isinstance(result, grpc.RpcError):  # type: ignore
                 raise result
             return result
-        except grpc.RpcError as e:
+        except grpc.RpcError as error:
             # no retries left
             if 0 <= self.__max_retry_count <= attempt:
                 raise
 
-            err_code = None
-            if isinstance(e, grpc.Call):
-                err_code = e.code()
-
+            err_code = error.code()  # pylint: disable=no-member
             if err_code == grpc.StatusCode.DEADLINE_EXCEEDED:
                 # if there is no per_call_timeout, or it is original deadline -> abort, otherwise, retry call.
                 if self.__per_call_timeout is None or deadline is not None and deadline < time.time():
@@ -144,9 +156,10 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
                 raise
 
         retry()
+        raise RuntimeError("Unexpected behavior")
 
     @staticmethod
-    def __adjust_timeout(client_call_details, deadline):
+    def __adjust_timeout(client_call_details: "grpc.ClientCallDetails", deadline: float) -> "grpc.ClientCallDetails":
         timeout = max(deadline - time.time(), 0.0)
         return _ClientCallDetails(
             client_call_details.method,
@@ -157,14 +170,18 @@ class RetryInterceptor(grpc.UnaryUnaryClientInterceptor):
             getattr(client_call_details, "compression", None),
         )
 
-    def __add_idempotency_token(self, client_call_details):
+    def __add_idempotency_token(self, client_call_details: "grpc.ClientCallDetails") -> "grpc.ClientCallDetails":
         return self.__append_metadata(client_call_details, self._IDEMPOTENCY_TOKEN_METADATA_KEY, str(uuid.uuid4()))
 
-    def __append_retry_attempt_header(self, client_call_details, attempt):
+    def __append_retry_attempt_header(
+        self, client_call_details: "grpc.ClientCallDetails", attempt: int
+    ) -> "grpc.ClientCallDetails":
         return self.__append_metadata(client_call_details, self._ATTEMPT_METADATA_KEY, str(attempt), force=True)
 
     @staticmethod
-    def __append_metadata(client_call_details, header, value, force=False):
+    def __append_metadata(
+        client_call_details: "grpc.ClientCallDetails", header: str, value: str, force: bool = False
+    ) -> "grpc.ClientCallDetails":
         metadata = []
         if client_call_details.metadata is not None:
             metadata = list(client_call_details.metadata)

yandexcloud/_sdk.py

@@ -1,5 +1,5 @@
 import inspect
-from typing import Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, Union
 
 import grpc
 
@@ -8,25 +8,57 @@ from yandexcloud._backoff import backoff_exponential_with_jitter
 from yandexcloud._retry_interceptor import RetryInterceptor
 from yandexcloud._wrappers import Wrappers
 
+if TYPE_CHECKING:
+    import logging
+
+    import google.protobuf.message
+
+    from yandex.cloud.operation.operation_pb2 import Operation
+    from yandexcloud._operation_waiter import OperationWaiter
+    from yandexcloud.operations import OperationError, OperationResult
+
 
 class SDK:
-    def __init__(self, interceptor=None, user_agent=None, endpoints: Optional[Dict[str, str]] = None, **kwargs):
+    def __init__(
+        self,
+        interceptor: Union[
+            grpc.UnaryUnaryClientInterceptor,
+            grpc.UnaryStreamClientInterceptor,
+            grpc.StreamUnaryClientInterceptor,
+            grpc.StreamStreamClientInterceptor,
+            None,
+        ] = None,
+        user_agent: Optional[str] = None,
+        endpoints: Optional[Dict[str, str]] = None,
+        token: Optional[str] = None,
+        iam_token: Optional[str] = None,
+        endpoint: Optional[str] = None,
+        service_account_key: Optional[Dict[str, str]] = None,
+        root_certificates: Optional[bytes] = None,
+        private_key: Optional[bytes] = None,
+        certificate_chain: Optional[bytes] = None,
+        **kwargs: str,
+    ):
         """
         API entry-point object.
 
         :param interceptor: GRPC interceptor to be used instead of default RetryInterceptor
-        :type interceptor: Union[
-            UnaryUnaryClientInterceptor,
-            UnaryStreamClientInterceptor,
-            StreamUnaryClientInterceptor,
-            StreamStreamClientInterceptor
-        ]
         :param user_agent: String to prepend User-Agent metadata header for all GRPC requests made via SDK object
-        :type user_agent: Optional[str]
         :param endpoints: Dict with services endpoints overrides. Example: {'vpc': 'new.vpc.endpoint:443'}
 
         """
-        self._channels = _channels.Channels(client_user_agent=user_agent, endpoints=endpoints, **kwargs)
+        self._channels = _channels.Channels(
+            user_agent,
+            endpoints,
+            token,
+            iam_token,
+            endpoint,
+            service_account_key,
+            root_certificates,
+            private_key,
+            certificate_chain,
+            **kwargs,
+        )
         if interceptor is None:
             interceptor = RetryInterceptor(
                 max_retry_count=5,
@@ -37,10 +69,19 @@ class SDK:
         self.helpers = _helpers.Helpers(self)
         self.wrappers = Wrappers(self)
 
-    def set_interceptor(self, interceptor):
-        self._default_interceptor = interceptor
-
-    def client(self, stub_ctor, interceptor=None, endpoint: Optional[str] = None, insecure: bool = False):
+    def client(
+        self,
+        stub_ctor: Type,
+        interceptor: Union[
+            grpc.UnaryUnaryClientInterceptor,
+            grpc.UnaryStreamClientInterceptor,
+            grpc.StreamUnaryClientInterceptor,
+            grpc.StreamStreamClientInterceptor,
+            None,
+        ] = None,
+        endpoint: Optional[str] = None,
+        insecure: bool = False,
+    ) -> Any:
         service = _service_for_ctor(stub_ctor)
         channel = self._channels.channel(service, endpoint, insecure)
         if interceptor is not None:
@@ -49,22 +90,29 @@ class SDK:
             channel = grpc.intercept_channel(channel, self._default_interceptor)
         return stub_ctor(channel)
 
-    def waiter(self, operation_id, timeout=None):
+    def waiter(self, operation_id: str, timeout: Optional[float] = None) -> "OperationWaiter":
         return _operation_waiter.operation_waiter(self, operation_id, timeout)
 
-    def wait_operation_and_get_result(self, operation, response_type=None, meta_type=None, timeout=None, logger=None):
+    def wait_operation_and_get_result(
+        self,
+        operation: "Operation",
+        response_type: Optional[Type["google.protobuf.message.Message"]] = None,
+        meta_type: Optional[Type["google.protobuf.message.Message"]] = None,
+        timeout: Optional[float] = None,
+        logger: Optional["logging.Logger"] = None,
+    ) -> Union["OperationResult", "OperationError"]:
         return _operation_waiter.get_operation_result(self, operation, response_type, meta_type, timeout, logger)
 
     def create_operation_and_get_result(
         self,
-        request,
-        service,
-        method_name,
-        response_type=None,
-        meta_type=None,
-        timeout=None,
-        logger=None,
-    ):
+        request: Type["google.protobuf.message.Message"],
+        service: Any,
+        method_name: str,
+        response_type: Optional[Type["google.protobuf.message.Message"]] = None,
+        meta_type: Optional[Type["google.protobuf.message.Message"]] = None,
+        timeout: Optional[float] = None,
+        logger: Optional["logging.Logger"] = None,
+    ) -> Union["OperationResult", "OperationError"]:
         operation = getattr(self.client(service), method_name)(request)
         return self.wait_operation_and_get_result(
             operation,
@@ -75,17 +123,18 @@ class SDK:
         )
 
 
-def _service_for_ctor(stub_ctor):
+def _service_for_ctor(stub_ctor: Any) -> str:
     m = inspect.getmodule(stub_ctor)
-    name = m.__name__
-    if not name.startswith("yandex.cloud"):
-        raise RuntimeError("Not a yandex.cloud service {}".format(stub_ctor))
+    if m is not None:
+        name = m.__name__
+        if not name.startswith("yandex.cloud"):
+            raise RuntimeError(f"Not a yandex.cloud service {stub_ctor}")
 
-    for k, v in _supported_modules:
-        if name.startswith(k):
-            return v
+        for k, v in _supported_modules:
+            if name.startswith(k):
+                return v
 
-    raise RuntimeError("Unknown service {}".format(stub_ctor))
+    raise RuntimeError(f"Unknown service {stub_ctor}")
 
 
 _supported_modules = [

yandexcloud/_wrappers/__init__.py

@@ -1,8 +1,15 @@
+from typing import TYPE_CHECKING
+
 from yandexcloud._wrappers.dataproc import Dataproc, InitializationAction
 
+if TYPE_CHECKING:
+    from yandexcloud._sdk import SDK
+
 
-class Wrappers(object):
-    def __init__(self, sdk):
+class Wrappers:
+    def __init__(self, sdk: "SDK"):
+        # pylint: disable-next=invalid-name
         self.Dataproc = Dataproc
         self.Dataproc.sdk = sdk
+        # pylint: disable-next=invalid-name
         self.InitializationAction = InitializationAction

yandexcloud/_wrappers/dataproc/__init__.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 # pylint: disable=no-member
+# mypy: ignore-errors
 import logging
 import random
 from typing import List, NamedTuple
@@ -32,7 +33,7 @@ class InitializationAction(NamedTuple):
         )
 
 
-class Dataproc(object):
+class Dataproc:
     """
     A base hook for Yandex.Cloud Data Proc.
 
@@ -47,7 +48,7 @@ class Dataproc(object):
     """
 
     def __init__(self, default_folder_id=None, default_public_ssh_key=None, logger=None, sdk=None):
-        self.sdk = sdk or self.sdk
+        self.sdk = sdk
         self.log = logger
         if not self.log:
             self.log = logging.getLogger()
@@ -200,7 +201,7 @@ class Dataproc(object):
 
         if not cluster_name:
             random_int = random.randint(0, 999)
-            cluster_name = "dataproc-{random_int}".format(random_int=random_int)
+            cluster_name = f"dataproc-{random_int}"
 
         if not subnet_id:
             network_id = self.sdk.helpers.find_network_id(folder_id)
@@ -397,7 +398,7 @@ class Dataproc(object):
             disk_type_id=disk_type,
         )
 
-        self.log.info("Adding subcluster to cluster {cluster_id}".format(cluster_id=cluster_id))
+        self.log.info("Adding subcluster to cluster %s", cluster_id)
         autoscaling_config = None
         if max_hosts_count:
             autoscaling_config = subcluster_pb.AutoscalingConfig(
@@ -439,7 +440,7 @@ class Dataproc(object):
         if not cluster_id:
             raise RuntimeError("Cluster id must be specified.")
 
-        self.log.info("Updating cluster {cluster_id}".format(cluster_id=cluster_id))
+        self.log.info("Updating cluster %s", cluster_id)
         mask = FieldMask(paths=["description"])
         request = cluster_service_pb.UpdateClusterRequest(
             cluster_id=cluster_id,
@@ -464,7 +465,7 @@ class Dataproc(object):
         if not cluster_id:
             raise RuntimeError("Cluster id must be specified.")
 
-        self.log.info("Deleting cluster {cluster_id}".format(cluster_id=cluster_id))
+        self.log.info("Deleting cluster %s", cluster_id)
         request = cluster_service_pb.DeleteClusterRequest(cluster_id=cluster_id)
         return self.sdk.create_operation_and_get_result(
             request,
@@ -507,7 +508,7 @@ class Dataproc(object):
             raise RuntimeError("Cluster id must be specified.")
         if (query and query_file_uri) or not (query or query_file_uri):
             raise RuntimeError("Either query or query_file_uri must be specified.")
-        self.log.info("Running Hive job. Cluster ID: {cluster_id}".format(cluster_id=cluster_id))
+        self.log.info("Running Hive job. Cluster ID: %s", cluster_id)
 
         hive_job = job_pb.HiveJob(
             query_file_uri=query_file_uri,
@@ -574,7 +575,7 @@ class Dataproc(object):
         cluster_id = cluster_id or self.cluster_id
         if not cluster_id:
             raise RuntimeError("Cluster id must be specified.")
-        self.log.info("Running Mapreduce job. Cluster ID: {cluster_id}".format(cluster_id=cluster_id))
+        self.log.info("Running Mapreduce job. Cluster ID: %s", cluster_id)
 
         request = job_service_pb.CreateJobRequest(
             cluster_id=cluster_id,
@@ -646,7 +647,7 @@ class Dataproc(object):
         cluster_id = cluster_id or self.cluster_id
         if not cluster_id:
             raise RuntimeError("Cluster id must be specified.")
-        self.log.info("Running Spark job. Cluster ID: {cluster_id}".format(cluster_id=cluster_id))
+        self.log.info("Running Spark job. Cluster ID: %s", cluster_id)
 
         request = job_service_pb.CreateJobRequest(
             cluster_id=cluster_id,
@@ -721,7 +722,7 @@ class Dataproc(object):
         cluster_id = cluster_id or self.cluster_id
         if not cluster_id:
             raise RuntimeError("Cluster id must be specified.")
-        self.log.info("Running Pyspark job. Cluster ID: {cluster_id}".format(cluster_id=cluster_id))
+        self.log.info("Running Pyspark job. Cluster ID: %s", cluster_id)
         request = job_service_pb.CreateJobRequest(
             cluster_id=cluster_id,
             name=name,

yandexcloud/auth.py

@@ -1,14 +1,22 @@
+from typing import Dict, Optional
+
 from yandex.cloud.iam.v1.iam_token_service_pb2_grpc import IamTokenServiceStub
-from yandexcloud import SDK
 from yandexcloud._auth_fabric import (
     YC_API_ENDPOINT,
     IamTokenAuth,
     MetadataAuth,
     get_auth_token_requester,
 )
+from yandexcloud._sdk import SDK
 
 
-def get_auth_token(token=None, service_account_key=None, iam_token=None, metadata_addr=None, endpoint=None):
+def get_auth_token(
+    token: Optional[str] = None,
+    service_account_key: Optional[Dict[str, str]] = None,
+    iam_token: Optional[str] = None,
+    metadata_addr: Optional[str] = None,
+    endpoint: Optional[str] = None,
+) -> str:
     if endpoint is None:
         endpoint = YC_API_ENDPOINT
     requester = get_auth_token_requester(