tp-shared 0.1.0__tar.gz

tp_shared-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.3
+Name: tp-shared
+Version: 0.1.0
+Summary: 
+Author: Developer
+Author-email: front-gold@mail.ru
+Requires-Python: >=3.12,<=3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pydantic (>=2.11.7,<3.0.0)
+Requires-Dist: tp-helper (>=0.4.62,<0.5.0)
+Description-Content-Type: text/markdown
+
+# 🧩 tp-shared
+
+Общий репозиторий схем для использования в нескольких проектах.
+
+---
+
+## Установка:
+`poetry add tp-shared`
+
+## Очистка при обновлении
+```
+poetry cache clear pypi --all --no-interaction; poetry add tp-shared@latest
+```
+
+```
+poetry cache clear pypi --all --no-interaction && poetry add tp-shared@latest
+```
+
+## Публикация:
+Собирает и загружает собранный пакет в PyPI.
+
+`poetry publish --build`
+
+## Структура проекта
+
+**messages** 
+-------------------------
+Схемы сообщений от сервисов
+
+Пример импорта  
+
+from tp_shared_schemas.messages import GibddDcResultMessage
+
+В каждой папке лежат соответствующие Pydantic-схемы, сгруппированные по функционалу.
+--------------------------
+---
+
+## Как подключить репозиторий к существующему проекту
+
+Если у вас есть локальный проект и вы хотите добавить репозиторий с общими схемами, выполните команды:
+в файле pyproject.toml прописать зависимость:
+1) 
+
+```Python
+[tool.poetry.dependencies]
+tp-shared = { git = "https://gitlab.8525.ru/modules/tp-shared.git", rev = "main" }
+```
+
+poetry add git
+
+```python
+poetry add git+https://gitlab.8525.ru/modules/tp-shared.git
+```
+
+2) Выполнить команду poetry install или poetry update
+
+
+## Репозиторий
+```
+cd existing_repo
+git remote add origin https://gitlab.8525.ru/modules/tp-shared.git
+git branch -M main
+git push -uf origin main
+```
+
+

tp_shared-0.1.0/README.md

@@ -0,0 +1,65 @@
+# 🧩 tp-shared
+
+Общий репозиторий схем для использования в нескольких проектах.
+
+---
+
+## Установка:
+`poetry add tp-shared`
+
+## Очистка при обновлении
+```
+poetry cache clear pypi --all --no-interaction; poetry add tp-shared@latest
+```
+
+```
+poetry cache clear pypi --all --no-interaction && poetry add tp-shared@latest
+```
+
+## Публикация:
+Собирает и загружает собранный пакет в PyPI.
+
+`poetry publish --build`
+
+## Структура проекта
+
+**messages** 
+-------------------------
+Схемы сообщений от сервисов
+
+Пример импорта  
+
+from tp_shared_schemas.messages import GibddDcResultMessage
+
+В каждой папке лежат соответствующие Pydantic-схемы, сгруппированные по функционалу.
+--------------------------
+---
+
+## Как подключить репозиторий к существующему проекту
+
+Если у вас есть локальный проект и вы хотите добавить репозиторий с общими схемами, выполните команды:
+в файле pyproject.toml прописать зависимость:
+1) 
+
+```Python
+[tool.poetry.dependencies]
+tp-shared = { git = "https://gitlab.8525.ru/modules/tp-shared.git", rev = "main" }
+```
+
+poetry add git
+
+```python
+poetry add git+https://gitlab.8525.ru/modules/tp-shared.git
+```
+
+2) Выполнить команду poetry install или poetry update
+
+
+## Репозиторий
+```
+cd existing_repo
+git remote add origin https://gitlab.8525.ru/modules/tp-shared.git
+git branch -M main
+git push -uf origin main
+```
+

tp_shared-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "tp-shared"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Developer",email = "front-gold@mail.ru"}
+]
+readme = "README.md"
+requires-python = ">=3.12,<=3.14"
+dependencies = [
+    "pydantic (>=2.11.7,<3.0.0)",
+    "tp-helper (>=0.4.62,<0.5.0)"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.ruff]
+line-length = 88
+target-version = "py313"
+fix = true
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle (стиль)
+    "F",   # pyflakes (ошибки исполнения)
+    "I",   # isort (сортировка импортов)
+    "UP",  # pyupgrade (обновление синтаксиса)
+    "B",   # bugbear (потенциальные баги)
+    "A",   # flake8-builtins (конфликты с встроенными именами)
+    "C4",  # flake8-comprehensions
+    "SIM", # flake8-simplify
+]
+ignore = [
+    "B008",   # Depends(...) в аргументах FastAPI — безопасно и распространённо
+    "E501",   # Длина строки — игнорируем, т.к. используем black с line-length = 88
+    "SIM117", # Вложенные async with — читаемость в некоторых случаях важнее
+]
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.13.0"
+pre-commit = "^4.3.0"
+pylint = "^3.3.8"
+

tp_shared-0.1.0/src/tp_shared/autoins_mpg_service/repos/autoins_results_ack_list_queue_repo.py

@@ -0,0 +1,14 @@
+from redis.asyncio import Redis
+from tp_helper.base_queues.base_ack_list_queue_repo import BaseAckListQueueRepo
+
+# from src.config import config
+from tp_shared.autoins_mpg_service.schemas.autoins_result_message import (
+    AutoinsResultMessage,
+)
+
+
+class AutoinsResultsAckListQueueRepo(BaseAckListQueueRepo):
+    QUEUE_NAME = "autoins:service:results:ack:list"
+
+    def __init__(self, redis_client: Redis):
+        super().__init__(redis_client=redis_client, message_type=AutoinsResultMessage)

tp_shared-0.1.0/src/tp_shared/autoins_mpg_service/schemas/autoins_result_message.py

