tp-common 0.0.1__py3-none-any.whl

tp_common/__init__.py

@@ -0,0 +1,52 @@
+from tp_common.base.base_client.base_client import BaseClient
+from tp_common.base.base_client.base_exception import BaseInfrastructureException
+from tp_common.base.base_client.base_request import BaseRequest
+from tp_common.base.base_client.base_response import BaseResponse
+from tp_common.base.base_client.client_exceptions import (
+    BaseClientException,
+    ClientConnectionException,
+    ClientDNSException,
+    ClientProxyException,
+    ClientResponseErrorException,
+    ClientTimeoutException,
+)
+from tp_common.base.base_client.domain_exceptions import (
+    AuthorizationException,
+    BaseBusinessErrorException,
+    BaseNetworkErrorException,
+    BaseProxyErrorException,
+    BaseServerErrorException,
+    ResourceNotFoundException,
+    ServerException,
+    ServiceUnavailableException,
+    TooManyRequestsException,
+    ValidationException,
+)
+from tp_common.logging import Logger, TracingLogger
+
+__all__ = [
+    # BaseClient
+    "BaseClient",
+    "BaseInfrastructureException",
+    "BaseRequest",
+    "BaseResponse",
+    "BaseClientException",
+    "ClientResponseErrorException",
+    "ClientTimeoutException",
+    "ClientProxyException",
+    "ClientConnectionException",
+    "ClientDNSException",
+    "BaseBusinessErrorException",
+    "BaseServerErrorException",
+    "BaseNetworkErrorException",
+    "BaseProxyErrorException",
+    "AuthorizationException",
+    "ValidationException",
+    "ResourceNotFoundException",
+    "ServerException",
+    "TooManyRequestsException",
+    "ServiceUnavailableException",
+    # Logging
+    "TracingLogger",
+    "Logger",
+]

tp_common/base_client/base_client.py

