yandexcloud 0.288.0__py3-none-any.whl → 0.290.0__py3-none-any.whl

yandex/cloud/ydb/v1/storage_type_pb2.pyi

@@ -0,0 +1,32 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import builtins
+import google.protobuf.descriptor
+import google.protobuf.message
+import typing
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing.final
+class StorageType(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    ID_FIELD_NUMBER: builtins.int
+    DEVICE_TYPE_FIELD_NUMBER: builtins.int
+    REDUNDANCY_TYPE_FIELD_NUMBER: builtins.int
+    id: builtins.str
+    device_type: builtins.str
+    redundancy_type: builtins.str
+    def __init__(
+        self,
+        *,
+        id: builtins.str = ...,
+        device_type: builtins.str = ...,
+        redundancy_type: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["device_type", b"device_type", "id", b"id", "redundancy_type", b"redundancy_type"]) -> None: ...
+
+global___StorageType = StorageType

yandex/cloud/ydb/v1/storage_type_pb2_grpc.pyi

@@ -0,0 +1,17 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import abc
+import collections.abc
+import grpc
+import grpc.aio
+import typing
+
+_T = typing.TypeVar("_T")
+
+class _MaybeAsyncIterator(collections.abc.AsyncIterator[_T], collections.abc.Iterator[_T], metaclass=abc.ABCMeta): ...
+
+class _ServicerContext(grpc.ServicerContext, grpc.aio.ServicerContext):  # type: ignore[misc, type-arg]
+    ...

yandex/cloud/ydb/v1/storage_type_service_pb2.pyi

@@ -0,0 +1,83 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import builtins
+import collections.abc
+import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.message
+import typing
+import yandex.cloud.ydb.v1.storage_type_pb2
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing.final
+class GetStorageTypeRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    STORAGE_TYPE_ID_FIELD_NUMBER: builtins.int
+    storage_type_id: builtins.str
+    """Required. ID of the storage type to return."""
+    def __init__(
+        self,
+        *,
+        storage_type_id: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["storage_type_id", b"storage_type_id"]) -> None: ...
+
+global___GetStorageTypeRequest = GetStorageTypeRequest
+
+@typing.final
+class ListStorageTypesRequest(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    PAGE_SIZE_FIELD_NUMBER: builtins.int
+    PAGE_TOKEN_FIELD_NUMBER: builtins.int
+    page_size: builtins.int
+    """The maximum number of results per page that should be returned. If the number of available
+    results is larger than `page_size`, the service returns a `next_page_token` that can be used
+    to get the next page of results in subsequent ListStorageTypes requests.
+    Acceptable values are 0 to 1000, inclusive. Default value: 100.
+    """
+    page_token: builtins.str
+    """Page token. Set `page_token` to the `next_page_token` returned by a previous ListStorageTypes
+    request to get the next page of results.
+    """
+    def __init__(
+        self,
+        *,
+        page_size: builtins.int = ...,
+        page_token: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["page_size", b"page_size", "page_token", b"page_token"]) -> None: ...
+
+global___ListStorageTypesRequest = ListStorageTypesRequest
+
+@typing.final
+class ListStorageTypesResponse(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    STORAGE_TYPES_FIELD_NUMBER: builtins.int
+    NEXT_PAGE_TOKEN_FIELD_NUMBER: builtins.int
+    next_page_token: builtins.str
+    """This token allows you to get the next page of results for ListStorageTypes requests,
+    if the number of results is larger than `page_size` specified in the request.
+    To get the next page, specify the value of `next_page_token` as a value for
+    the `page_token` parameter in the next ListStorageTypes request. Subsequent ListStorageTypes
+    requests will have their own `next_page_token` to continue paging through the results.
+    """
+    @property
+    def storage_types(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[yandex.cloud.ydb.v1.storage_type_pb2.StorageType]:
+        """Requested list of storage types."""
+
+    def __init__(
+        self,
+        *,
+        storage_types: collections.abc.Iterable[yandex.cloud.ydb.v1.storage_type_pb2.StorageType] | None = ...,
+        next_page_token: builtins.str = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["next_page_token", b"next_page_token", "storage_types", b"storage_types"]) -> None: ...
+
+global___ListStorageTypesResponse = ListStorageTypesResponse

yandex/cloud/ydb/v1/storage_type_service_pb2_grpc.pyi

@@ -0,0 +1,65 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import abc
+import collections.abc
+import grpc
+import grpc.aio
+import typing
+import yandex.cloud.ydb.v1.storage_type_pb2
+import yandex.cloud.ydb.v1.storage_type_service_pb2
+
+_T = typing.TypeVar("_T")
+
+class _MaybeAsyncIterator(collections.abc.AsyncIterator[_T], collections.abc.Iterator[_T], metaclass=abc.ABCMeta): ...
+
+class _ServicerContext(grpc.ServicerContext, grpc.aio.ServicerContext):  # type: ignore[misc, type-arg]
+    ...
+
+class StorageTypeServiceStub:
+    def __init__(self, channel: typing.Union[grpc.Channel, grpc.aio.Channel]) -> None: ...
+    Get: grpc.UnaryUnaryMultiCallable[
+        yandex.cloud.ydb.v1.storage_type_service_pb2.GetStorageTypeRequest,
+        yandex.cloud.ydb.v1.storage_type_pb2.StorageType,
+    ]
+    """Returns the specified storage types."""
+
+    List: grpc.UnaryUnaryMultiCallable[
+        yandex.cloud.ydb.v1.storage_type_service_pb2.ListStorageTypesRequest,
+        yandex.cloud.ydb.v1.storage_type_service_pb2.ListStorageTypesResponse,
+    ]
+    """Returns the list of available storage types."""
+
+class StorageTypeServiceAsyncStub:
+    Get: grpc.aio.UnaryUnaryMultiCallable[
+        yandex.cloud.ydb.v1.storage_type_service_pb2.GetStorageTypeRequest,
+        yandex.cloud.ydb.v1.storage_type_pb2.StorageType,
+    ]
+    """Returns the specified storage types."""
+
+    List: grpc.aio.UnaryUnaryMultiCallable[
+        yandex.cloud.ydb.v1.storage_type_service_pb2.ListStorageTypesRequest,
+        yandex.cloud.ydb.v1.storage_type_service_pb2.ListStorageTypesResponse,
+    ]
+    """Returns the list of available storage types."""
+
+class StorageTypeServiceServicer(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def Get(
+        self,
+        request: yandex.cloud.ydb.v1.storage_type_service_pb2.GetStorageTypeRequest,
+        context: _ServicerContext,
+    ) -> typing.Union[yandex.cloud.ydb.v1.storage_type_pb2.StorageType, collections.abc.Awaitable[yandex.cloud.ydb.v1.storage_type_pb2.StorageType]]:
+        """Returns the specified storage types."""
+
+    @abc.abstractmethod
+    def List(
+        self,
+        request: yandex.cloud.ydb.v1.storage_type_service_pb2.ListStorageTypesRequest,
+        context: _ServicerContext,
+    ) -> typing.Union[yandex.cloud.ydb.v1.storage_type_service_pb2.ListStorageTypesResponse, collections.abc.Awaitable[yandex.cloud.ydb.v1.storage_type_service_pb2.ListStorageTypesResponse]]:
+        """Returns the list of available storage types."""
+
+def add_StorageTypeServiceServicer_to_server(servicer: StorageTypeServiceServicer, server: typing.Union[grpc.Server, grpc.aio.Server]) -> None: ...

yandexcloud/_auth_fabric.py

@@ -1,6 +1,7 @@
 import os
 import time
 from datetime import datetime
+from typing import Dict, Optional, Union
 
 # noinspection PyUnresolvedReferences
 # jwt package depends on cryptography
@@ -26,9 +27,9 @@ def set_up_yc_api_endpoint(endpoint: str) -> str:
     return YC_API_ENDPOINT
 
 
-def __validate_service_account_key(sa_key):
+def __validate_service_account_key(sa_key: Optional[dict]) -> bool:
     if not isinstance(sa_key, dict):
-        raise RuntimeError("Invalid Service Account Key: expecting dictionary, actually got {}".format(type(sa_key)))
+        raise RuntimeError(f"Invalid Service Account Key: expecting dictionary, actually got {type(sa_key)}")
 
     obj_id = sa_key.get("id")
     sa_id = sa_key.get("service_account_id")
@@ -47,46 +48,21 @@ def __validate_service_account_key(sa_key):
     if not isinstance(private_key, six.string_types) or private_key_prefix not in private_key:
         error_message = (
             "Invalid Service Account Key: private key is in incorrect format."
-            + "Should start with {prefix}.\n".format(prefix=private_key_prefix)
-            + "To obtain one you can use YC CLI: yc iam key create --output sa.json --service-account-id <id>"
+            f"Should start with {private_key_prefix}.\n"
+            "To obtain one you can use YC CLI: yc iam key create --output sa.json --service-account-id <id>"
         )
         raise RuntimeError(error_message)
-
-
-def get_auth_token_requester(token=None, service_account_key=None, iam_token=None, metadata_addr=None, endpoint=None):
-    if endpoint is None:
-        endpoint = YC_API_ENDPOINT
-    auth_methods = [("token", token), ("service_account_key", service_account_key), ("iam_token", iam_token)]
-    auth_methods = [(auth_type, value) for auth_type, value in auth_methods if value is not None]
-
-    if len(auth_methods) == 0:
-        return MetadataAuth(metadata_addr=metadata_addr or os.environ.get("YC_METADATA_ADDR", _MDS_ADDR))
-
-    if len(auth_methods) > 1:
-        raise RuntimeError(
-            "Conflicting API credentials properties are set: {}.".format([auth[0] for auth in auth_methods])
-        )
-
-    auth_name, _ = auth_methods[0]
-    if auth_name == "token":
-        return TokenAuth(token=token)
-    if auth_name == "service_account_key":
-        __validate_service_account_key(service_account_key)
-        return ServiceAccountAuth(service_account_key, endpoint)
-    if auth_name == "iam_token":
-        return IamTokenAuth(iam_token)
-
-    raise RuntimeError("Unknown auth method: {}".format(auth_name))
+    return True
 
 
 class MetadataAuth:
-    def __init__(self, metadata_addr):
+    def __init__(self, metadata_addr: str):
         self.__metadata_addr = metadata_addr
 
-    def url(self):
+    def url(self) -> str:
         return _MDS_URL.format(self.__metadata_addr)
 
-    def get_token(self):
+    def get_token(self) -> str:
         r = requests.get(self.url(), headers=_MDS_HEADERS, timeout=_MDS_TIMEOUT)
         r.raise_for_status()
         response = r.json()
@@ -94,28 +70,28 @@ class MetadataAuth:
 
 
 class TokenAuth:
-    def __init__(self, token):
+    def __init__(self, token: str):
         self.__oauth_token = token
 
-    def get_token_request(self):
+    def get_token_request(self) -> "CreateIamTokenRequest":
         return CreateIamTokenRequest(yandex_passport_oauth_token=self.__oauth_token)
 
 
 class ServiceAccountAuth:
     __SECONDS_IN_HOUR = 60.0 * 60.0
 
-    def __init__(self, sa_key, endpoint=None):
+    def __init__(self, sa_key: Dict[str, str], endpoint: Optional[str] = None):
         self.__sa_key = sa_key
         self._endpoint = endpoint if endpoint is not None else YC_API_ENDPOINT
 
-    def get_token_request(self):
+    def get_token_request(self) -> "CreateIamTokenRequest":
         return CreateIamTokenRequest(jwt=self.__prepare_request(self._endpoint))
 
-    def __prepare_request(self, endpoint):
+    def __prepare_request(self, endpoint: str) -> str:
         now = time.time()
         now_utc = datetime.utcfromtimestamp(now)
         exp_utc = datetime.utcfromtimestamp(now + self.__SECONDS_IN_HOUR)
-        url = "https://iam.{}/iam/v1/tokens".format(endpoint)
+        url = f"https://iam.{endpoint}/iam/v1/tokens"
         payload = {
             "iss": self.__sa_key["service_account_id"],
             "aud": url,
@@ -133,8 +109,37 @@ class ServiceAccountAuth:
 
 
 class IamTokenAuth:
-    def __init__(self, iam_token):
+    def __init__(self, iam_token: str):
         self.__iam_token = iam_token
 
-    def get_token(self):
+    def get_token(self) -> str:
         return self.__iam_token
+
+
+def get_auth_token_requester(
+    token: Optional[str] = None,
+    service_account_key: Optional[dict] = None,
+    iam_token: Optional[str] = None,
+    metadata_addr: Optional[str] = None,
+    endpoint: Optional[str] = None,
+) -> Union["MetadataAuth", "TokenAuth", "IamTokenAuth", "ServiceAccountAuth"]:
+    if endpoint is None:
+        endpoint = YC_API_ENDPOINT
+    auth_methods = [("token", token), ("service_account_key", service_account_key), ("iam_token", iam_token)]
+    auth_methods = [(auth_type, value) for auth_type, value in auth_methods if value is not None]
+
+    if len(auth_methods) == 0:
+        metadata_addr = metadata_addr if metadata_addr is not None else os.environ.get("YC_METADATA_ADDR", _MDS_ADDR)
+        return MetadataAuth(metadata_addr)
+
+    if len(auth_methods) > 1:
+        raise RuntimeError(f"Conflicting API credentials properties are set: {[auth[0] for auth in auth_methods]}.")
+
+    if token is not None:
+        return TokenAuth(token=token)
+    if iam_token is not None:
+        return IamTokenAuth(iam_token)
+    if service_account_key is not None and __validate_service_account_key(service_account_key):
+        return ServiceAccountAuth(service_account_key, endpoint)
+
+    raise RuntimeError("Unknown auth method")

yandexcloud/_auth_plugin.py

@@ -1,41 +1,57 @@
 from datetime import datetime
+from typing import TYPE_CHECKING, Callable, Optional, Tuple, Union
 
 import grpc
 from six.moves.urllib.parse import urlparse
 
 from yandex.cloud.iam.v1.iam_token_service_pb2_grpc import IamTokenServiceStub
 
+if TYPE_CHECKING:
+    from yandex.cloud.iam.v1.iam_token_service_pb2 import CreateIamTokenResponse
+    from yandexcloud._auth_fabric import (
+        IamTokenAuth,
+        MetadataAuth,
+        ServiceAccountAuth,
+        TokenAuth,
+    )
+
+
 TIMEOUT_SECONDS = 20
 
 
 class Credentials(grpc.AuthMetadataPlugin):
-    def __init__(self, token_requester, lazy_channel):
+    def __init__(
+        self,
+        token_requester: Union["MetadataAuth", "TokenAuth", "IamTokenAuth", "ServiceAccountAuth"],
+        lazy_channel: Callable[[], "grpc.Channel"],
+    ):
         # pylint: disable=super-init-not-called
         self.__token_requester = token_requester
         self._lazy_channel = lazy_channel
-        self._channel = None
-        self._cached_iam_token = None
-        self._iam_token_timestamp = None
+        self._channel: Optional[grpc.Channel] = None
+        self._cached_iam_token: str = ""
+        self._iam_token_timestamp: Optional[datetime] = None
 
-    def __call__(self, context, callback):
+    def __call__(self, context: "grpc.AuthMetadataContext", callback: "grpc.AuthMetadataPluginCallback") -> None:
         try:
             return self._call(context, callback)
         except Exception as exception:  # pylint: disable=broad-except
-            callback(None, exception)
+            callback(tuple(), exception)
+        return None
 
-    def _call(self, context, callback):
+    def _call(self, context: "grpc.AuthMetadataContext", callback: "grpc.AuthMetadataPluginCallback") -> None:
         u = urlparse(context.service_url)
         if u.path in (
             "/yandex.cloud.iam.v1.IamTokenService",
             "/yandex.cloud.endpoint.ApiEndpointService",
         ):
-            callback(None, None)
+            callback(tuple(), None)
             return
 
-        if not self._channel:
+        if self._channel is None:
             self._channel = self._lazy_channel()
 
-        if self._cached_iam_token is None or not self._fresh():
+        if not self._fresh():
             get_token = getattr(self.__token_requester, "get_token", None)
             if callable(get_token):
                 self._cached_iam_token = get_token()
@@ -51,28 +67,30 @@ class Credentials(grpc.AuthMetadataPlugin):
 
         callback(self._metadata(), None)
 
-    def create_done_callback(self, callback):
-        def done_callback(future):
+    def create_done_callback(self, callback: "grpc.AuthMetadataPluginCallback") -> Callable[["grpc.Future"], None]:
+        def done_callback(future: "grpc.Future") -> None:
             try:
                 resp = future.result()
             except Exception as exception:  # pylint: disable=broad-except
-                callback(None, exception)
+                callback(tuple(), exception)
             else:
                 self._save_token(resp)
                 callback(self._metadata(), None)
 
         return done_callback
 
-    def _metadata(self):
-        metadata = (("authorization", "Bearer " + self._cached_iam_token),)
+    def _metadata(self) -> Tuple[Tuple[str, str]]:
+        metadata = (("authorization", f"Bearer {self._cached_iam_token}"),)
         return metadata
 
-    def _save_token(self, resp):
+    def _save_token(self, resp: "CreateIamTokenResponse") -> None:
         self._cached_iam_token = resp.iam_token
         self._iam_token_timestamp = datetime.now()
 
-    def _fresh(self):
-        if self._cached_iam_token is None:
+    def _fresh(self) -> bool:
+        if self._cached_iam_token == "":
+            return False
+        if self._iam_token_timestamp is None:
             return False
         diff = datetime.now() - self._iam_token_timestamp
         return diff.total_seconds() < TIMEOUT_SECONDS

yandexcloud/_backoff.py

@@ -1,16 +1,17 @@
 import random
+from typing import Callable
 
 
-def backoff_linear_with_jitter(wait_time, jitter):
-    def func(attempt):  # pylint: disable=unused-argument
+def backoff_linear_with_jitter(wait_time: float, jitter: float) -> Callable[[int], float]:
+    def func(attempt: int) -> float:  # pylint: disable=unused-argument
         multiplier = jitter * (random.random() * 2 - 1)
         return wait_time * (1 + multiplier)
 
     return func
 
 
-def backoff_exponential_with_jitter(base, cap):
-    def func(attempt):
+def backoff_exponential_with_jitter(base: float, cap: float) -> Callable[[int], float]:
+    def func(attempt: int) -> float:  # pylint: disable=unused-argument
         try:
             res = (2**attempt) * base * random.random()
         except OverflowError:
@@ -24,8 +25,8 @@ def backoff_exponential_with_jitter(base, cap):
     return func
 
 
-def backoff_exponential_jittered_min_interval(base=0.05, cap=60):
-    def func(attempt):
+def backoff_exponential_jittered_min_interval(base: float = 0.05, cap: float = 60) -> Callable[[int], float]:
+    def func(attempt: int) -> float:  # pylint: disable=unused-argument
         try:
             base_interval = (2**attempt) * base
             res = base_interval / 2 + base_interval * random.random()
@@ -40,5 +41,5 @@ def backoff_exponential_jittered_min_interval(base=0.05, cap=60):
     return func
 
 
-def default_backoff():
+def default_backoff() -> Callable[[int], float]:
     return backoff_exponential_with_jitter(0.05, 60)

yandexcloud/_channels.py

@@ -14,28 +14,40 @@ try:
 except PackageNotFoundError:
     VERSION = "0.0.0"
 
-SDK_USER_AGENT = "yandex-cloud-python-sdk/{version}".format(version=VERSION)
+SDK_USER_AGENT = f"yandex-cloud-python-sdk/{VERSION}"
 logger = logging.getLogger(__name__)
 
 
 class Channels:
-    def __init__(self, client_user_agent=None, endpoints: Optional[Dict[str, str]] = None, **kwargs):
+    def __init__(
+        self,
+        client_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,
+        **_: str,
+    ) -> None:
         self._channel_creds = grpc.ssl_channel_credentials(
-            root_certificates=kwargs.get("root_certificates"),
-            private_key=kwargs.get("private_key"),
-            certificate_chain=kwargs.get("certificate_chain"),
+            root_certificates=root_certificates,
+            private_key=private_key,
+            certificate_chain=certificate_chain,
         )
-        self._endpoint = kwargs.get("endpoint", YC_API_ENDPOINT)
+        self._endpoint = endpoint if endpoint is not None else YC_API_ENDPOINT
         self._token_requester = get_auth_token_requester(
-            token=kwargs.get("token"),
-            service_account_key=kwargs.get("service_account_key"),
-            iam_token=kwargs.get("iam_token"),
+            token=token,
+            service_account_key=service_account_key,
+            iam_token=iam_token,
             endpoint=self._endpoint,
         )
 
         self._client_user_agent = client_user_agent
         self._config_endpoints = endpoints if endpoints is not None else {}
-        self._endpoints = None
+        self._endpoints: Optional[Dict[str, str]] = None
         self.channel_options = tuple(
             ("grpc.primary_user_agent", user_agent)
             for user_agent in [self._client_user_agent, SDK_USER_AGENT]
@@ -49,7 +61,7 @@ class Channels:
                 logger.info("Insecure option is ON, no IAM endpoint used for verification")
                 return grpc.insecure_channel(endpoint, options=self.channel_options)
             logger.info("Insecure option is OFF,IAM endpoint %s used for verification")
-            creds = self._get_creds(self.endpoints["iam"])
+            creds: grpc.ChannelCredentials = self._get_creds(self.endpoints["iam"])
             return grpc.secure_channel(endpoint, creds, options=self.channel_options)
         if service not in self._config_endpoints and insecure:
             logger.warning(
@@ -74,7 +86,7 @@ class Channels:
         return grpc.secure_channel(self.endpoints[service], creds, options=self.channel_options)
 
     @property
-    def endpoints(self) -> Optional[dict]:
+    def endpoints(self) -> Dict[str, str]:
         if self._endpoints is None:
             self._endpoints = self._get_endpoints()
             for id_, address in self._config_endpoints.items():
@@ -94,7 +106,9 @@ class Channels:
         return {endpoint.id: endpoint.address for endpoint in resp.endpoints}
 
     def _get_creds(self, iam_endpoint: str) -> grpc.ChannelCredentials:
-        plugin = _auth_plugin.Credentials(self._token_requester, lambda: iam_endpoint)
+        plugin = _auth_plugin.Credentials(
+            self._token_requester, lambda: grpc.secure_channel(iam_endpoint, creds, options=self.channel_options)
+        )
         call_creds = grpc.metadata_call_credentials(plugin)
         creds = grpc.composite_channel_credentials(self._channel_creds, call_creds)
         return creds

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")