@@ -0,0 +1,34 @@
+from datetime import date
+
+from pydantic import BaseModel
+
+from tp_shared.types.policy_series import PolicySeries
+
+
+class AutoinsResultPolicy(BaseModel):
+    insurer_name: str
+    reg_number: str
+    series: PolicySeries
+    number: str
+    start_date: date
+    end_date: date
+    period1_start: date | None = None
+    period1_end: date | None = None
+    period2_start: date | None = None
+    period2_end: date | None = None
+    period3_start: date | None = None
+    period3_end: date | None = None
+    vin: str | None = None
+    body_number: str | None = None
+    chassis_number: str | None = None
+    car_mark: str | None = None
+    car_model: str | None = None
+    external_policy_id: int | None = None
+    policy_state: str | None = None
+    policy_status_t_use: str | None = None
+
+
+class AutoinsResultMessage(BaseModel):
+    series: PolicySeries
+    number: str
+    policies: list[AutoinsResultPolicy] = []

tp_shared-0.1.0/src/tp_shared/autoins_mpg_service/worker_services/base_autoins_results_ack_list_queue_worker_service.py

@@ -0,0 +1,34 @@
+from logging import Logger
+
+from redis.asyncio import Redis
+from tp_helper.base_items.base_worker_service import BaseWorkerService
+from tp_helper.decorators.decorator_retry_forever import retry_forever
+
+from tp_shared.autoins_mpg_service.repos.autoins_results_ack_list_queue_repo import (
+    AutoinsResultsAckListQueueRepo,
+)
+from tp_shared.autoins_mpg_service.schemas.autoins_result_message import (
+    AutoinsResultMessage,
+)
+
+
+class BaseAutoinsResultsAckListQueueWorkerService(
+    BaseWorkerService, AutoinsResultsAckListQueueRepo
+):
+    def __init__(self, redis_client: Redis, logger: Logger):
+        BaseWorkerService.__init__(self, logger=logger, redis_client=redis_client)
+        AutoinsResultsAckListQueueRepo.__init__(self, redis_client=redis_client)
+
+    @retry_forever(
+        start_message="📥 Чтение задач из очереди {queue_name}",
+        error_message="❌ Ошибка при чтении из очереди {queue_name}",
+    )
+    async def pop(self) -> AutoinsResultMessage | None:
+        return await AutoinsResultsAckListQueueRepo.pop(self)
+
+    @retry_forever(
+        start_message="🗑️ ack в очередь {queue_name}",
+        error_message="❌ Ошибка при ack в очередь {queue_name}",
+    )
+    async def ack(self) -> None:
+        return await AutoinsResultsAckListQueueRepo.ack(self)

tp_shared-0.1.0/src/tp_shared/base/base_message.py

@@ -0,0 +1,5 @@
+from tp_helper import BaseSchema
+
+
+class BaseMessage(BaseSchema):
+    version: str = "1.0"

tp_shared-0.1.0/src/tp_shared/gibdd_service/repo/gibdd_dc_results_stream_queue_repo.py

@@ -0,0 +1,17 @@
+from redis.asyncio import Redis
+from tp_helper.base_queues.base_stream_queue_repo import BaseStreamQueueRepo
+
+from tp_shared.gibdd_service.schemas.gibdd_dc_result_message import (
+    GibddDcResultMessage,
+)
+
+
+class GibddDcResultsStreamQueueRepo(BaseStreamQueueRepo):
+    QUEUE_NAME = "gibdd:service:dc:results:stream"
+
+    def __init__(self, redis_client: Redis):
+        super().__init__(
+            redis_client=redis_client,
+            schema=GibddDcResultMessage,
+            queue_name=self.QUEUE_NAME,
+        )

tp_shared-0.1.0/src/tp_shared/gibdd_service/schemas/gibdd_dc_result_message.py

@@ -0,0 +1,39 @@
+from datetime import date
+
+from pydantic import ConfigDict
+
+from tp_shared.base.base_message import BaseMessage
+from tp_shared.types.dc_operator_status import DcOperatorStatus
+
+
+class GibddDcResultOperator(BaseMessage):
+    operator_id: int
+    status: DcOperatorStatus
+    name: str
+    address_line: str
+    phone_number: str
+    email: str
+    site: str
+    canceled_date: date | None
+    canceled_at: int | None
+
+
+class GibddDcResultCard(BaseMessage):
+    card_number: str
+    vin: str
+    start_date: date
+    end_date: date
+    odometer_value: int
+    is_active: bool
+    updated_at: int
+    created_at: int
+
+    operator: GibddDcResultOperator
+
+    model_config = ConfigDict(from_attributes=True, populate_by_name=True)
+
+
+class GibddDcResultMessage(BaseMessage):
+    version: str = "1.0"
+    vin: str
+    diagnostic_cards: list[GibddDcResultCard] = []

tp_shared-0.1.0/src/tp_shared/gibdd_service/worker_services/base_gibdd_dc_results_stream_queue_worker_service.py