@@ -0,0 +1,585 @@
+import asyncio
+import json as json_lib
+import logging
+import time
+from datetime import UTC, datetime
+from typing import Any, Literal, TypeVar
+from urllib.parse import urlencode
+
+import aiohttp
+from aiohttp import (
+    ClientConnectionError,
+    ClientConnectorDNSError,
+    ClientHttpProxyError,
+    ClientProxyConnectionError,
+    ServerTimeoutError,
+)
+
+from tp_common.base.base_client.client_exceptions import (
+    BaseClientException,
+    ClientConnectionException,
+    ClientDNSException,
+    ClientProxyException,
+    ClientResponseErrorException,
+    ClientTimeoutException,
+)
+
+T = TypeVar("T", bound="BaseClient")
+
+
+class BaseClient:
+    """
+    Базовый HTTP клиент для работы с внешними API.
+
+    Поддерживает:
+    - Переиспользование сессии
+    - Прокси
+    - Cookies
+    - Имитацию браузера
+    - Логирование (с автоматическим созданием логгера при необходимости)
+    - Переопределение базового URL для тестирования
+
+    Args:
+        cookies: Строка с cookies в формате "name=value; name2=value2"
+        proxy: URL прокси-сервера
+        logger: Внешний логгер (если не передан, создается автоматически)
+        base_url: Базовый URL для запросов (обязательный параметр)
+    """
+
+    DEFAULT_TIMEOUT = 30.0  # секунды
+
+    def __init__(
+        self,
+        base_url: str,
+        cookies: str | None = None,
+        proxy: str | None = None,
+        logger: logging.Logger | None = None,
+    ):
+        self._raw_cookies = cookies
+        self._proxy: str | None = proxy
+        self._session: aiohttp.ClientSession | None = None
+        self._logger = logger or self._create_logger()
+        self._base_url = base_url
+
+    def _create_logger(self) -> logging.Logger:
+        """Создает логгер на основе имени класса, если не передан внешний."""
+        class_name = self.__class__.__name__
+        module_name = self.__class__.__module__
+        logger_name = f"{module_name}.{class_name}"
+        return logging.getLogger(logger_name)
+
+    @property
+    def logger(self) -> logging.Logger:
+        """Возвращает логгер для использования в наследниках."""
+        return self._logger
+
+    @logger.setter
+    def logger(self, logger: logging.Logger) -> None:
+        self._logger = logger
+
+    async def __aenter__(self: T) -> T:
+        """Инициализация сессии при входе в контекстный менеджер"""
+        _ = await self._get_session()
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Закрытие сессии при выходе из контекстного менеджера"""
+        await self.close()
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Получает или создает переиспользуемую сессию"""
+        if self._session is None or self._session.closed:
+            timeout = aiohttp.ClientTimeout(total=self.DEFAULT_TIMEOUT)
+            connector = aiohttp.TCPConnector(limit=100, limit_per_host=30)
+
+            self._session = aiohttp.ClientSession(
+                timeout=timeout,
+                connector=connector,
+                cookies=self._prepare_cookies_dict(),
+            )
+        return self._session
+
+    async def close(self) -> None:
+        """Закрывает HTTP сессию"""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+
+    def _get_default_headers(self) -> dict[str, str]:
+        """Возвращает заголовки по умолчанию для имитации браузера"""
+        return {
+            "accept": "*/*",
+            "accept-language": "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7",
+            "sec-ch-ua": '"Chromium";v="122"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "referer": f"{self._base_url}/",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+        }
+
+    @property
+    def cookies(self) -> str | None:
+        """Возвращает текущие cookies"""
+        return self._raw_cookies
+
+    @cookies.setter
+    def cookies(self, cookies: str) -> None:
+        """Устанавливает новые cookies (требует пересоздания сессии)"""
+        self._raw_cookies = cookies
+        # Сразу обнуляем _session, чтобы следующий _get_session() создал новую сессию
+        # с новыми cookies; старую сессию закрываем в фоне (иначе гонка: запрос
+        # может получить уже закрываемую сессию → "Connector is closed")
+        old_session = self._session
+        self._session = None
+        if old_session and not old_session.closed:
+
+            async def _close_old() -> None:
+                await old_session.close()
+
+            asyncio.create_task(_close_old())
+
+    @property
+    def proxy(self) -> str | None:
+        """Возвращает текущий прокси"""
+        return self._proxy
+
+    @proxy.setter
+    def proxy(self, proxy: str) -> None:
+        """Устанавливает новый прокси"""
+        self._proxy = proxy
+
+    def _prepare_cookies_dict(self) -> dict[str, str] | None:
+        """Подготавливает словарь cookies из строки для aiohttp"""
+        if not self._raw_cookies:
+            return None
+
+        cookies_dict: dict[str, str] = {}
+
+        # Парсим строку cookies в формате "name=value; name2=value2"
+        for cookie_str in self._raw_cookies.split(";"):
+            cookie_str = cookie_str.strip()
+            if not cookie_str:
+                continue
+            if "=" in cookie_str:
+                name, value = cookie_str.split("=", 1)
+                cookies_dict[name.strip()] = value.strip()
+
+        return cookies_dict if cookies_dict else None
+
+    def extract_cookies_from_session(self) -> str | None:
+        """
+        Извлекает cookies из текущей сессии в строку формата 'name=value; name2=value2'.
+
+        Returns:
+            Строка с кукисами в формате 'name=value; name2=value2' или None
+        """
+        if not self._session or self._session.closed:
+            return self._raw_cookies
+
+        cookies_list: list[str] = []
+        for cookie in self._session.cookie_jar:
+            cookies_list.append(f"{cookie.key}={cookie.value}")
+
+        if not cookies_list:
+            return self._raw_cookies
+
+        return "; ".join(cookies_list)
+
+    def _build_url(self, uri: str, params: str | dict[str, Any] | None = None) -> str:
+        """Строит полный URL из базового адреса, URI и параметров"""
+        url = f"{self._base_url}/{uri.lstrip('/')}"
+
+        if params and isinstance(params, dict):
+            # Фильтруем None значения и конвертируем все значения в строки для urlencode
+            filtered_params: dict[str, str] = {}
+            for key, val in params.items():
+                if val is not None:
+                    # Для datetime объектов используем ISO формат с Z и миллисекундами
+                    if isinstance(val, datetime):
+                        # Формат: 2026-01-20T00:00:00.000Z
+                        # Если datetime имеет timezone, конвертируем в UTC, иначе используем как есть
+                        if val.tzinfo is not None:
+                            # Конвертируем в UTC
+                            val_utc = val.astimezone(UTC)
+                            filtered_params[key] = (
+                                val_utc.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+                            )
+                        else:
+                            # Naive datetime - используем как есть и добавляем Z
+                            filtered_params[key] = (
+                                val.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+                            )
+                    else:
+                        filtered_params[key] = str(val)
+            if filtered_params:
+                # Используем urlencode для правильного кодирования параметров URL
+                query_string = urlencode(filtered_params, doseq=False)
+                url += "?" + query_string
+        elif params and isinstance(params, str):
+            url += f"?{params}"
+
+        return url
+
+    def _merge_headers(self, custom_headers: dict[str, Any] | None) -> dict[str, str]:
+        """Объединяет заголовки по умолчанию с пользовательскими"""
+        headers = self._get_default_headers()
+        if custom_headers:
+            headers.update(custom_headers)
+        return headers
+
+    def _prepare_payload(
+        self, json: dict[str, Any] | None, data: Any | None
+    ) -> dict[str, Any] | list[Any] | str | None:
+        """Подготавливает payload для логирования"""
+        if json is not None:
+            return json
+        if data is not None:
+            if isinstance(data, str):
+                try:
+                    return json_lib.loads(data)
+                except (json_lib.JSONDecodeError, TypeError):
+                    return None
+            elif isinstance(data, (dict, list)):
+                return data
+            return None
+        return None
+
+    def _prepare_response(self, response_text: str) -> dict[str, Any] | list[Any] | str:
+        """Подготавливает response для логирования: пытается распарсить JSON, иначе возвращает текст"""
+        if not response_text:
+            return response_text
+        try:
+            return json_lib.loads(response_text)
+        except (json_lib.JSONDecodeError, TypeError):
+            return response_text
+
+    def _decode_response_body(
+        self, body_bytes: bytes, response: aiohttp.ClientResponse
+    ) -> str:
+        """
+        Декодирует тело ответа в строку с учётом кодировки из заголовков
+        и резервных кодировок при ошибке UTF-8 (например, cp1251 для российских API).
+        """
+        encodings_to_try: list[str | tuple[str, str]] = []
+        if response.charset:
+            encodings_to_try.append(response.charset)
+        encodings_to_try.append("utf-8")
+        encodings_to_try.append("cp1251")  # Windows-1251, типично для российских API
+        encodings_to_try.append(("iso-8859-1", "replace"))
+        for entry in encodings_to_try:
+            if isinstance(entry, tuple):
+                encoding, errors = entry
+            else:
+                encoding, errors = entry, "strict"
+            try:
+                return body_bytes.decode(encoding, errors=errors)
+            except (UnicodeDecodeError, LookupError):
+                continue
+        return body_bytes.decode("iso-8859-1", errors="replace")
+
+    async def _make_request(
+        self,
+        method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"],
+        uri: str,
+        headers: dict[str, Any] | None = None,
+        params: str | dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        data: Any | None = None,
+        retry_on_proxy_error: bool = False,
+        max_retries: int = 5,
+    ) -> str:
+        """
+        Базовый метод для выполнения HTTP запросов. Возвращает только строку.
+
+        Args:
+            method: HTTP метод
+            uri: URI endpoint (будет добавлен к base_url)
+            headers: Дополнительные заголовки
+            params: Query параметры
+            json: JSON тело запроса (для POST/PUT/PATCH)
+            data: Данные тела запроса (альтернатива json)
+            retry_on_proxy_error: Повторять ли запрос при ошибках прокси
+            max_retries: Максимальное количество попыток при retry_on_proxy_error
+
+        Returns:
+            Текст ответа как строка
+
+        Raises:
+            ClientResponseErrorException: При неуспешном HTTP статусе (>=400)
+            ClientTimeoutException: При таймауте соединения
+            ClientProxyException: При ошибке прокси
+            ClientConnectionException: При ошибке соединения
+            ClientDNSException: При ошибке DNS
+        """
+        url = self._build_url(uri, params)
+        merged_headers = self._merge_headers(headers)
+        session = await self._get_session()
+
+        # Определяем kwargs для запроса
+        request_kwargs: dict[str, Any] = {
+            "url": url,
+            "headers": merged_headers,
+            "proxy": self._proxy,
+        }
+
+        if json is not None:
+            request_kwargs["json"] = json
+        elif data is not None:
+            request_kwargs["data"] = data
+
+        payload = self._prepare_payload(json, data)
+        amount_failed = 0
+
+        while True:
+            response_body_text = ""
+            start_time = time.perf_counter()
+            try:
+                async with session.request(method, **request_kwargs) as response:
+                    body_bytes = await response.read()
+                    response_body_text = self._decode_response_body(
+                        body_bytes, response
+                    )
+                    end_time = time.perf_counter()
+                    duration_ms = int((end_time - start_time) * 1000)
+
+                    response_data = self._prepare_response(response_body_text)
+
+                    self._logger.info(
+                        "HTTP запрос выполнен",
+                        extra={
+                            "url": url,
+                            "method": method,
+                            "status_code": response.status,
+                            "payload": payload,
+                            "response": response_data,
+                            "duration": duration_ms,
+                        },
+                    )
+
+                    if response.status >= 400:
+                        raise ClientResponseErrorException(
+                            f"HTTP {response.status} error: {response.reason}",
+                            url=url,
+                            status_code=response.status,
+                            response_body=response_body_text,
+                        )
+
+                    return response_body_text
+
+            except (ClientHttpProxyError, ClientProxyConnectionError) as e:
+                if not retry_on_proxy_error:
+                    self._logger.error(
+                        "Ошибка прокси при HTTP запросе",
+                        extra={
+                            "method": method,
+                            "url": url,
+                            "proxy": self._proxy,
+                            "error": str(e),
+                        },
+                    )
+                    raise ClientProxyException(
+                        f"Proxy error: {str(e)}",
+                        url=url,
+                        proxy=self._proxy,
+                    ) from e
+
+                amount_failed += 1
+                if amount_failed >= max_retries:
+                    self._logger.error(
+                        "Ошибка прокси после исчерпания попыток",
+                        extra={
+                            "method": method,
+                            "url": url,
+                            "proxy": self._proxy,
+                            "retries": amount_failed,
+                            "error": str(e),
+                        },
+                    )
+                    raise ClientProxyException(
+                        f"Proxy error after {max_retries} retries: {str(e)}",
+                        url=url,
+                        proxy=self._proxy,
+                    ) from e
+
+                self._logger.warning(
+                    "Повтор запроса после ошибки прокси",
+                    extra={
+                        "method": method,
+                        "url": url,
+                        "proxy": self._proxy,
+                        "retry": amount_failed,
+                        "max_retries": max_retries,
+                    },
+                )
+                continue
+
+            except (TimeoutError, ServerTimeoutError) as e:
+                # self._logger.error(
+                #     "Таймаут HTTP запроса",
+                #     extra={
+                #         "method": method,
+                #         "url": url,
+                #         "timeout": self.DEFAULT_TIMEOUT,
+                #         "error": str(e),
+                #     },
+                # )
+                raise ClientTimeoutException(
+                    f"Request timeout after {self.DEFAULT_TIMEOUT}s: {str(e)}",
+                    url=url,
+                ) from e
+
+            except ClientConnectorDNSError as e:
+                self._logger.error(
+                    "Ошибка DNS при HTTP запросе",
+                    extra={
+                        "method": method,
+                        "url": url,
+                        "error": str(e),
+                    },
+                )
+                raise ClientDNSException(
+                    f"DNS resolution failed: {str(e)}",
+                    url=url,
+                ) from e
+
+            except ClientConnectionError as e:
+                self._logger.error(
+                    "Ошибка соединения при HTTP запросе",
+                    extra={
+                        "method": method,
+                        "url": url,
+                        "error": str(e),
+                    },
+                )
+                raise ClientConnectionException(
+                    f"Connection error: {str(e)}",
+                    url=url,
+                ) from e
+            except ClientResponseErrorException as e:
+                raise e
+            except Exception as e:
+                # Неожиданные ошибки
+                self._logger.error(
+                    "Неожиданная ошибка HTTP запроса",
+                    extra={
+                        "method": method,
+                        "url": url,
+                        "error_type": type(e).__name__,
+                        "error": str(e),
+                        "response": response_body_text or "",
+                    },
+                )
+                raise BaseClientException(
+                    f"Неожиданная HTTP-ошибка: {str(e)}",
+                    url=url,
+                ) from e
+
+    async def request_text(
+        self,
+        method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"],
+        uri: str,
+        headers: dict[str, Any] | None = None,
+        params: str | dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        data: Any | None = None,
+        retry_on_proxy_error: bool = False,
+        max_retries: int = 5,
+    ) -> str:
+        """
+        Выполняет HTTP запрос и возвращает ответ как строку.
+
+        Используется для получения HTML, XML или других текстовых форматов.
+
+        Args:
+            method: HTTP метод
+            uri: URI endpoint (будет добавлен к base_url)
+            headers: Дополнительные заголовки
+            params: Query параметры
+            json: JSON тело запроса (для POST/PUT/PATCH)
+            data: Данные тела запроса (альтернатива json)
+            retry_on_proxy_error: Повторять ли запрос при ошибках прокси
+            max_retries: Максимальное количество попыток при retry_on_proxy_error
+
+        Returns:
+            Текст ответа как строка
+
+        Raises:
+            ClientResponseErrorException: При неуспешном HTTP статусе (>=400)
+            ClientTimeoutException: При таймауте соединения
+            ClientProxyException: При ошибке прокси
+            ClientConnectionException: При ошибке соединения
+            ClientDNSException: При ошибке DNS
+        """
+        return await self._make_request(
+            method=method,
+            uri=uri,
+            headers=headers,
+            params=params,
+            json=json,
+            data=data,
+            retry_on_proxy_error=retry_on_proxy_error,
+            max_retries=max_retries,
+        )
+
+    async def request_json(
+        self,
+        method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"],
+        uri: str,
+        headers: dict[str, Any] | None = None,
+        params: str | dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        data: Any | None = None,
+        retry_on_proxy_error: bool = False,
+        max_retries: int = 5,
+    ) -> dict[str, Any] | list[Any]:
+        """
+        Выполняет HTTP запрос и возвращает ответ как распарсенный JSON.
+
+        Args:
+            method: HTTP метод
+            uri: URI endpoint (будет добавлен к base_url)
+            headers: Дополнительные заголовки
+            params: Query параметры
+            json: JSON тело запроса (для POST/PUT/PATCH)
+            data: Данные тела запроса (альтернатива json)
+            retry_on_proxy_error: Повторять ли запрос при ошибках прокси
+            max_retries: Максимальное количество попыток при retry_on_proxy_error
+
+        Returns:
+            Распарсенный JSON (dict или list)
+
+        Raises:
+            ClientResponseErrorException: При неуспешном HTTP статусе (>=400)
+            ClientTimeoutException: При таймауте соединения
+            ClientProxyException: При ошибке прокси
+            ClientConnectionException: При ошибке соединения
+            ClientDNSException: При ошибке DNS
+            json.JSONDecodeError: Если ответ не является валидным JSON
+        """
+        response_text = await self._make_request(
+            method=method,
+            uri=uri,
+            headers=headers,
+            params=params,
+            json=json,
+            data=data,
+            retry_on_proxy_error=retry_on_proxy_error,
+            max_retries=max_retries,
+        )
+
+        try:
+            return json_lib.loads(response_text)
+        except json_lib.JSONDecodeError as e:
+            url = self._build_url(uri, params)
+            self._logger.error(
+                "Не удалось распарсить ответ как JSON",
+                extra={
+                    "method": method,
+                    "url": url,
+                    "response": response_text,
+                    "error": str(e),
+                },
+            )
+            raise

tp_common/base_client/base_exception.py

@@ -0,0 +1,2 @@
+class BaseInfrastructureException(Exception):
+    pass

tp_common/base_client/base_request.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class BaseRequest(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        validate_by_name=True,
+        validate_by_alias=True,
+        serialize_by_alias=True,
+        populate_by_name=True,
+    )

tp_common/base_client/base_response.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class BaseResponse(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel,
+        validate_by_name=True,
+        validate_by_alias=True,
+        serialize_by_alias=True,
+    )

tp_common/base_client/client_exceptions.py

@@ -0,0 +1,76 @@
+"""Исключения для базового HTTP клиента."""
+
+
+class BaseClientException(Exception):
+    """Базовое исключение для всех ошибок клиента."""
+
+    def __init__(
+        self,
+        message: str,
+        url: str | None = None,
+        status_code: int | None = None,
+        response_body: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.url = url
+        self.status_code = status_code
+        self.response_body = response_body
+
+
+class ClientResponseErrorException(BaseClientException):
+    """Исключение при неуспешном HTTP статусе (>=400)."""
+
+    def __init__(
+        self,
+        message: str,
+        url: str | None = None,
+        status_code: int | None = None,
+        response_body: str | None = None,
+    ) -> None:
+        super().__init__(message, url, status_code, response_body)
+
+
+class ClientTimeoutException(BaseClientException):
+    """Исключение при таймауте соединения."""
+
+    def __init__(
+        self,
+        message: str,
+        url: str | None = None,
+    ) -> None:
+        super().__init__(message, url)
+
+
+class ClientProxyException(BaseClientException):
+    """Исключение при ошибке прокси."""
+
+    def __init__(
+        self,
+        message: str,
+        url: str | None = None,
+        proxy: str | None = None,
+    ) -> None:
+        super().__init__(message, url)
+        self.proxy = proxy
+
+
+class ClientConnectionException(BaseClientException):
+    """Исключение при ошибке соединения (не удалось установить соединение)."""
+
+    def __init__(
+        self,
+        message: str,
+        url: str | None = None,
+    ) -> None:
+        super().__init__(message, url)
+
+
+class ClientDNSException(BaseClientException):
+    """Исключение при ошибке DNS (не удалось разрешить доменное имя)."""
+
+    def __init__(
+        self,
+        message: str,
+        url: str | None = None,
+    ) -> None:
+        super().__init__(message, url)

tp_common/base_client/domain_exceptions.py

@@ -0,0 +1,63 @@
+"""Доменные исключения для обработки ошибок в воркерах."""
+
+from tp_common.base.base_client.client_exceptions import BaseClientException
+
+
+class BaseBusinessErrorException(BaseClientException):
+    """Базовое исключение для бизнес-ошибок (400, 401, 403, 404, 422)."""
+
+    pass
+
+
+class BaseServerErrorException(BaseClientException):
+    """Базовое исключение для ошибок сервера (500, 502, 503, 504)."""
+
+    pass
+
+
+class BaseNetworkErrorException(BaseClientException):
+    """Базовое исключение для сетевых ошибок (таймауты, соединение, DNS)."""
+
+    pass
+
+
+class BaseProxyErrorException(BaseClientException):
+    """Базовое исключение для ошибок прокси."""
+
+    pass
+
+
+class AuthorizationException(BaseBusinessErrorException):
+    """Исключение при ошибке авторизации (401, 403)."""
+
+    pass
+
+
+class ValidationException(BaseBusinessErrorException):
+    """Исключение при ошибке валидации данных (400, 422)."""
+
+    pass
+
+
+class ResourceNotFoundException(BaseBusinessErrorException):
+    """Исключение при отсутствии ресурса (404)."""
+
+    pass
+
+
+class ServerException(BaseServerErrorException):
+    """Исключение при ошибке сервера (500, 502, 503, 504)."""
+
+    pass
+
+
+class TooManyRequestsException(BaseProxyErrorException):
+    """Исключение при превышении лимита запросов (429)."""
+
+    pass
+
+
+class ServiceUnavailableException(BaseServerErrorException):
+    """Исключение при недоступности сервиса (502, 503, 504)."""
+
+    pass

tp_common/logging.py

@@ -0,0 +1,339 @@
+"""
+Централизованный модуль для получения логгеров в проекте.
+
+Единая точка входа — класс Logger(env, job=...).get_logger(name).
+Все настройки форматирования и обработки логов находятся здесь.
+Очередь и поток для асинхронного логирования общие для всех экземпляров (синглтоны).
+"""
+
+from __future__ import annotations
+
+import logging
+import queue
+import sys
+import threading
+import traceback
+import uuid
+from typing import Any
+
+# from logging_loki import LokiHandler
+from pythonjsonlogger import json
+from tp_helper.types.environment_type import EnvironmentType
+
+# ============================================================================
+# ЕДИНАЯ КОНФИГУРАЦИЯ ФОРМАТТЕРА
+# ============================================================================
+# Все изменения формата логов должны производиться здесь
+
+
+def _create_formatter(
+    env: EnvironmentType, job: str | int | uuid.UUID | None = None
+) -> json.JsonFormatter:
+    """
+    Создаёт JSON-форматтер для логов.
+
+    Единая точка настройки формата логов для всего проекта.
+
+    Args:
+        env: Окружение (для статического поля в логах).
+        job: Идентификатор задачи (для статических полей, опционально).
+
+    Returns:
+        Настроенный JSON форматтер.
+    """
+    static_fields = {"env": env.value}
+    if job is not None:
+        static_fields["job"] = str(job)
+
+    return json.JsonFormatter(
+        "{asctime}{levelname}{message}{env}{trace_id}",
+        style="{",
+        json_ensure_ascii=False,
+        rename_fields={
+            "asctime": "timestamp",
+            "levelname": "level",
+            "message": "msg",
+        },
+        static_fields=static_fields,
+    )
+
+
+# ============================================================================
+# ФИЛЬТР ДЛЯ ОБРАБОТКИ ИСКЛЮЧЕНИЙ
+# ============================================================================
+
+
+class ExceptionFormatterFilter(logging.Filter):
+    """Filter that formats exceptions into JSON structure and adds to extra."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Format exception info into structured JSON if present."""
+        if record.exc_info and record.exc_info[0] is not None:
+            e_type, e, exc_traceback = record.exc_info
+
+            if exc_traceback:
+                tb = traceback.extract_tb(exc_traceback)
+                if tb:
+                    last = tb[-1]
+                    record.last_tb_line = (
+                        f"{last.filename}:{last.lineno} — {last.name} → {last.line}"
+                    )
+
+            record.error = e_type if e_type else ""
+            record.error_message = str(e) if e else ""
+
+        return True
+
+
+# ============================================================================
+# АСИНХРОННАЯ ОБРАБОТКА ЛОГОВ
+# ============================================================================
+
+
+class QueueHandler(logging.Handler):
+    """Handler that sends log records to a queue for async processing."""
+
+    def __init__(self, log_queue: queue.Queue[logging.LogRecord | None]) -> None:
+        super().__init__()
+        self.queue = log_queue
+
+    def emit(self, record: logging.LogRecord) -> None:
+        """Put the record into the queue."""
+        try:
+            self.queue.put_nowait(record)
+        except queue.Full:
+            self.handleError(record)
+        except Exception:
+            self.handleError(record)
+
+
+def _log_listener_thread(
+    log_queue: queue.Queue[logging.LogRecord | None],
+    env: EnvironmentType,
+) -> None:
+    """Поток для обработки логов из очереди."""
+
+    formatter = _create_formatter(env)
+    stdout_handler = logging.StreamHandler(sys.stdout)
+    stdout_handler.setFormatter(formatter)
+
+    while True:
+        try:
+            record = log_queue.get()
+            if record is None:  # Сигнал для завершения
+                break
+            stdout_handler.emit(record)
+        except (KeyboardInterrupt, SystemExit):
+            break
+        except Exception:
+            import traceback
+
+            traceback.print_exc(file=sys.stderr)
+
+
+# -----------------------------------------------------------------------------
+# Общая очередь и поток (синглтоны)
+# -----------------------------------------------------------------------------
+# Все экземпляры Logger с use_queue=True используют одну очередь и один поток.
+# Это стандартная практика для асинхронного логирования: один listener на всё
+# приложение — меньше памяти и контекстных переключений, единый формат вывода.
+
+_log_queue: queue.Queue[logging.LogRecord | None] | None = None
+_log_thread: threading.Thread | None = None
+_log_lock = threading.Lock()
+
+
+def _get_log_queue(env: EnvironmentType) -> queue.Queue[logging.LogRecord | None]:
+    """Получает или создаёт глобальную очередь для логов (один раз на приложение)."""
+    global _log_queue, _log_thread
+
+    if _log_queue is None:
+        with _log_lock:
+            if _log_queue is None:
+                _log_queue = queue.Queue(-1)  # -1 = без ограничения размера
+                _log_thread = threading.Thread(
+                    target=_log_listener_thread,
+                    args=(_log_queue, env),
+                    daemon=True,
+                    name="LogListenerThread",
+                )
+                _log_thread.start()
+
+    return _log_queue
+
+
+# ============================================================================
+# ОБЁРТКА ЛОГГЕРА С TRACE_ID
+# ============================================================================
+
+
+class TracingLogger:
+    """
+    Обёртка над logging.Logger с методами set_trace_id / clear_trace_id.
+
+    trace_id хранится в экземпляре: простой вариант, не зависит от contextvars.
+    Передавайте этот логгер по цепочке вызовов — везде будет один и тот же trace_id.
+
+    Ограничение: один экземпляр логгера не должен использоваться из нескольких
+    параллельных asyncio-задач с разными trace_id (будут перезаписывать друг друга).
+    Для цикла «одна задача за раз» — подходит идеально.
+    """
+
+    def __init__(self, logger: logging.Logger) -> None:
+        self._logger = logger
+        self._trace_id: str | uuid.UUID | None = None
+
+    def set_trace_id(self, value: str | uuid.UUID | None) -> None:
+        """Устанавливает trace_id для этого экземпляра логгера."""
+        self._trace_id = value
+
+    def clear_trace_id(self) -> None:
+        """Сбрасывает trace_id."""
+        self._trace_id = None
+
+    def _merge_extra(self, kwargs: dict) -> dict:
+        extra = dict(kwargs.get("extra") or {})
+        if self._trace_id is not None:
+            extra["trace_id"] = str(self._trace_id)
+        return {**kwargs, "extra": extra}
+
+    def debug(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._logger.debug(msg, *args, **self._merge_extra(kwargs))
+
+    def info(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._logger.info(msg, *args, **self._merge_extra(kwargs))
+
+    def warning(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._logger.warning(msg, *args, **self._merge_extra(kwargs))
+
+    def error(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._logger.error(msg, *args, **self._merge_extra(kwargs))
+
+    def exception(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._logger.exception(msg, *args, **self._merge_extra(kwargs))
+
+    def critical(self, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._logger.critical(msg, *args, **self._merge_extra(kwargs))
+
+    def log(self, level: int, msg: str, *args: Any, **kwargs: Any) -> None:
+        self._logger.log(level, msg, *args, **self._merge_extra(kwargs))
+
+    @property
+    def logger(self) -> logging.Logger:
+        """Доступ к исходному logging.Logger при необходимости."""
+        return self._logger
+
+
+# ============================================================================
+# КЛАСС LOGGER — ЕДИНАЯ ТОЧКА ВХОДА ДЛЯ ЛОГГЕРОВ
+# ============================================================================
+
+
+class Logger:
+    """
+    Фабрика логгеров с фиксированной средой (env) и общей очередью.
+
+    Создаётся один раз на уровне приложения с нужной средой (DEV/PROD/...).
+    В разных местах из неё получают логгеры через get_logger(name, job=...).
+    job передаётся в get_logger, а не в конструктор — у каждого логгера свой job.
+
+    Все экземпляры Logger с use_queue=True пишут в одну общую очередь и один
+    фоновый поток (синглтоны на уровне модуля).
+
+    Использование:
+        from tp_helper.logging import Logger
+        from tp_helper.types.environment_type import EnvironmentType
+
+        # Один раз на уровне приложения — фабрика с желаемой средой
+        log_factory = Logger(EnvironmentType.DEV)
+
+        # В разных местах получаем логгеры (job — при необходимости)
+        logger = log_factory.get_logger("api_service")
+        worker_logger = log_factory.get_logger("task_worker", job="task_123")
+
+        # trace_id для сквозной трассировки (например, в воркере по одной задаче)
+        # logger.set_trace_id(uuid.uuid4())
+        # logger.debug("Получена задача", extra=task)  # в логе будет trace_id
+
+        # Настройка uvicorn/fastapi при старте
+        Logger.setup_standard_loggers(EnvironmentType.DEV)
+    """
+
+    def __init__(self, env: EnvironmentType) -> None:
+        """
+        Args:
+            env: Окружение (local/dev/staging/prod) для поля в логах.
+        """
+        self._env = env
+
+    def get_logger(
+        self,
+        name: str | int,
+        job: str | uuid.UUID | int | None = None,
+        # loki_handler: LokiHandler | None = None,
+        use_queue: bool = True,
+    ) -> TracingLogger:
+        """
+        Возвращает логгер с именем name и опциональным job.
+
+        Возвращаемый объект — TracingLogger (обёртка с set_trace_id/clear_trace_id).
+        trace_id хранится в экземпляре и попадает во все записи лога; можно
+        передавать логгер по цепочке вызовов.
+
+        Args:
+            name: Имя логгера (идентификация в логах).
+            job: Идентификатор задачи (опционально), попадает в статические поля.
+            loki_handler: Опциональный handler для отправки в Loki.
+            use_queue: True — асинхронная запись через общую очередь (по умолчанию).
+
+        Returns:
+            TracingLogger с методами set_trace_id/clear_trace_id.
+        """
+        log_queue = _get_log_queue(self._env) if use_queue else None
+
+        logger = logging.getLogger(f"app_logger_{name}")
+        logger.setLevel(logging.DEBUG)
+        logger.propagate = False
+        logger.addFilter(ExceptionFormatterFilter())
+
+        if use_queue and log_queue:
+            logger.addHandler(QueueHandler(log_queue))
+        else:
+            formatter = _create_formatter(self._env, job)
+            stdout_handler = logging.StreamHandler(sys.stdout)
+            stdout_handler.setFormatter(formatter)
+            logger.addHandler(stdout_handler)
+
+        # if loki_handler:
+        #     formatter = _create_formatter(self._env, job)
+        #     loki_handler.setFormatter(formatter)
+        #     logger.addHandler(loki_handler)
+
+        return TracingLogger(logger)
+
+    @staticmethod
+    def setup_standard_loggers(env: EnvironmentType) -> None:
+        """
+        Настраивает логирование для uvicorn и fastapi (единый JSON-формат).
+
+        Вызывать при инициализации API-приложения.
+        """
+        json_formatter = _create_formatter(env)
+        standard_handler = logging.StreamHandler(sys.stdout)
+        standard_handler.setFormatter(json_formatter)
+
+        uvicorn_logger = logging.getLogger("uvicorn")
+        uvicorn_logger.setLevel(logging.INFO)
+        uvicorn_logger.handlers = [standard_handler]
+        uvicorn_logger.propagate = False
+
+        uvicorn_access_logger = logging.getLogger("uvicorn.access")
+        uvicorn_access_logger.setLevel(logging.WARNING)
+        uvicorn_access_logger.propagate = False
+
+        fastapi_logger = logging.getLogger("fastapi")
+        fastapi_logger.setLevel(logging.INFO)
+        fastapi_logger.handlers = [standard_handler]
+        fastapi_logger.propagate = False
+
+        logging.getLogger("src.infrastructure.clients").setLevel(logging.INFO)

tp_common-0.0.1.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.3
+Name: tp-common
+Version: 0.0.1
+Summary: 
+Author: Developer
+Author-email: front-gold@mail.ru
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiohttp (>=3.13.3,<4.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: python-json-logger (>=4.0.0,<5.0.0)
+Requires-Dist: tp-helper (>=0.4.87,<0.5.0)
+Description-Content-Type: text/markdown
+
+# tp-common
+
+
+
+## Getting started
+
+To make it easy for you to get started with GitLab, here's a list of recommended next steps.
+
+Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
+
+## Add your files
+
+* [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
+* [Add files using the command line](https://docs.gitlab.com/topics/git/add_files/#add-files-to-a-git-repository) or push an existing Git repository with the following command:
+
+```
+cd existing_repo
+git remote add origin https://gitlab.8525.ru/modules/tp-common.git
+git branch -M main
+git push -uf origin main
+```
+
+## Integrate with your tools
+
+* [Set up project integrations](https://gitlab.8525.ru/modules/tp-common/-/settings/integrations)
+
+## Collaborate with your team
+
+* [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
+* [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
+* [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
+* [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
+* [Set auto-merge](https://docs.gitlab.com/user/project/merge_requests/auto_merge/)
+
+## Test and Deploy
+
+Use the built-in continuous integration in GitLab.
+
+* [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/)
+* [Analyze your code for known vulnerabilities with Static Application Security Testing (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
+* [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
+* [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
+* [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
+
+***
+
+# Editing this README
+
+When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thanks to [makeareadme.com](https://www.makeareadme.com/) for this template.
+
+## Suggestions for a good README
+
+Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
+
+## Name
+Choose a self-explaining name for your project.
+
+## Description
+Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
+
+## Badges
+On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
+
+## Visuals
+Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
+
+## Installation
+Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
+
+## Usage
+Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
+
+## Support
+Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
+
+## Roadmap
+If you have ideas for releases in the future, it is a good idea to list them in the README.
+
+## Contributing
+State if you are open to contributions and what your requirements are for accepting them.
+
+For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
+
+You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
+
+## Authors and acknowledgment
+Show your appreciation to those who have contributed to the project.
+
+## License
+For open source projects, say how it is licensed.
+
+## Project status
+If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+

tp_common-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+tp_common/__init__.py,sha256=2PQG0ZnJt11WcRYF5rBYhYjXq_1oKrjM760LTEBW8sU,1621
+tp_common/base_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tp_common/base_client/base_client.py,sha256=WYjuANyoczyoavnxXIQzvd3GIzeczG6w8jRxdsEpOG4,24996
+tp_common/base_client/base_exception.py,sha256=vN7Qq-2QIHPsMNUdQ-2G_WDnF-UEcM9gA0L5LwETPlA,57
+tp_common/base_client/base_request.py,sha256=U_ucIFkxVbRMe2gjx_bXATZU4-OvK7r3u6vk1LVanCM,332
+tp_common/base_client/base_response.py,sha256=Y65bNcNIswRi1x49jhC7nuoxs9wuzdzYvZWZ4eFTy4Q,301
+tp_common/base_client/client_exceptions.py,sha256=pC5KmcDEnP28r8lfMzuQNKsGfZhSoVua2JXmyGwaUxM,2234
+tp_common/base_client/domain_exceptions.py,sha256=JoDklz4Uxvk3BJZDxjWsWc5zjASisypQvtA0wEPngsA,1880
+tp_common/logging.py,sha256=YiH3NJmWKIYKB7Uoe81w-Xlov7Rtz9SF7r9yKTuXnbc,14538
+tp_common-0.0.1.dist-info/METADATA,sha256=N6T0o_UdcHpoURKID2U70c7b5iLV5JI23v9sr8EGceQ,6582
+tp_common-0.0.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+tp_common-0.0.1.dist-info/RECORD,,

tp_common-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.3
+Root-Is-Purelib: true
+Tag: py3-none-any