http-misc 0.0.2__tar.gz → 1.0.1__tar.gz

{http_misc-0.0.2 → http_misc-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: http-misc
-Version: 0.0.2
+Version: 1.0.1
 Summary: Утилитарный пакет межсервисного взаимодействия по протоколу HTTP
 Author: Anton Gorinenko
 Author-email: anton.gorinenko@gmail.com
@@ -18,6 +18,8 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: python-dotenv; extra == "test"
 Requires-Dist: envparse; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-env; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{http_misc-0.0.2 → http_misc-1.0.1}/http_misc/http_utils.py

@@ -2,8 +2,9 @@ import datetime
 import decimal
 import json
 import uuid
+from typing import Optional
 
-from http_misc import services, errors
+from http_misc import services, errors, retry_policy
 
 
 def default_encoder(obj):
@@ -31,9 +32,14 @@ def join_str(*args, sep: str | None = '/', append_last_sep: bool | None = False)
     return url
 
 
-async def send_and_validate(service: 'services.BaseService', request, expected_status: int | None = 200):
+async def send_and_validate(service: 'services.BaseService', request, expected_status: int | None = 200,
+                            policy: Optional['retry_policy.AsyncRetryPolicy'] = None):
     """ Вызов внешнего сервиса и проверка его статуса"""
-    response = await service.send_request(**request)
+    if policy:
+        response = await policy.apply(service.send_request, **request)
+    else:
+        response = await service.send_request(**request)
+
     if response.status != expected_status:
         raise errors.InteractionError('Произошла ошибка при вызове внешнего сервиса',
                                       status_code=response.status, response=response.response_data)

http_misc-1.0.1/http_misc/logger.py

@@ -0,0 +1,11 @@
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    """ Получить logger """
+    if name:
+        return _logger.getChild(name)
+
+    return _logger

http_misc-1.0.1/http_misc/retry_policy.py

@@ -0,0 +1,120 @@
+import asyncio
+import random
+import uuid
+from abc import ABC
+from collections.abc import Callable
+from time import sleep
+
+from http_misc.errors import RetryError, MaxRetryError
+from http_misc.logger import get_logger
+
+logger = get_logger('retry_policy')
+
+
+class BaseRetryPolicy(ABC):
+    """
+    Базовая политика действий
+    """
+
+    def __init__(self, max_retry: int | None = 9, backoff_factor: float | None = 0.3, jitter: float | None = 0.1):
+        """ Базовая политика действий
+        :param max_retry: максимальное количество повторений(без учета основного вызова)
+        :param backoff_factor: коэффициент задержки попыток повторных вызовов
+        :param jitter: коэффициент "дрожания" повторных вызовов
+        """
+        self.max_retry = max_retry
+        self.backoff_factor = backoff_factor
+        self.jitter = jitter
+
+        self.request_count_manager = RequestCountManager()
+
+    def _on_retry_error(self, current_step: int, request_id: uuid.UUID) -> float:
+        if current_step >= self.max_retry:
+            raise MaxRetryError(f'Exceeded the maximum number of attempts {self.max_retry}.')
+
+        sleep_seconds = self.backoff_factor * (2 ** (current_step - 1))
+        sleep_seconds += random.normalvariate(0, sleep_seconds * self.jitter)
+        self.request_count_manager.inc(request_id)
+        return sleep_seconds
+
+
+class AsyncRetryPolicy(BaseRetryPolicy):
+    """
+    Политика повторов асинхронных действий
+    """
+
+    async def apply(self, action: Callable, *args, **kwargs):
+        """ Выполнение асинхронного действия """
+        request_id = self.request_count_manager.add()
+        try:
+            while True:
+                current_step = self.request_count_manager.get(request_id)
+                if current_step > 0:
+                    logger.debug('Step %s. Repeat action #%s.', request_id)
+                try:
+                    return await action(*args, **kwargs)
+                except RetryError:
+                    sleep_seconds = self._on_retry_error(current_step, request_id)
+                    await asyncio.sleep(sleep_seconds)
+        finally:
+            self.request_count_manager.pop(request_id)
+
+
+class RetryPolicy(BaseRetryPolicy):
+    """
+    Политика повторов синхронных действий
+    """
+
+    def apply(self, action: Callable, *args, **kwargs):
+        """ Выполнение синхронного действия """
+        request_id = self.request_count_manager.add()
+        try:
+            while True:
+                current_step = self.request_count_manager.get(request_id)
+                if current_step > 0:
+                    logger.debug('Step %s. Repeat action #%s.', request_id)
+                try:
+                    return action(*args, **kwargs)
+                except RetryError:
+                    sleep_seconds = self._on_retry_error(current_step, request_id)
+                    sleep(sleep_seconds)
+        finally:
+            self.request_count_manager.pop(request_id)
+
+
+class RequestCountManager:
+    def __init__(self):
+        self._requests: dict[uuid.UUID, int] = {}
+
+    def get_requests(self):
+        return self._requests
+
+    def add(self) -> uuid.UUID:
+        """ Инициализация запроса """
+        request_id = uuid.uuid4()
+        self._requests[request_id] = 0
+        return request_id
+
+    def exist(self, request_id: uuid.UUID) -> bool:
+        """ Проверка наличия запроса """
+        if request_id not in self._requests:
+            raise KeyError(f'Request {request_id} not in registry.')
+
+        return True
+
+    def pop(self, request_id: uuid.UUID) -> int | None:
+        """ Удаление запроса """
+        self.exist(request_id)
+        return self._requests.pop(request_id)
+
+    def get(self, request_id: uuid.UUID) -> int:
+        """ Получение количества попыток запроса """
+        self.exist(request_id)
+        return self._requests[request_id]
+
+    def inc(self, request_id: uuid.UUID) -> int:
+        """ Увеличение количества попыток на 1 """
+        self.exist(request_id)
+        self._requests[request_id] += 1
+
+        return self._requests[request_id]

http_misc-1.0.1/http_misc/services.py

@@ -0,0 +1,134 @@
+import uuid
+from abc import ABC, abstractmethod
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+
+from aiohttp import ContentTypeError, ClientSession
+
+from http_misc import http_utils, errors
+from http_misc.logger import get_logger
+
+DEFAULT_RETRY_ON_STATUSES = frozenset([413, 429, 503, 504])
+logger = get_logger('services')
+
+
+@dataclass
+class ServiceResponse:
+    """ Ответ сервиса """
+    status: int
+    response_data: any = None
+    raw_response: any = None
+
+
+class Transformer(ABC):
+    @abstractmethod
+    async def modify(self, *args, **kwargs):
+        """ Изменение параметров запроса или ответа """
+        return args, kwargs
+
+
+class BaseService(ABC):
+    """
+    Abstract service
+    """
+
+    def __init__(self, retry_on_statuses: set[int] | None = DEFAULT_RETRY_ON_STATUSES,
+                 request_preproc: list[Transformer] | None = None,
+                 response_preproc: list[Transformer] | None = None):
+        """ Сервис """
+        self.retry_on_statuses = retry_on_statuses
+        self.request_preproc = request_preproc
+        self.response_preproc = response_preproc
+
+    @abstractmethod
+    async def _send(self, *args, **kwargs) -> ServiceResponse:
+        """
+        Abstract _send
+        """
+        raise NotImplementedError('Not implemented _send method')
+
+    async def send_request(self, *args, **kwargs) -> ServiceResponse:
+        """
+        Вызов внешнего сервиса
+        """
+        try:
+            args, kwargs = await self._before_send(*args, **kwargs)
+            logger.debug('Send request %s; %s', args, kwargs)
+            service_response = await self._send(*args, **kwargs)
+            service_response = await self._transform_response(service_response)
+            logger.debug('Response: %s, %s', service_response.status, service_response.response_data)
+
+            if self.retry_on_statuses and service_response.status in self.retry_on_statuses:
+                raise errors.RetryError()
+
+            return service_response
+        except Exception as ex:
+            if isinstance(ex, errors.RetryError):
+                raise ex
+            else:
+                return await self._on_error(ex, *args, **kwargs)
+
+    async def _transform_response(self, response: ServiceResponse) -> ServiceResponse:
+        """ Преобразование ответа для возврата пользователю """
+        if self.response_preproc:
+            for response_preproc in self.response_preproc:
+                response = await response_preproc.modify(response)
+        return response
+
+    async def _before_send(self, *args, **kwargs):
+        """ Действие перед вызовом """
+        if self.request_preproc:
+            for request_preproc in self.request_preproc:
+                args, kwargs = await request_preproc.modify(*args, **kwargs)
+        return args, kwargs
+
+    async def _on_error(self, ex: Exception, *args, **kwargs) -> ServiceResponse:
+        """
+        Действие на возникновение ошибки.
+        """
+        logger.exception(ex)
+        raise ex
+
+
+class HttpService(BaseService):
+    """
+    Вызов сервиса по протоколу http
+    """
+
+    def __init__(self, *args, client_session: ClientSession | None = None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.client_session = client_session
+
+    async def _send(self, request_id: uuid.UUID, *args, **kwargs) -> ServiceResponse:
+        method = kwargs.get('method', 'get')
+        url = kwargs.get('url', None)
+        if url is None:
+            raise ValueError('Url is none')
+        url = str(url)
+
+        cfg = kwargs.get('cfg', {})
+        if not isinstance(cfg, dict):
+            raise ValueError('Invalid cfg type. Must be dict.')
+
+        if url.lower().startswith('https://') and 'ssl' not in cfg:
+            cfg['ssl'] = False
+
+        async with self._use_client_session() as session:
+            async with session.request(method, url, **cfg) as response:
+                response_data = await _get_response_content(response)
+                return ServiceResponse(status=response.status, response_data=response_data, raw_response=response)
+
+    @asynccontextmanager
+    async def _use_client_session(self):
+        if self.client_session is not None:
+            yield self.client_session
+        else:
+            async with ClientSession(json_serialize=http_utils.json_dumps) as session:
+                yield session
+
+
+async def _get_response_content(response):
+    try:
+        return await response.json()
+    except ContentTypeError:
+        return await response.text()

{http_misc-0.0.2 → http_misc-1.0.1}/http_misc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: http-misc
-Version: 0.0.2
+Version: 1.0.1
 Summary: Утилитарный пакет межсервисного взаимодействия по протоколу HTTP
 Author: Anton Gorinenko
 Author-email: anton.gorinenko@gmail.com
@@ -18,6 +18,8 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: python-dotenv; extra == "test"
 Requires-Dist: envparse; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-env; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{http_misc-0.0.2 → http_misc-1.0.1}/http_misc.egg-info/SOURCES.txt

@@ -3,9 +3,13 @@ setup.py
 http_misc/__init__.py
 http_misc/errors.py
 http_misc/http_utils.py
+http_misc/logger.py
+http_misc/retry_policy.py
 http_misc/services.py
 http_misc.egg-info/PKG-INFO
 http_misc.egg-info/SOURCES.txt
 http_misc.egg-info/dependency_links.txt
 http_misc.egg-info/requires.txt
-http_misc.egg-info/top_level.txt
+http_misc.egg-info/top_level.txt
+tests/test_retry_policy.py
+tests/test_services.py

{http_misc-0.0.2 → http_misc-1.0.1}/http_misc.egg-info/requires.txt

@@ -5,3 +5,5 @@ pytest
 python-dotenv
 envparse
 pytest-asyncio
+pytest-mock
+pytest-env

{http_misc-0.0.2 → http_misc-1.0.1}/setup.py

@@ -4,7 +4,7 @@ import setuptools
 
 setuptools.setup(
     name='http-misc',
-    version='0.0.2',
+    version='1.0.1',
     author='Anton Gorinenko',
     author_email='anton.gorinenko@gmail.com',
     description='Утилитарный пакет межсервисного взаимодействия по протоколу HTTP',
@@ -28,7 +28,9 @@ setuptools.setup(
             'pytest',
             'python-dotenv',
             'envparse',
-            'pytest-asyncio'
+            'pytest-asyncio',
+            'pytest-mock',
+            'pytest-env'
         ]
     },
     python_requires='>=3.10',

http_misc-1.0.1/tests/test_retry_policy.py

@@ -0,0 +1,66 @@
+from unittest.mock import MagicMock, AsyncMock
+
+import pytest
+
+from http_misc.errors import RetryError, MaxRetryError
+from http_misc.retry_policy import RetryPolicy, AsyncRetryPolicy
+
+
+@pytest.mark.parametrize('clazz', [RetryPolicy, AsyncRetryPolicy])
+async def test_async_apply(clazz):
+    """ Выполнение асинхронного действия. Успех """
+    policy = clazz()
+    is_async_policy = isinstance(policy, AsyncRetryPolicy)
+
+    some_action = AsyncMock() if is_async_policy else MagicMock()
+    some_action.return_value = '123'
+
+    if is_async_policy:
+        result = await policy.apply(some_action)
+    else:
+        result = policy.apply(some_action)
+
+    requests = policy.request_count_manager.get_requests()
+    assert result == '123'
+    assert some_action.call_count == 1
+    assert len(requests.keys()) == 0
+
+
+@pytest.mark.parametrize('clazz', [RetryPolicy, AsyncRetryPolicy])
+async def test_async_apply__retry_error(clazz):
+    """ Выполнение асинхронного действия. RetryError """
+    max_retry = 5
+    policy = clazz(max_retry=max_retry, backoff_factor=0.001, jitter=0.001)
+    is_async_policy = isinstance(policy, AsyncRetryPolicy)
+
+    some_action = AsyncMock() if is_async_policy else MagicMock()
+    some_action.side_effect = RetryError()
+
+    with pytest.raises(MaxRetryError, match=f'Exceeded the maximum number of attempts {max_retry}.'):
+        if is_async_policy:
+            await policy.apply(some_action)
+        else:
+            policy.apply(some_action)
+
+    requests = policy.request_count_manager.get_requests()
+    assert some_action.call_count == max_retry + 1
+    assert len(requests.keys()) == 0
+
+
+@pytest.mark.parametrize('clazz', [RetryPolicy, AsyncRetryPolicy])
+async def test_async_apply__error(clazz):
+    """ Выполнение асинхронного действия. Exception """
+    policy = clazz()
+    is_async_policy = isinstance(policy, AsyncRetryPolicy)
+
+    some_action = AsyncMock() if is_async_policy else MagicMock()
+    some_action.side_effect = Exception('Test')
+    with pytest.raises(Exception, match=f'Test'):
+        if is_async_policy:
+            await policy.apply(some_action)
+        else:
+            policy.apply(some_action)
+
+    requests = policy.request_count_manager.get_requests()
+    assert some_action.call_count == 1
+    assert len(requests.keys()) == 0

http_misc-1.0.1/tests/test_services.py

@@ -0,0 +1,118 @@
+from unittest.mock import call
+
+import pytest
+from http_misc import http_utils
+
+from http_misc.errors import RetryError, MaxRetryError
+from http_misc.retry_policy import AsyncRetryPolicy
+from http_misc.services import HttpService, ServiceResponse
+
+
+async def test_http_service(mocker):
+    response_data = {
+        'meta': {
+            'count': 5
+        },
+        'list': [
+            1, 2, 3, 4, 5
+        ]
+    }
+    send_mocker = mocker.patch('http_misc.services.HttpService._send')
+    send_mocker.return_value = ServiceResponse(status=200, response_data=response_data, raw_response=None)
+
+    policy = AsyncRetryPolicy()
+    service = HttpService()
+    request = {
+        'method': 'GET',
+        'url': 'https://localhost:8000',
+        'cfg': {
+            'params': {
+                'q1': 1,
+                'q2': '2'
+            }
+        }
+    }
+    result = await policy.apply(service.send_request, **request)
+    assert result.status == 200
+    assert result.response_data == response_data
+
+    assert send_mocker.call_args_list == [
+        call(method='GET', url='https://localhost:8000', cfg={'params': {'q1': 1, 'q2': '2'}})
+    ]
+
+
+async def test_http_service__500(mocker):
+    response_data = {
+        'error': 'Error1'
+    }
+    send_mocker = mocker.patch('http_misc.services.HttpService._send')
+    send_mocker.return_value = ServiceResponse(status=500, response_data=response_data, raw_response=None)
+
+    policy = AsyncRetryPolicy()
+    service = HttpService()
+    request = {
+        'method': 'GET',
+        'url': 'https://localhost:8000',
+        'cfg': {
+            'params': {
+                'q1': 1,
+                'q2': '2'
+            }
+        }
+    }
+    result = await http_utils.send_and_validate(service, request, expected_status=500, policy=policy)
+    assert result == response_data
+
+    assert send_mocker.call_args_list == [
+        call(method='GET', url='https://localhost:8000', cfg={'params': {'q1': 1, 'q2': '2'}})
+    ]
+
+
+async def test_http_service__retry_error(mocker):
+    send_mocker = mocker.patch('http_misc.services.HttpService._send')
+    send_mocker.side_effect = RetryError()
+
+    max_retry = 5
+    policy = AsyncRetryPolicy(max_retry=max_retry, backoff_factor=0.001, jitter=0.001)
+    service = HttpService()
+    request = {
+        'method': 'GET',
+        'url': 'https://localhost:8000',
+        'cfg': {
+            'params': {
+                'q1': 1,
+                'q2': '2'
+            }
+        }
+    }
+    with pytest.raises(MaxRetryError, match=f'Exceeded the maximum number of attempts {max_retry}.'):
+        await policy.apply(service.send_request, **request)
+
+    assert send_mocker.call_args_list == [
+        call(method='GET', url='https://localhost:8000', cfg={'params': {'q1': 1, 'q2': '2'}})
+    ] * (max_retry + 1)
+
+
+async def test_http_service__error(mocker):
+    send_mocker = mocker.patch('http_misc.services.HttpService._send')
+    send_mocker.side_effect = Exception('Test')
+
+    max_retry = 5
+    policy = AsyncRetryPolicy(max_retry=max_retry, backoff_factor=0.001, jitter=0.001)
+    service = HttpService()
+    request = {
+        'method': 'GET',
+        'url': 'https://localhost:8000',
+        'cfg': {
+            'params': {
+                'q1': 1,
+                'q2': '2'
+            }
+        }
+    }
+    with pytest.raises(Exception, match=f'Test'):
+        await policy.apply(service.send_request, **request)
+
+    assert send_mocker.call_args_list == [
+        call(method='GET', url='https://localhost:8000', cfg={'params': {'q1': 1, 'q2': '2'}})
+    ]

http_misc-0.0.2/http_misc/services.py

@@ -1,237 +0,0 @@
-import asyncio
-import logging
-import random
-import uuid
-from abc import ABC, abstractmethod
-from contextlib import asynccontextmanager
-from dataclasses import dataclass
-from enum import Enum
-
-from aiohttp import ContentTypeError, ClientSession
-
-from http_misc import http_utils, errors
-
-DEFAULT_RETRY_ON_STATUSES = frozenset([413, 429, 503, 504])
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class ServiceResponse:
-    """ Ответ сервиса """
-    status: int
-    response_data: any = None
-    raw_response: any = None
-
-
-class OnErrorResult(Enum):
-    """
-    SILENT - проигнорировать ошибку
-    THROW - возбудить ошибку
-    REFRESH - при ошибке выполнить действие повторно
-    """
-    SILENT = 1
-    THROW = 2
-    REFRESH = 3
-
-
-@dataclass
-class RetryPolicy:
-    max_retry: int | None = 10
-    retry_on_statuses: set[int] | None = DEFAULT_RETRY_ON_STATUSES
-    backoff_factor: int | None = 0.3
-    jitter: int | None = 0.1
-
-
-class Transformer(ABC):
-    @abstractmethod
-    async def modify(self, request_id, *args, **kwargs):
-        """ Изменение параметров запроса или ответа """
-        return args, kwargs
-
-
-class BaseService(ABC):
-    """
-    Abstract service
-    """
-
-    def __init__(self, retry_policy: RetryPolicy | None = None,
-                 request_preproc: list[Transformer] | None = None,
-                 response_preproc: list[Transformer] | None = None):
-        """ Сервис """
-        self.retry_policy = retry_policy or RetryPolicy()
-        self.request_preproc = request_preproc
-        self.response_preproc = response_preproc
-        self._request_count_manager = _RequestCountManager()
-
-    @abstractmethod
-    async def _send(self, request_id: uuid.UUID, *args, **kwargs) -> ServiceResponse:
-        """
-        Abstract _send
-        """
-        raise NotImplementedError('Not implemented _send method')
-
-    async def send_request(self, *args, **kwargs):
-        """  Вызов внешнего сервиса """
-        request_id = self._request_count_manager.add()
-        try:
-            return await self._send_request(request_id, *args, **kwargs)
-        finally:
-            # обнуляем current_step для запроса, он выполнен успешно
-            self._request_count_manager.pop(request_id)
-
-    def get_current_step(self, request_id: uuid.UUID):
-        """ Получение количества попыток запроса """
-        return self._request_count_manager.get(request_id)
-
-    async def _send_request(self, request_id: uuid.UUID, *args, **kwargs) -> ServiceResponse:
-        """
-        Вызов внешнего сервиса
-        """
-        try:
-            args, kwargs = await self._before_send(request_id, *args, **kwargs)
-            logger.debug('Send request %s: %s; %s', self.get_current_step(request_id), args, kwargs)
-            service_response = await self._send(request_id, *args, **kwargs)
-            service_response = await self._transform_response(request_id, service_response)
-            logger.debug('Response %s: %s, %s', self.get_current_step(request_id),
-                         service_response.status, service_response.response_data)
-
-            if self.retry_policy.retry_on_statuses and service_response.status in self.retry_policy.retry_on_statuses:
-                raise errors.RetryError()
-
-            return service_response
-        except Exception as ex:
-            if isinstance(ex, errors.RetryError):
-                on_error_result = OnErrorResult.REFRESH
-            else:
-                on_error_result = await self._on_error(ex, *args, **kwargs)
-
-            if on_error_result == OnErrorResult.THROW:
-                logger.exception(ex)
-                raise ex
-
-            if on_error_result == OnErrorResult.SILENT:
-                logger.exception(ex)
-                return ServiceResponse(status=-1)
-
-            if on_error_result == OnErrorResult.REFRESH:
-                return await self._resend_request(request_id, ex, *args, **kwargs)
-
-            raise NotImplementedError(f'on_error_result "{on_error_result}" not implemented') from ex
-
-    async def _transform_response(self, request_id: uuid.UUID, response: ServiceResponse) -> ServiceResponse:
-        """ Преобразование ответа для возврата пользователю """
-        if self.response_preproc:
-            for response_preproc in self.response_preproc:
-                response = await response_preproc.modify(request_id, response)
-        return response
-
-    async def _before_send(self, request_id: uuid.UUID, *args, **kwargs):
-        """ Действие перед вызовом """
-        if self.request_preproc:
-            for request_preproc in self.request_preproc:
-                args, kwargs = await request_preproc.modify(request_id, *args, **kwargs)
-        return args, kwargs
-
-    async def _on_error(self, ex: Exception, *args, **kwargs) -> OnErrorResult:  # pylint: disable=unused-argument
-        """
-        Действие на возникновение ошибки.
-        SILENT - продолжить работу без возникновения ошибки
-        THROW - выкинуть исключение дальше
-        REFRESH - сделать повторный вызов сервиса
-        """
-        return OnErrorResult.THROW
-
-    async def _resend_request(self, request_id: uuid.UUID, ex: Exception, *args, **kwargs):
-        """ Повторная отправка запроса """
-        self._request_count_manager.inc(request_id)
-
-        current_step = self.get_current_step(request_id)
-        logger.debug('Repeat request #%s.', current_step)
-
-        if current_step >= self.retry_policy.max_retry:
-            raise errors.MaxRetryError(f'Exceeded the maximum number of attempts {self.retry_policy.max_retry}') from ex
-
-        sleep_seconds = self.retry_policy.backoff_factor * (2 ** (current_step - 1))
-        sleep_seconds += random.normalvariate(0, sleep_seconds * self.retry_policy.jitter)
-        await asyncio.sleep(sleep_seconds)
-
-        return await self._send_request(request_id, *args, **kwargs)
-
-
-class HttpService(BaseService):
-    """
-    Вызов по протоколу http
-    """
-
-    def __init__(self, *args, client_session: ClientSession | None = None, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.client_session = client_session
-
-    async def _send(self, request_id: uuid.UUID, *args, **kwargs) -> ServiceResponse:
-        method = kwargs.get('method', 'get')
-        url = kwargs.get('url', None)
-        if url is None:
-            raise ValueError('Url is none')
-        url = str(url)
-
-        cfg = kwargs.get('cfg', {})
-        if not isinstance(cfg, dict):
-            raise ValueError('Invalid cfg type. Must be dict.')
-
-        if url.lower().startswith('https://') and 'ssl' not in cfg:
-            cfg['ssl'] = False
-
-        async with self._use_client_session() as session:
-            async with session.request(method, url, **cfg) as response:
-                response_data = await _get_response_content(response)
-                return ServiceResponse(status=response.status, response_data=response_data, raw_response=response)
-
-    @asynccontextmanager
-    async def _use_client_session(self):
-        if self.client_session is not None:
-            yield self.client_session
-        else:
-            async with ClientSession(json_serialize=http_utils.json_dumps) as session:
-                yield session
-
-
-class _RequestCountManager:
-    def __init__(self):
-        self._requests: dict[uuid.UUID, int] = {}
-
-    def add(self) -> uuid.UUID:
-        """ Инициализация запроса """
-        request_id = uuid.uuid4()
-        self._requests[request_id] = 0
-        return request_id
-
-    def exist(self, request_id: uuid.UUID) -> bool:
-        """ Проверка наличия запроса """
-        if request_id not in self._requests:
-            raise KeyError(f'Request {str(request_id)} not in registry')
-
-        return True
-
-    def pop(self, request_id: uuid.UUID) -> int | None:
-        """ Удаление запроса """
-        self.exist(request_id)
-        return self._requests.pop(request_id)
-
-    def get(self, request_id: uuid.UUID) -> int:
-        """ Получение количества попыток запроса """
-        self.exist(request_id)
-        return self._requests[request_id]
-
-    def inc(self, request_id: uuid.UUID) -> int:
-        """ Увеличение количества попыток на 1 """
-        self.exist(request_id)
-        self._requests[request_id] += 1
-
-        return self._requests[request_id]
-
-
-async def _get_response_content(response):
-    try:
-        return await response.json()
-    except ContentTypeError:
-        return await response.text()