@@ -0,0 +1,122 @@
+from datetime import timedelta
+from logging import Logger
+
+from redis.asyncio import Redis
+from tp_helper.base_items.base_worker_service import BaseWorkerService
+from tp_helper.decorators.decorator_retry_forever import retry_forever
+
+from tp_shared.gibdd_service.repo.gibdd_dc_results_stream_queue_repo import (
+    GibddDcResultsStreamQueueRepo,
+)
+from tp_shared.gibdd_service.schemas.gibdd_dc_result_message import (
+    GibddDcResultMessage,
+)
+
+
+class BaseGibddDcResultsStreamQueueWorkerService(
+    GibddDcResultsStreamQueueRepo, BaseWorkerService
+):
+    def __init__(
+        self,
+        redis_client: Redis,
+        logger: Logger,
+        group_name: str,
+        consumer_name: str,
+    ):
+        BaseWorkerService.__init__(self, redis_client=redis_client, logger=logger)
+        GibddDcResultsStreamQueueRepo.__init__(self, redis_client=redis_client)
+
+        self.group_name = group_name
+        self.consumer_name = consumer_name
+
+    @retry_forever(
+        start_message="Добавление сообщения из очередь {queue_name}",
+        error_message="Ошибка при добавление сообщения в очередь {queue_name}",
+    )
+    async def add(self, message: GibddDcResultMessage) -> None:
+        await GibddDcResultsStreamQueueRepo.add(self, message)
+
+    @retry_forever(
+        start_message="Получение сообщений из очереди {queue_name}",
+        error_message="Ошибка получения сообщений из очереди {queue_name}",
+    )
+    async def pop(
+        self,
+        stream_id: str = ">",
+        block: int = 0,
+        count: int = 100,
+        prioritize_claimed: bool = True,
+        min_idle_time: int = 60000,
+    ) -> list[tuple[str, GibddDcResultMessage]] | None:
+        return await GibddDcResultsStreamQueueRepo.pop(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            stream_id=stream_id,
+            block=block,
+            count=count,
+            prioritize_claimed=prioritize_claimed,
+            min_idle_time=min_idle_time,
+        )
+
+    @retry_forever(
+        start_message="Подтверждение сообщения в потоке {queue_name}",
+        error_message="Ошибка подтверждения сообщения в потоке {queue_name}",
+    )
+    async def ack(self, message_id: str):
+        await GibddDcResultsStreamQueueRepo.ack(self, self.group_name, message_id)
+
+    @retry_forever(
+        start_message="Поиск зависших сообщений в потоке {queue_name}",
+        error_message="Ошибка при auto-claim сообщений в потоке {queue_name}",
+    )
+    async def claim_reassign(
+        self,
+        min_idle_time: int = 60000,
+        count: int = 100,
+    ) -> list[tuple[str, GibddDcResultMessage]]:
+        return await GibddDcResultsStreamQueueRepo.claim_reassign(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            min_idle_time=min_idle_time,
+            count=count,
+        )
+
+    @retry_forever(
+        start_message="Создание группы потребителей в потоке {queue_name}",
+        error_message="Ошибка создания группы в потоке {queue_name}",
+    )
+    async def create_consumer_group(self, create_stream: bool = True):
+        try:
+            await GibddDcResultsStreamQueueRepo.create_consumer_group(
+                self,
+                group_name=self.group_name,
+                create_stream=create_stream,
+                stream_id="0",
+            )
+        except Exception as e:
+            print(e)
+
+    @retry_forever(
+        start_message="Очистка сообщений старше {retention} в потоке {queue_name}",
+        error_message="Ошибка при очистке сообщений в потоке {queue_name}",
+    )
+    async def trim_by_age(self, retention: timedelta) -> int:
+        """
+        Удаляет сообщения старше указанного периода (retention) через XTRIM MINID.
+
+        :param retention: Максимальный "возраст" сообщений, например timedelta(days=1)
+        :return: Кол-во удалённых сообщений
+        """
+        return await GibddDcResultsStreamQueueRepo.trim_by_age(self, retention)
+
+    @retry_forever(
+        start_message="Полная очистка потока {queue_name}",
+        error_message="Ошибка при полной очистке потока {queue_name}",
+    )
+    async def delete_all(self) -> None:
+        """
+        Удаляет все consumer group и сам поток (полная очистка).
+        """
+        await GibddDcResultsStreamQueueRepo.delete_all(self)

tp_shared-0.1.0/src/tp_shared/mos_passes_service/repo/mos_passes_results_stream_queue_repo.py

@@ -0,0 +1,17 @@
+from redis.asyncio import Redis
+from tp_helper.base_queues.base_stream_queue_repo import BaseStreamQueueRepo
+
+from tp_shared.mos_passes_service.schemas.mos_passes_result_message import (
+    MosPassesResultMessage,
+)
+
+
+class MosPassesResultsStreamQueueRepo(BaseStreamQueueRepo):
+    QUEUE_NAME = "mos:passes:service:results:stream"
+
+    def __init__(self, redis_client: Redis):
+        super().__init__(
+            redis_client=redis_client,
+            schema=MosPassesResultMessage,
+            queue_name=self.QUEUE_NAME,
+        )

tp_shared-0.1.0/src/tp_shared/mos_passes_service/schemas/mos_passes_result_message.py

@@ -0,0 +1,23 @@
+from datetime import date
+
+from tp_shared.base.base_message import BaseMessage
+from tp_shared.types.pass_allowed_zone import PassAllowedZone
+from tp_shared.types.pass_series import PassSeries
+from tp_shared.types.pass_time_of_date import PassTimeOfDate
+
+
+class MosPassesResultPass(BaseMessage):
+    reg_number: str
+    time_of_day: PassTimeOfDate
+    series: PassSeries
+    number: str
+    allowed_zone: PassAllowedZone
+    start_date: date
+    end_date: date
+    cancel_date: date | None
+
+
+class MosPassesResultMessage(BaseMessage):
+    version: str = "1.0"
+    reg_number: str
+    passes: list[MosPassesResultPass] = []

tp_shared-0.1.0/src/tp_shared/mos_passes_service/worker_services/base_mos_passes_results_stream_queue_worker_service.py

@@ -0,0 +1,109 @@
+from datetime import timedelta
+from logging import Logger
+
+from redis.asyncio import Redis
+from tp_helper.base_items.base_worker_service import BaseWorkerService
+from tp_helper.decorators.decorator_retry_forever import retry_forever
+
+from tp_shared.mos_passes_service.repo.mos_passes_results_stream_queue_repo import (
+    MosPassesResultsStreamQueueRepo,
+)
+from tp_shared.mos_passes_service.schemas.mos_passes_result_message import (
+    MosPassesResultMessage,
+)
+
+
+class BaseMosPassesResultsStreamQueueWorkerService(
+    MosPassesResultsStreamQueueRepo, BaseWorkerService
+):
+    def __init__(
+        self,
+        redis_client: Redis,
+        logger: Logger,
+        group_name: str,
+        consumer_name: str,
+    ):
+        BaseWorkerService.__init__(self, redis_client=redis_client, logger=logger)
+        MosPassesResultsStreamQueueRepo.__init__(self, redis_client=redis_client)
+
+        self.group_name = group_name
+        self.consumer_name = consumer_name
+
+    @retry_forever(
+        start_message="Добавление сообщения из очередь {queue_name}",
+        error_message="Ошибка при добавление сообщения в очередь {queue_name}",
+    )
+    async def add(self, message: MosPassesResultMessage) -> None:
+        await MosPassesResultsStreamQueueRepo.add(self, message)
+
+    @retry_forever(
+        start_message="Получение сообщений из очереди {queue_name}",
+        error_message="Ошибка получения сообщений из очереди {queue_name}",
+    )
+    async def pop(
+        self,
+        stream_id: str = ">",
+        block: int = 0,
+        count: int = 100,
+        prioritize_claimed: bool = True,
+        min_idle_time: int = 60000,
+    ) -> list[tuple[str, MosPassesResultMessage]] | None:
+        return await MosPassesResultsStreamQueueRepo.pop(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            stream_id=stream_id,
+            block=block,
+            count=count,
+            prioritize_claimed=prioritize_claimed,
+            min_idle_time=min_idle_time,
+        )
+
+    @retry_forever(
+        start_message="Подтверждение сообщения в потоке {queue_name}",
+        error_message="Ошибка подтверждения сообщения в потоке {queue_name}",
+    )
+    async def ack(self, message_id: str):
+        await MosPassesResultsStreamQueueRepo.ack(self, self.group_name, message_id)
+
+    @retry_forever(
+        start_message="Поиск зависших сообщений в потоке {queue_name}",
+        error_message="Ошибка при auto-claim сообщений в потоке {queue_name}",
+    )
+    async def claim_reassign(
+        self,
+        min_idle_time: int = 60000,
+        count: int = 100,
+    ) -> list[tuple[str, MosPassesResultMessage]]:
+        return await MosPassesResultsStreamQueueRepo.claim_reassign(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            min_idle_time=min_idle_time,
+            count=count,
+        )
+
+    @retry_forever(
+        start_message="Создание группы потребителей в потоке {queue_name}",
+        error_message="Ошибка создания группы в потоке {queue_name}",
+    )
+    async def create_consumer_group(self, create_stream: bool = True):
+        await MosPassesResultsStreamQueueRepo.create_consumer_group(
+            self,
+            group_name=self.group_name,
+            create_stream=create_stream,
+        )
+
+    @retry_forever(
+        start_message="Очистка сообщений старше {retention} в потоке {queue_name}",
+        error_message="Ошибка при очистке сообщений в потоке {queue_name}",
+    )
+    async def trim_by_age(self, retention: timedelta) -> int:
+        return await MosPassesResultsStreamQueueRepo.trim_by_age(self, retention)
+
+    @retry_forever(
+        start_message="Полная очистка потока {queue_name}",
+        error_message="Ошибка при полной очистке потока {queue_name}",
+    )
+    async def delete_all(self) -> None:
+        await MosPassesResultsStreamQueueRepo.delete_all(self)

tp_shared-0.1.0/src/tp_shared/nsis_service/repos/nsis_results_ack_list_queue_repo.py

@@ -0,0 +1,13 @@
+from redis.asyncio import Redis
+from tp_helper.base_queues.base_ack_list_queue_repo import BaseAckListQueueRepo
+
+from tp_shared.nsis_service.schemas.nsis_result_message import (
+    NsisResultMessage,
+)
+
+
+class NsisResultsAckListQueueRepo(BaseAckListQueueRepo):
+    QUEUE_NAME = "nsis:service:results:ack:list"
+
+    def __init__(self, redis_client: Redis):
+        super().__init__(redis_client, message_type=NsisResultMessage)

tp_shared-0.1.0/src/tp_shared/nsis_service/schemas/nsis_result_message.py

@@ -0,0 +1,23 @@
+from datetime import date
+
+from tp_helper.base_items.base_schema import BaseSchema
+
+from tp_shared.nsis_service.types.nsis_task_type import NsisTaskType
+from tp_shared.types.policy_series import PolicySeries
+from tp_shared.types.policy_status import PolicyStatus
+
+
+class NsisResultPolicy(BaseSchema):
+    status: PolicyStatus
+    series: PolicySeries
+    number: str
+    start_date: date | None = None
+    end_date: date | None = None
+    insurer_name: str
+
+
+class NsisResultMessage(BaseSchema):
+    task_type: NsisTaskType
+    query: str
+    request_date: date
+    policies: list[NsisResultPolicy] = []

tp_shared-0.1.0/src/tp_shared/nsis_service/types/nsis_task_type.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class NsisTaskType(Enum):
+    REG_NUMBER = "REG_NUMBER"
+    VIN = "VIN"

tp_shared-0.1.0/src/tp_shared/nsis_service/worker_services/base_nsis_results_queue_worker_service.py

@@ -0,0 +1,32 @@
+from logging import Logger
+
+from redis.asyncio import Redis
+from tp_helper.base_items.base_worker_service import BaseWorkerService
+from tp_helper.decorators.decorator_retry_forever import retry_forever
+
+from tp_shared.nsis_service.repos.nsis_results_ack_list_queue_repo import (
+    NsisResultsAckListQueueRepo,
+)
+from tp_shared.nsis_service.schemas.nsis_result_message import NsisResultMessage
+
+
+class BaseNsisResultsAckListQueueWorkerService(
+    NsisResultsAckListQueueRepo, BaseWorkerService
+):
+    def __init__(self, redis_client: Redis, logger: Logger):
+        BaseWorkerService.__init__(self, logger=logger, redis_client=redis_client)
+        NsisResultsAckListQueueRepo.__init__(self, redis_client=redis_client)
+
+    @retry_forever(
+        start_message="📥 Начало чтения задач из очереди {queue_name}",
+        error_message="❌ Ошибка при чтении из очереди {queue_name}",
+    )
+    async def pop(self) -> NsisResultMessage | None:
+        return await NsisResultsAckListQueueRepo.pop(self)
+
+    @retry_forever(
+        start_message="🗑️ Удаление задач из очереди {queue_name}",
+        error_message="❌ Ошибка при удалении задач из очереди {queue_name}",
+    )
+    async def ack(self) -> None:
+        return await NsisResultsAckListQueueRepo.ack(self)

tp_shared-0.1.0/src/tp_shared/policies_service/repos/policies_event_stream_queue_repo.py

@@ -0,0 +1,17 @@
+from redis.asyncio import Redis
+from tp_helper.base_queues.base_stream_queue_repo import BaseStreamQueueRepo
+
+from tp_shared.policies_service.schemas.policies_result_message import (
+    PoliciesResultMessage,
+)
+
+
+class PoliciesResultsStreamQueueRepo(BaseStreamQueueRepo):
+    QUEUE_NAME = "policies:service:results:stream"
+
+    def __init__(self, redis_client: Redis):
+        super().__init__(
+            redis_client=redis_client,
+            schema=PoliciesResultMessage,
+            queue_name=self.QUEUE_NAME,
+        )

tp_shared-0.1.0/src/tp_shared/policies_service/schemas/policies_result_message.py

@@ -0,0 +1,28 @@
+from datetime import date
+
+from tp_shared.base.base_message import BaseMessage
+from tp_shared.types.policy_series import PolicySeries
+from tp_shared.types.policy_status import PolicyStatus
+
+
+class PoliciesResultPolicy(BaseMessage):
+    series: PolicySeries
+    number: str
+    status: PolicyStatus
+    start_date: date | None = None
+    end_date: date | None = None
+    period1_start: date | None = None
+    period1_end: date | None = None
+    period2_start: date | None = None
+    period2_end: date | None = None
+    period3_start: date | None = None
+    period3_end: date | None = None
+    vin: str | None = None
+    car_mark: str | None = None
+    car_model: str | None = None
+
+
+class PoliciesResultMessage(BaseMessage):
+    version: str = "1.0"
+    reg_number: str
+    policies: list[PoliciesResultPolicy] = []

tp_shared-0.1.0/src/tp_shared/policies_service/worker_services/base_policies_results_queue_worker_service.py

@@ -0,0 +1,109 @@
+from datetime import timedelta
+from logging import Logger
+
+from redis.asyncio import Redis
+from tp_helper.base_items.base_worker_service import BaseWorkerService
+from tp_helper.decorators.decorator_retry_forever import retry_forever
+
+from tp_shared.policies_service.repos.policies_event_stream_queue_repo import (
+    PoliciesResultsStreamQueueRepo,
+)
+from tp_shared.policies_service.schemas.policies_result_message import (
+    PoliciesResultMessage,
+)
+
+
+class BasePolicyResultsStreamQueueWorkerService(
+    PoliciesResultsStreamQueueRepo, BaseWorkerService
+):
+    def __init__(
+        self,
+        redis_client: Redis,
+        logger: Logger,
+        group_name: str = None,
+        consumer_name: str = None,
+    ):
+        BaseWorkerService.__init__(self, redis_client=redis_client, logger=logger)
+        PoliciesResultsStreamQueueRepo.__init__(self, redis_client=redis_client)
+
+        self.group_name = group_name
+        self.consumer_name = consumer_name
+
+    @retry_forever(
+        start_message="➕ Добавление сообщения из очередь {queue_name}",
+        error_message="❌ Ошибка при добавление сообщения в очередь {queue_name}",
+    )
+    async def add(self, message: PoliciesResultMessage) -> None:
+        await PoliciesResultsStreamQueueRepo.add(self, message)
+
+    @retry_forever(
+        start_message="📥 Получение сообщений из очереди {queue_name}",
+        error_message="❗ Ошибка получения сообщений из очереди {queue_name}",
+    )
+    async def pop(
+        self,
+        stream_id: str = ">",
+        block: int = 0,
+        count: int = 100,
+        prioritize_claimed: bool = True,
+        min_idle_time: int = 60000,
+    ) -> list[tuple[str, PoliciesResultMessage]] | None:
+        return await PoliciesResultsStreamQueueRepo.pop(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            stream_id=stream_id,
+            block=block,
+            count=count,
+            prioritize_claimed=prioritize_claimed,
+            min_idle_time=min_idle_time,
+        )
+
+    @retry_forever(
+        start_message="✅ Подтверждение сообщения в потоке {queue_name}",
+        error_message="⚠️ Ошибка подтверждения сообщения в потоке {queue_name}",
+    )
+    async def ack(self, message_id: str):
+        await PoliciesResultsStreamQueueRepo.ack(self, self.group_name, message_id)
+
+    @retry_forever(
+        start_message="🔍 Поиск зависших сообщений в потоке {queue_name}",
+        error_message="🚫 Ошибка при auto-claim сообщений в потоке {queue_name}",
+    )
+    async def claim_reassign(
+        self,
+        min_idle_time: int = 60000,
+        count: int = 100,
+    ) -> list[tuple[str, PoliciesResultMessage]]:
+        return await PoliciesResultsStreamQueueRepo.claim_reassign(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            min_idle_time=min_idle_time,
+            count=count,
+        )
+
+    @retry_forever(
+        start_message="👥 Создание группы потребителей в потоке {queue_name}",
+        error_message="❌ Ошибка создания группы в потоке {queue_name}",
+    )
+    async def create_consumer_group(self, create_stream: bool = True):
+        await PoliciesResultsStreamQueueRepo.create_consumer_group(
+            self,
+            group_name=self.group_name,
+            create_stream=create_stream,
+        )
+
+    @retry_forever(
+        start_message="🧹 Очистка сообщений старше {retention} в потоке {queue_name}",
+        error_message="⚠️ Ошибка при очистке сообщений в потоке {queue_name}",
+    )
+    async def trim_by_age(self, retention: timedelta) -> int:
+        return await PoliciesResultsStreamQueueRepo.trim_by_age(self, retention)
+
+    @retry_forever(
+        start_message="🗑️ Полная очистка потока {queue_name}",
+        error_message="❌ Ошибка при полной очистке потока {queue_name}",
+    )
+    async def delete_all(self) -> None:
+        await PoliciesResultsStreamQueueRepo.delete_all(self)

tp_shared-0.1.0/src/tp_shared/rnis_check_service/repos/rnis_check_results_stream_queue_repo.py

@@ -0,0 +1,17 @@
+from redis.asyncio import Redis
+from tp_helper.base_queues.base_stream_queue_repo import BaseStreamQueueRepo
+
+from tp_shared.rnis_check_service.schemas.rnis_check_result_message import (
+    RNISCheckResultMessage,
+)
+
+
+class RNISCheckResultsStreamQueueRepo(BaseStreamQueueRepo):
+    QUEUE_NAME = "rnis:check:service:results:stream"
+
+    def __init__(self, redis_client: Redis):
+        super().__init__(
+            redis_client=redis_client,
+            schema=RNISCheckResultMessage,
+            queue_name=self.QUEUE_NAME,
+        )

tp_shared-0.1.0/src/tp_shared/rnis_check_service/schemas/rnis_check_result_message.py

@@ -0,0 +1,9 @@
+from tp_shared.base.base_message import BaseMessage
+
+
+class RNISCheckResultMessage(BaseMessage):
+    version: str = "1.0"
+    reg_number: str
+    exists: bool
+    last_mark: int | None
+    terminals_amount: int

tp_shared-0.1.0/src/tp_shared/rnis_check_service/worker_services/base_rnis_results_queue_worker_service.py

@@ -0,0 +1,109 @@
+from datetime import timedelta
+from logging import Logger
+
+from redis.asyncio import Redis
+from tp_helper.base_items.base_worker_service import BaseWorkerService
+from tp_helper.decorators.decorator_retry_forever import retry_forever
+
+from tp_shared.rnis_check_service.repos.rnis_check_results_stream_queue_repo import (
+    RNISCheckResultsStreamQueueRepo,
+)
+from tp_shared.rnis_check_service.schemas.rnis_check_result_message import (
+    RNISCheckResultMessage,
+)
+
+
+class BaseRNISCheckResultsStreamQueueWorkerService(
+    RNISCheckResultsStreamQueueRepo, BaseWorkerService
+):
+    def __init__(
+        self,
+        redis_client: Redis,
+        logger: Logger,
+        group_name: str,
+        consumer_name: str,
+    ):
+        BaseWorkerService.__init__(self, redis_client=redis_client, logger=logger)
+        RNISCheckResultsStreamQueueRepo.__init__(self, redis_client=redis_client)
+
+        self.group_name = group_name
+        self.consumer_name = consumer_name
+
+    @retry_forever(
+        start_message="➕ Добавление сообщения из очередь {queue_name}",
+        error_message="❌ Ошибка при добавление сообщения в очередь {queue_name}",
+    )
+    async def add(self, message: RNISCheckResultMessage) -> None:
+        await RNISCheckResultsStreamQueueRepo.add(self, message)
+
+    @retry_forever(
+        start_message="📥 Получение сообщений из очереди {queue_name}",
+        error_message="⚠️ Ошибка получения сообщений из очереди {queue_name}",
+    )
+    async def pop(
+        self,
+        stream_id: str = ">",
+        block: int = 0,
+        count: int = 100,
+        prioritize_claimed: bool = True,
+        min_idle_time: int = 60000,
+    ) -> list[tuple[str, RNISCheckResultMessage]] | None:
+        return await RNISCheckResultsStreamQueueRepo.pop(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            stream_id=stream_id,
+            block=block,
+            count=count,
+            prioritize_claimed=prioritize_claimed,
+            min_idle_time=min_idle_time,
+        )
+
+    @retry_forever(
+        start_message="✅ Подтверждение сообщения в потоке {queue_name}",
+        error_message="⚠️ Ошибка подтверждения сообщения в потоке {queue_name}",
+    )
+    async def ack(self, message_id: str):
+        await RNISCheckResultsStreamQueueRepo.ack(self, self.group_name, message_id)
+
+    @retry_forever(
+        start_message="🔍 Поиск зависших сообщений в потоке {queue_name}",
+        error_message="🚫 Ошибка при auto-claim сообщений в потоке {queue_name}",
+    )
+    async def claim_reassign(
+        self,
+        min_idle_time: int = 60000,
+        count: int = 100,
+    ) -> list[tuple[str, RNISCheckResultMessage]]:
+        return await RNISCheckResultsStreamQueueRepo.claim_reassign(
+            self,
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            min_idle_time=min_idle_time,
+            count=count,
+        )
+
+    @retry_forever(
+        start_message="👥 Создание группы потребителей в потоке {queue_name}",
+        error_message="❌ Ошибка создания группы в потоке {queue_name}",
+    )
+    async def create_consumer_group(self, create_stream: bool = True):
+        await RNISCheckResultsStreamQueueRepo.create_consumer_group(
+            self,
+            group_name=self.group_name,
+            create_stream=create_stream,
+        )
+
+    @retry_forever(
+        start_message="🧹 Очистка сообщений старше {retention} в потоке {queue_name}",
+        error_message="⚠️ Ошибка при очистке сообщений в потоке {queue_name}",
+    )
+    async def trim_by_age(self, retention: timedelta) -> int:
+        return await RNISCheckResultsStreamQueueRepo.trim_by_age(self, retention)
+
+    @retry_forever(
+        start_message="🗑️ Полная очистка потока {queue_name}",
+        error_message="❌ Ошибка при полной очистке потока {queue_name}",
+    )
+    async def delete_all(self) -> None:
+        await RNISCheckResultsStreamQueueRepo.delete_all(self)

tp_shared-0.1.0/src/tp_shared/rnis_emulator_service/repos/rnis_emulator_results_stream_queue_repo.py

@@ -0,0 +1,17 @@
+from redis.asyncio import Redis
+from tp_helper.base_queues.base_stream_queue_repo import BaseStreamQueueRepo
+
+from tp_shared.rnis_emulator_service.schemas.rnis_emulator_result_message import (
+    RnisEmulatorResultMessage,
+)
+
+
+class RnisEmulatorResultsStreamQueueRepo(BaseStreamQueueRepo):
+    QUEUE_NAME = "rnis:emulator:service:results:stream"
+
+    def __init__(self, redis_client: Redis):
+        super().__init__(
+            redis_client=redis_client,
+            schema=RnisEmulatorResultMessage,
+            queue_name=self.QUEUE_NAME,
+        )

tp_shared-0.1.0/src/tp_shared/rnis_emulator_service/schemas/rnis_emulator_result_message.py

@@ -0,0 +1,57 @@
+import uuid
+from datetime import date
+
+from pydantic import model_validator
+from tp_helper.base_items.base_schema import BaseSchema
+
+from tp_shared.rnis_emulator_service.types.rnis_emulator_types import (
+    RnisEmulatorActionType,
+    RnisEmulatorResultType,
+    RnisEmulatorSubscriptionStatus,
+    RnisEmulatorTaskStatus,
+)
+from tp_shared.types.pass_time_of_date import PassTimeOfDate
+
+
+class RnisEmulatorResultTask(BaseSchema):
+    task_id: uuid.UUID
+    subscription_id: uuid.UUID
+    reg_number: str
+    is_test_drive: bool
+    time_of_day: PassTimeOfDate
+    status: RnisEmulatorTaskStatus
+    error_message: str | None = None
+    started_at: int | None = None
+    ended_at: int | None = None
+
+
+class RnisEmulatorResultSubscription(BaseSchema):
+    subscription_id: uuid.UUID
+    reg_number: str
+    time_of_day: PassTimeOfDate
+    status: RnisEmulatorSubscriptionStatus
+    monthly_run_count: int
+    start_date: date
+    end_date: date
+    created_at: int
+
+    @model_validator(mode="after")
+    def _check_dates(self):
+        if self.start_date > self.end_date:
+            raise ValueError("start_date не может быть позже end_date")
+        return self
+
+
+class RnisEmulatorResultMessage(BaseSchema):
+    type: RnisEmulatorResultType
+    task: RnisEmulatorResultTask | None = None
+    subscription: RnisEmulatorResultSubscription | None = None
+    action_type: RnisEmulatorActionType
+
+    @model_validator(mode="after")
+    def _one_of_task_or_subscription(self):
+        if (self.task is None) and (self.subscription is None):
+            raise ValueError(
+                "Должно быть заполнено хотя бы одно поле: 'task' или 'subscription'."
+            )
+        return self

tp_shared-0.1.0/src/tp_shared/rnis_emulator_service/types/rnis_emulator_types.py

@@ -0,0 +1,35 @@
+from enum import Enum, StrEnum
+
+
+class RnisEmulatorResultType(StrEnum):
+    TASK = "TASK"
+    SUBSCRIPTION = "SUBSCRIPTION"
+
+
+class RnisEmulatorActionType(StrEnum):
+    CREATE = "CREATE"
+    UPDATE = "UPDATE"
+    DELETE = "DELETE"
+
+
+class RnisEmulatorTaskStatus(str, Enum):
+    WAITING = "WAITING"
+    CALCULATING = "CALCULATING"
+    CALCULATED = "CALCULATED"  # Расчёт проведён, готова к эмуляции
+    IN_WORK = "IN_WORK"
+    UNLOADING = "UNLOADING"
+    PARKING = "PARKING"
+    COMPLETED = "COMPLETED"
+    CANCELED = "CANCELED"
+    ERROR = "ERROR"
+
+
+class RnisEmulatorSubscriptionStatus(str, Enum):
+    # первичный, только что создана, ещё не активна
+    CREATED = "CREATED"
+    # работает
+    ACTIVE = "ACTIVE"
+    # вручную приостановлена
+    SUSPENDED = "SUSPENDED"
+    # закончилась по сроку
+    EXPIRED = "EXPIRED"

tp_shared-0.1.0/src/tp_shared/rnis_emulator_service/worker_services/rnis_emulator_results_stream_worker_service.py

@@ -0,0 +1,102 @@
+from datetime import timedelta
+from logging import Logger
+
+from tp_helper.base_items.base_worker_service import BaseWorkerService
+from tp_helper.decorators.decorator_retry_forever import retry_forever
+
+from tp_shared.rnis_emulator_service.repos.rnis_emulator_results_stream_queue_repo import (
+    RnisEmulatorResultsStreamQueueRepo,
+)
+from tp_shared.rnis_emulator_service.schemas.rnis_emulator_result_message import (
+    RnisEmulatorResultMessage,
+)
+
+
+class RnisEmulatorResultsStreamQueueWorkerService(BaseWorkerService):
+    def __init__(
+        self,
+        repo: RnisEmulatorResultsStreamQueueRepo,
+        logger: Logger,
+        group_name: str,
+        consumer_name: str,
+    ):
+        super().__init__(logger=logger)
+        self.repo = repo
+        self.group_name = group_name
+        self.consumer_name = consumer_name
+
+    @retry_forever(
+        start_message="➕ Добавление сообщения из очередь {queue_name}",
+        error_message="❌ Ошибка при добавление сообщения в очередь {queue_name}",
+    )
+    async def add(self, message: RnisEmulatorResultMessage) -> None:
+        await self.repo.add(message)
+
+    @retry_forever(
+        start_message="📥 Получение сообщений из очереди {queue_name}",
+        error_message="⚠️ Ошибка получения сообщений из очереди {queue_name}",
+    )
+    async def pop(
+        self,
+        stream_id: str = ">",
+        block: int = 60,
+        count: int = 100,
+        prioritize_claimed: bool = True,
+        min_idle_time: int = 60000,
+    ) -> list[tuple[str, RnisEmulatorResultMessage]] | None:
+        return await self.repo.pop(
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            stream_id=stream_id,
+            block=block,
+            count=count,
+            prioritize_claimed=prioritize_claimed,
+            min_idle_time=min_idle_time,
+        )
+
+    @retry_forever(
+        start_message="✅ Подтверждение сообщения в потоке {queue_name}",
+        error_message="⚠️ Ошибка подтверждения сообщения в потоке {queue_name}",
+    )
+    async def ack(self, message_id: str):
+        await self.repo.ack(self.group_name, message_id)
+
+    @retry_forever(
+        start_message="🔍 Поиск зависших сообщений в потоке {queue_name}",
+        error_message="🚫 Ошибка при auto-claim сообщений в потоке {queue_name}",
+    )
+    async def claim_reassign(
+        self,
+        min_idle_time: int = 60000,
+        count: int = 100,
+    ) -> list[tuple[str, RnisEmulatorResultMessage]]:
+        return await self.repo.claim_reassign(
+            group_name=self.group_name,
+            consumer_name=self.consumer_name,
+            min_idle_time=min_idle_time,
+            count=count,
+        )
+
+    @retry_forever(
+        start_message="👥 Создание группы потребителей в потоке {queue_name}",
+        error_message="❌ Ошибка создания группы в потоке {queue_name}",
+    )
+    async def create_consumer_group(self, create_stream: bool = True):
+        await self.repo.create_consumer_group(
+            group_name=self.group_name,
+            create_stream=create_stream,
+        )
+
+    @retry_forever(
+        start_message="🧹 Очистка сообщений старше {retention} в потоке {queue_name}",
+        error_message="⚠️ Ошибка при очистке сообщений в потоке {queue_name}",
+    )
+    async def trim_by_age(self, retention: timedelta) -> int:
+        return await self.repo.trim_by_age(retention)
+
+    @retry_forever(
+        start_message="🗑️ Полная очистка потока {queue_name}",
+        error_message="❌ Ошибка при полной очистке потока {queue_name}",
+    )
+    async def delete_all(self) -> None:
+        await self.repo.delete_all()

tp_shared-0.1.0/src/tp_shared/types/dc_operator_status.py

@@ -0,0 +1,7 @@
+import enum
+
+
+class DcOperatorStatus(str, enum.Enum):
+    ACTIVE = "ACTIVE"
+    PAUSED = "PAUSED"
+    CANCELLED = "CANCELLED"

tp_shared-0.1.0/src/tp_shared/types/pass_allowed_zone.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class PassAllowedZone(str, Enum):
+    MKAD = "МКАД"
+    SK = "СК"
+    TTK = "ТТК"
+    MO = "МО"

tp_shared-0.1.0/src/tp_shared/types/pass_series.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+
+class PassSeries(str, Enum):
+    AA = "АА"
+    BA = "БА"
+    AB = "АБ"
+    BB = "ББ"
+    MB = "МБ"
+    MK = "МК"
+    MA = "МА"
+    MO = "МО"
+    II = "ЯЯ"
+    MOJD = "МОЖД"

tp_shared-0.1.0/src/tp_shared/types/pass_time_of_date.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class PassTimeOfDate(str, Enum):
+    DAY = "DAY"
+    NIGHT = "NIGHT"

tp_shared-0.1.0/src/tp_shared/types/policy_series.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+
+class PolicySeries(str, Enum):
+    XXX = "ХХХ"
+    TTT = "ТТТ"
+    AAA = "ААА"
+    AAV = "ААВ"
+    AAK = "ААК"
+    AAM = "ААМ"
+    AAN = "ААН"
+    AAS = "ААС"
+    VVV = "ВВВ"
+    EEE = "ЕЕЕ"
+    KKK = "ККК"
+    MMM = "МММ"
+    NNN = "ННН"
+    RRR = "РРР"
+    SSS = "ССС"

tp_shared-0.1.0/src/tp_shared/types/policy_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class PolicyStatus(str, Enum):
+    ACTIVE = "ACTIVE"
+    WAITING_ACTIVATION = "WAITING_ACTIVATION"
+    EXPIRED = "EXPIRED"