tp-common 0.0.3__tar.gz → 0.0.5__tar.gz

{tp_common-0.0.3 → tp_common-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tp-common
-Version: 0.0.3
+Version: 0.0.5
 Summary: 
 Author: Developer
 Author-email: front-gold@mail.ru
@@ -9,6 +9,7 @@ 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: confluent-kafka (>=2.13.0,<3.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)

{tp_common-0.0.3 → tp_common-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tp-common"
-version = "0.0.3"
+version = "0.0.5"
 description = ""
 authors = [
     {name = "Developer",email = "front-gold@mail.ru"}
@@ -11,7 +11,8 @@ dependencies = [
     "aiohttp (>=3.13.3,<4.0.0)",
     "pydantic (>=2.12.5,<3.0.0)",
     "python-json-logger (>=4.0.0,<5.0.0)",
-    "tp-helper (>=0.4.87,<0.5.0)"
+    "tp-helper (>=0.4.87,<0.5.0)",
+    "confluent-kafka (>=2.13.0,<3.0.0)"
 ]
 
 [build-system]
@@ -66,6 +67,18 @@ follow_imports = "silent"
 module = "tp_common.logging"
 disable_error_code = ["import-untyped"]
 
+[[tool.mypy.overrides]]
+module = "tp_helper.*"
+disable_error_code = ["import-untyped"]
+
+[[tool.mypy.overrides]]
+module = "tp_common.base_items.*"
+disable_error_code = ["import-untyped"]
+
+[[tool.mypy.overrides]]
+module = "tp_logging"
+disable_error_code = ["import-untyped"]
+
 [tool.pyright]
 extraPaths = ["src"]
 

{tp_common-0.0.3 → tp_common-0.0.5}/src/tp_common/base_client/client.py

@@ -16,9 +16,9 @@ from aiohttp import (
 )
 
 from tp_common.base_client.exceptions import (
-    BaseClientException,
     ClientConnectionException,
     ClientDNSException,
+    ClientException,
     ClientProxyException,
     ClientResponseErrorException,
     ClientTimeoutException,
@@ -471,7 +471,7 @@ class BaseClient:
                         "response": response_body_text or "",
                     },
                 )
-                raise BaseClientException(
+                raise ClientException(
                     f"Неожиданная HTTP-ошибка: {str(e)}",
                     url=url,
                 ) from e

{tp_common-0.0.3 → tp_common-0.0.5}/src/tp_common/base_client/exceptions.py

@@ -17,7 +17,6 @@ class ClientException(Exception):
         self.response_body = response_body
 
 
-
 class ClientResponseErrorException(ClientException):
     """Исключение при неуспешном HTTP статусе (>=400)."""
 
@@ -30,6 +29,7 @@ class ClientResponseErrorException(ClientException):
     ) -> None:
         super().__init__(message, url, status_code, response_body)
 
+
 class ClientConnectionException(ClientException):
     """Исключение при ошибке соединения (не удалось установить соединение)."""
 
@@ -40,6 +40,7 @@ class ClientConnectionException(ClientException):
     ) -> None:
         super().__init__(message, url)
 
+
 class ClientTimeoutException(ClientConnectionException):
     """Исключение при таймауте соединения."""
 
@@ -64,9 +65,6 @@ class ClientProxyException(ClientConnectionException):
         self.proxy = proxy
 
 
-
-
-
 class ClientDNSException(ClientConnectionException):
     """Исключение при ошибке DNS (не удалось разрешить доменное имя)."""
 
@@ -90,7 +88,7 @@ class ClientServerErrorException(ClientException):
     pass
 
 
-class BaseNetworkErrorException(ClientException):
+class ClientNetworkErrorException(ClientException):
     """Базовое исключение для сетевых ошибок (таймауты, соединение, DNS)."""
 
     pass

tp_common-0.0.5/src/tp_common/base_items/base_logging_service.py

@@ -0,0 +1,26 @@
+from logging import Logger
+from typing import Any
+
+from tp_helper.functions import get_full_class_name
+
+
+class BaseLoggingService:
+    def __init__(self, logger: Logger | None = None) -> None:
+        self.logger = logger
+
+    def set_logger(self, logger: Logger) -> None:
+        self.logger = logger
+
+    def logging_error(
+        self, exception: Any, message: str, retry_delay: float | None = None
+    ) -> None:
+        if self.logger is None:
+            return
+        error_type = get_full_class_name(exception)
+        error_text = str(exception)
+
+        self.logger.error(message)
+        self.logger.error(f"{error_type}: {error_text}")
+
+        if retry_delay is not None:
+            self.logger.info(f"🔁 Повтор через {retry_delay:.1f} сек...")

tp_common-0.0.5/src/tp_common/base_items/base_request.py

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

tp_common-0.0.5/src/tp_common/base_items/base_response.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
+class BaseResponse(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel, populate_by_name=True, from_attributes=True
+    )

tp_common-0.0.5/src/tp_common/base_items/base_schema.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class BaseSchema(BaseModel):
+    def to_json(self) -> str:
+        return self.model_dump_json()

tp_common-0.0.5/src/tp_common/base_items/base_timestamp_model.py

@@ -0,0 +1,21 @@
+from datetime import UTC, datetime
+
+from sqlalchemy import TIMESTAMP, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+
+class BaseTimestampModel:
+    created_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP(timezone=True),
+        server_default=text("TIMEZONE('utc', now())"),
+        default=lambda: datetime.now(UTC),  # Aware datetime по умолчанию
+        nullable=False,
+    )
+
+    updated_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP(timezone=True),
+        server_default=text("TIMEZONE('utc', now())"),
+        onupdate=text("TIMEZONE('utc', now())"),
+        default=lambda: datetime.now(UTC),  # Aware datetime по умолчанию
+        nullable=False,
+    )

tp_common-0.0.5/src/tp_common/base_items/base_worker.py

@@ -0,0 +1,11 @@
+from logging import Logger
+
+from tp_helper.base_items.base_discord import BaseDiscord
+from tp_helper.base_items.base_logging_service import BaseLoggingService
+from tp_helper.discord_helper import DiscordHelper
+
+
+class BaseWorker(BaseLoggingService, BaseDiscord):
+    def __init__(self, logger: Logger, discord: DiscordHelper):
+        BaseLoggingService.__init__(self, logger)
+        BaseDiscord.__init__(self, discord)

tp_common-0.0.5/src/tp_common/base_items/base_worker_service.py

@@ -0,0 +1,14 @@
+from logging import Logger
+
+from redis.asyncio import Redis
+from tp_helper.base_items.base_logging_service import BaseLoggingService
+
+
+class BaseWorkerService(BaseLoggingService):
+    def __init__(
+        self,
+        logger: Logger,
+        redis_client: Redis | None = None,
+    ) -> None:
+        super().__init__(logger)
+        self.redis_client = redis_client

tp_common-0.0.5/src/tp_common/decorators/decorator_retry_forever.py

@@ -0,0 +1,123 @@
+import asyncio
+import functools
+import inspect
+import logging
+from collections.abc import Awaitable, Callable
+from typing import ParamSpec, Protocol, TypeVar, cast
+
+P = ParamSpec("P")  # параметры оригинальной функции
+R = TypeVar("R")  # возвращаемый тип оригинальной функции
+
+
+class _HasLogger(Protocol):
+    logger: logging.Logger
+
+
+def retry_forever(
+    start_message: str,
+    error_message: str,
+    delay: int = 10,
+    backoff: float = 1.2,
+    max_delay: int = 60,
+    discord_every: int = 3,
+    ignore_exceptions: list[type[Exception | BaseException]] | None = None,
+) -> Callable[
+    [Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]
+]:  # принимает и возвращает асинхронную функцию с исходной сигнатурой
+    """
+    Оборачивает только метод класса.
+    """
+    ignored_list: list[type[Exception] | type[BaseException]] = (
+        ignore_exceptions if ignore_exceptions is not None else []
+    )
+
+    def decorator(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+        sig = inspect.signature(func)
+
+        @functools.wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+            # --- Собираем контекст для подстановки в сообщения
+            self = args[0] if args else None  # self итак уже есть в *args
+            if self is None:
+                raise ValueError(
+                    "@retry_forever применяется только к методу класса, "
+                    f"но {func.__qualname__} не принимает аргументов"
+                )
+            try:
+                bound = sig.bind(*args, **kwargs)
+                bound.apply_defaults()
+                context = dict(bound.arguments)
+            except Exception:
+                context = {"self": self}
+
+            str_context = {k: str(v) for k, v in context.items()}
+
+            # --- Распаковываем self.*
+            if "self" in context:
+                self_obj = context["self"]
+                try:
+                    for attr in dir(self_obj):
+                        if not attr.startswith("_"):
+                            val = getattr(self_obj, attr)
+                            if not callable(val):
+                                str_context[attr] = str(val)
+                except Exception:
+                    pass
+
+            # --- Лог старта
+            self_typed = cast(_HasLogger, self)
+            try:
+                self_typed.logger.debug(start_message.format_map(str_context))
+            except Exception:
+                self_typed.logger.debug(start_message)
+
+            # --- Цикл повторов
+            current_delay: float = float(delay)
+            retry_count = 0
+
+            while True:
+                try:
+                    return await func(*args, **kwargs)
+                except Exception as e:
+                    if type(e) in ignored_list:
+                        raise e from e
+                    retry_count += 1
+
+                    str_context_with_exception = {
+                        **str_context,
+                        "e": str(e),
+                        "retry_count": retry_count,
+                    }
+
+                    try:
+                        err_msg = error_message.format_map(str_context_with_exception)
+                    except Exception:
+                        err_msg = error_message
+
+                    self_typed.logger.exception(f"❌ {err_msg}")
+
+                    discord_obj = getattr(self, "discord", None)
+                    if (
+                        retry_count % discord_every == 0
+                        and discord_obj is not None
+                        and callable(
+                            getattr(discord_obj, "send_traceback_report", None)
+                        )
+                    ):
+                        try:
+                            await discord_obj.send_traceback_report(e, err_msg)
+                        except Exception as discord_error:
+                            self_typed.logger.warning(
+                                f"⚠️ Ошибка при отправке в Discord: {discord_error}"
+                            )
+
+                    self_typed.logger.info(
+                        f"🔁 Повтор #{retry_count} через {current_delay:.1f} сек..."
+                    )
+
+                    await asyncio.sleep(current_delay)
+                    current_delay = min(current_delay * backoff, float(max_delay))
+
+        return wrapper
+
+    return decorator

tp_common-0.0.5/src/tp_common/event_service/base_event_service.py

@@ -0,0 +1,222 @@
+import json
+from collections.abc import Sequence
+from enum import Enum
+from logging import Logger
+from typing import TypeVar, cast
+
+from confluent_kafka import Consumer, KafkaError, KafkaException, Message, Producer
+from pydantic import ValidationError
+
+from tp_common.event_service.event_config import (
+    KAFKA_STREAM_PREFIX,
+    create_consumer,
+    create_producer,
+)
+from tp_common.event_service.schemas import BaseEventPayload, BaseEventType
+
+EventEnumT = TypeVar("EventEnumT", bound=Enum)
+
+
+class BaseEventService:
+    def __init__(self, logger: Logger) -> None:
+        self.logger = logger
+
+
+class ConsumerBaseEventService[EventEnumT: Enum](BaseEventService):
+    def __init__(
+        self,
+        group_id: str,
+        group_name: str,
+        logger: Logger,
+        poll_timeout: float = 1.0,
+        event_enum: type[EventEnumT] = cast(type[EventEnumT], BaseEventType),
+        subscribe_to: Sequence[EventEnumT] | None = None,
+        auto_ack_ignored: bool = True,
+    ) -> None:
+        super().__init__(logger=logger)
+        self.consumer: Consumer = create_consumer(group_id=group_id)
+        self.group_name: str = group_name
+        self.poll_timeout: float = poll_timeout
+        self.event_enum = event_enum
+        self.subscribe_to = subscribe_to
+        self.auto_ack_ignored = auto_ack_ignored
+
+    def subscribe(self) -> None:
+        """
+        Подписываемся на очередь по group_name.
+        """
+        self.consumer.subscribe([f"{KAFKA_STREAM_PREFIX}.{self.group_name}"])
+
+    def consume_filtered(
+        self,
+        event_types: list[EventEnumT] | None = None,
+    ) -> tuple[Message, BaseEventPayload] | None:
+        """
+        Возвращает сообщение и payload для внешней обработки и commit'а.
+        """
+        msg = self._poll_message()
+        if msg is None:
+            return None
+
+        try:
+            payload = self.parse_payload(msg)
+            normalized_event = self._normalize_event(payload.event)
+            snapshot_value = getattr(self.event_enum, "SNAPSHOT", None)
+            if snapshot_value is not None and normalized_event == snapshot_value:
+                # Если это SNAPSHOT(начальная “полная выгрузка” данных из таблицы при старте Debezium‑коннектора)
+                self._log_snapshot_message(msg)
+                self.commit(msg)
+                return None
+            if not self._should_process_event(
+                normalized_event, event_types=event_types
+            ):
+                # Если не проходит по фильтру
+                self._handle_ignored_message(msg)
+                return None
+            # Если проходит по фильтру
+            return msg, payload
+        except ValidationError:
+            # Если в WAL служебные или иные сообщения
+            self._log_skipped_message(msg)
+            self.commit(msg)
+            return None
+        except Exception:
+            # Если иные ошибки
+            self.logger.exception(
+                "Failed to process message (topic=%s, partition=%s, offset=%s) — offset NOT committed",
+                msg.topic(),
+                msg.partition(),
+                msg.offset(),
+            )
+            return None
+
+    def commit(self, msg: Message) -> None:
+        """
+        Записываем изменения.
+        """
+        self.consumer.commit(message=msg, asynchronous=False)
+
+    def close(self) -> None:
+        """
+        Закрытие подключения к очереди.
+        """
+        self.consumer.close()
+
+    def _poll_message(self) -> Message | None:
+        msg = self.consumer.poll(self.poll_timeout)
+        if msg is None:
+            return None
+
+        if msg.error():
+            err = msg.error()
+            eof_code = getattr(KafkaError, "_PARTITION_EOF", 1)
+            if err is not None and err.code() == eof_code:
+                self.logger.debug(
+                    "Partition EOF (topic=%s, partition=%s, offset=%s)",
+                    msg.topic(),
+                    msg.partition(),
+                    msg.offset(),
+                )
+                return None
+            raise KafkaException(err)
+
+        return msg
+
+    def _handle_ignored_message(self, msg: Message) -> None:
+        if not self.auto_ack_ignored:
+            return
+        self.logger.debug(
+            "Ignored message by filter (topic=%s, partition=%s, offset=%s) — committed",
+            msg.topic(),
+            msg.partition(),
+            msg.offset(),
+        )
+        self.commit(msg)
+
+    def _log_skipped_message(self, msg: Message) -> None:
+        # Не Debezium-payload (тестовые/служебные сообщения) — пропускаем и коммитим.
+        self.logger.warning(
+            "Skipped non-Debezium message (topic=%s, partition=%s, offset=%s) — committed anyway",
+            msg.topic(),
+            msg.partition(),
+            msg.offset(),
+            exc_info=True,
+        )
+
+    def _log_snapshot_message(self, msg: Message) -> None:
+        self.logger.debug(
+            "Skipped snapshot message (topic=%s, partition=%s, offset=%s)",
+            msg.topic(),
+            msg.partition(),
+            msg.offset(),
+        )
+
+    def _should_process_event(
+        self,
+        event: EventEnumT | None,
+        event_types: Sequence[EventEnumT] | None = None,
+    ) -> bool:
+        active_filter = event_types if event_types is not None else self.subscribe_to
+        if active_filter is None:
+            return True
+        if event is None:
+            return False
+        return event in list(active_filter)
+
+    def _normalize_event(self, value: object) -> EventEnumT | None:
+        if value is None:
+            return None
+        if isinstance(value, self.event_enum):
+            return value
+        try:
+            return self.event_enum(value)
+        except Exception:
+            return None
+
+    def parse_payload(self, msg: Message) -> BaseEventPayload:
+        raw = msg.value()
+        if raw is None:
+            raise ValueError("Message value is None")
+        event_dict = json.loads(raw)
+        return BaseEventPayload.model_validate(event_dict)
+
+
+class ProducerBaseEventService(BaseEventService):
+    def __init__(self, logger: Logger) -> None:
+        super().__init__(logger=logger)
+        self.producer: Producer = create_producer()
+
+    def publish_payload(
+        self,
+        payload: BaseEventPayload,
+        *,
+        topic: str,
+        key: str | None = None,
+    ) -> None:
+        data = json.dumps(payload.model_dump(mode="json"), ensure_ascii=False).encode(
+            "utf-8"
+        )
+        key_bytes = key.encode("utf-8") if key is not None else None
+        self.producer.produce(
+            topic=topic,
+            value=data,
+            key=key_bytes,
+        )
+        self.producer.poll(0)
+
+    def flush(self, timeout: float = 10.0) -> None:
+        self.producer.flush(timeout)
+
+    def close(self, timeout: float = 10.0) -> None:
+        self.flush(timeout)
+
+    def _on_delivery(self, err: KafkaError | None, msg: Message) -> None:
+        if err:
+            self.logger.error("Kafka delivery error: %s", err)
+            return
+        self.logger.debug(
+            "Kafka delivered: topic=%s partition=%s offset=%s",
+            msg.topic(),
+            msg.partition(),
+            msg.offset(),
+        )

tp_common-0.0.5/src/tp_common/event_service/consumer_event_service.py

@@ -0,0 +1,88 @@
+import typing
+from enum import Enum
+from logging import Logger
+from typing import cast
+
+from confluent_kafka import Message
+from pydantic import BaseModel, ValidationError
+
+from tp_common.event_service.base_event_service import ConsumerBaseEventService
+from tp_common.event_service.schemas import BaseEventType, TypedEventPayload
+
+
+class ConsumeEventService[EventEnumT: Enum, ModelT: BaseModel](
+    ConsumerBaseEventService[EventEnumT]
+):
+    def __init__(
+        self,
+        group_id: str,
+        group_name: str,
+        logger: Logger,
+        payload_schema: type[ModelT],
+        poll_timeout: float = 1.0,
+        event_enum: type[EventEnumT] = cast(type[EventEnumT], BaseEventType),
+        subscribe_to: list[EventEnumT] | None = None,
+        auto_ack_ignored: bool = True,
+    ) -> None:
+        super().__init__(
+            group_id=group_id,
+            group_name=group_name,
+            logger=logger,
+            poll_timeout=poll_timeout,
+            event_enum=event_enum,
+            subscribe_to=subscribe_to,
+            auto_ack_ignored=auto_ack_ignored,
+        )
+        self.payload_schema = payload_schema
+
+    def parse_payload(self, msg: Message) -> TypedEventPayload[ModelT]:  # type: ignore[override]
+        base_payload = super().parse_payload(msg)
+        before = self._parse_model_part(base_payload.before)
+        after = self._parse_model_part(base_payload.after)
+        normalized_event = self._normalize_event(base_payload.event)
+        return TypedEventPayload[ModelT](
+            before=before,
+            after=after,
+            event=normalized_event,
+        )
+
+    def consume_filtered(  # type: ignore[override]
+        self,
+        event_types: list[EventEnumT] | None = None,
+    ) -> tuple[Message, TypedEventPayload[ModelT]] | None:
+        msg = self._poll_message()
+        if msg is None:
+            return None
+        try:
+            payload = self.parse_payload(msg)
+            snapshot_value = getattr(self.event_enum, "SNAPSHOT", None)
+            if snapshot_value is not None and payload.event == snapshot_value:
+                self._log_snapshot_message(msg)
+                self.commit(msg)
+                return None
+            if not self._should_process_event(
+                typing.cast(EventEnumT | None, payload.event),
+                event_types=event_types,
+            ):
+                self._handle_ignored_message(msg)
+                return None
+            return msg, payload
+        except ValidationError:
+            self._log_skipped_message(msg)
+            self.commit(msg)
+            return None
+        except Exception:
+            self.logger.exception(
+                "Failed to process message (topic=%s, partition=%s, offset=%s) — offset NOT committed",
+                msg.topic(),
+                msg.partition(),
+                msg.offset(),
+            )
+            return None
+
+    def _parse_model_part(self, data: dict | BaseModel | None) -> ModelT | None:
+        if data is None:
+            return None
+        if isinstance(data, self.payload_schema):
+            return typing.cast(ModelT, data)
+        return typing.cast(ModelT, self.payload_schema.model_validate(data))

tp_common-0.0.5/src/tp_common/event_service/event_config.py

@@ -0,0 +1,46 @@
+import os
+
+from confluent_kafka import Consumer, Producer
+
+KAFKA_BOOTSTRAP_SERVERS = os.getenv("KAFKA_BOOTSTRAP_SERVERS", "192.168.81.61:9094")
+KAFKA_STREAM_PREFIX = os.getenv("KAFKA_STREAM_PREFIX", "events.public")
+DEFAULT_GROUP_ID = os.getenv("DEFAULT_GROUP_ID", "domain-tpc-consumer")
+
+SASL_USERNAME = os.getenv("KAFKA_SASL_USERNAME", "user")
+SASL_PASSWORD = os.getenv("KAFKA_SASL_PASSWORD", "user1122@")
+SASL_MECHANISM = os.getenv("KAFKA_SASL_MECHANISM", "SCRAM-SHA-256")
+SECURITY_PROTOCOL = os.getenv("KAFKA_SECURITY_PROTOCOL", "SASL_PLAINTEXT")
+
+
+def create_consumer(group_id: str = DEFAULT_GROUP_ID) -> Consumer:
+    return Consumer(
+        {
+            "bootstrap.servers": KAFKA_BOOTSTRAP_SERVERS,
+            "group.id": group_id,
+            "auto.offset.reset": "earliest",
+            "enable.auto.commit": False,
+            "session.timeout.ms": 30000,
+            "max.poll.interval.ms": 300000,
+            # SASL
+            "security.protocol": SECURITY_PROTOCOL,
+            "sasl.mechanism": SASL_MECHANISM,
+            "sasl.username": SASL_USERNAME,
+            "sasl.password": SASL_PASSWORD,
+        }
+    )
+
+
+def create_producer() -> Producer:
+    return Producer(
+        {
+            "bootstrap.servers": KAFKA_BOOTSTRAP_SERVERS,
+            "acks": "all",
+            "retries": 3,
+            "retry.backoff.ms": 100,
+            # SASL
+            "security.protocol": SECURITY_PROTOCOL,
+            "sasl.mechanism": SASL_MECHANISM,
+            "sasl.username": SASL_USERNAME,
+            "sasl.password": SASL_PASSWORD,
+        }
+    )

tp_common-0.0.5/src/tp_common/event_service/producer_event_service.py

@@ -0,0 +1,97 @@
+import json
+from enum import Enum
+from logging import Logger
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+from tp_common.event_service.base_event_service import ProducerBaseEventService
+from tp_common.event_service.event_config import KAFKA_STREAM_PREFIX
+from tp_common.event_service.schemas import BaseEventPayload, TypedEventPayload
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+
+
+class ProducerEventService(ProducerBaseEventService):
+    def __init__(
+        self,
+        logger: Logger,
+        group_name: str,
+        payload_schema: type[ModelT] | None = None,
+    ) -> None:
+        super().__init__(logger=logger)
+        self.topic_name = f"{KAFKA_STREAM_PREFIX}.{group_name}"
+        self.payload_schema = payload_schema
+
+    def publish(
+        self,
+        payload: BaseEventPayload | TypedEventPayload[ModelT],
+    ) -> None:
+        normalized_payload = self._normalize_payload(payload)
+        data = json.dumps(
+            normalized_payload.model_dump(mode="json"),
+            ensure_ascii=False,
+        ).encode("utf-8")
+        self.producer.produce(
+            topic=self.topic_name,
+            value=data,
+            on_delivery=self._on_delivery,
+        )
+
+        self.producer.poll(0)
+
+    def publish_to_group(
+        self,
+        payload: BaseEventPayload | TypedEventPayload[ModelT],
+    ) -> None:
+        self.publish(payload)
+
+    def _normalize_payload(
+        self,
+        payload: BaseEventPayload | TypedEventPayload[ModelT],
+    ) -> BaseEventPayload:
+        if isinstance(payload, BaseEventPayload):
+            return self._normalize_base_payload(payload)
+        before = self._normalize_model_part(payload.before)
+        after = self._normalize_model_part(payload.after)
+        event = self._normalize_event_value(payload.event)
+        return BaseEventPayload(
+            before=before,
+            after=after,
+            event=event,
+        )
+
+    def _normalize_base_payload(self, payload: BaseEventPayload) -> BaseEventPayload:
+        before = self._normalize_model_part(payload.before)
+        after = self._normalize_model_part(payload.after)
+        event = self._normalize_event_value(payload.event)
+        if (
+            before is payload.before
+            and after is payload.after
+            and event == payload.event
+        ):
+            return payload
+        return BaseEventPayload(
+            before=before,
+            after=after,
+            event=event,
+        )
+
+    def _normalize_model_part(self, data: dict | BaseModel | None) -> dict | None:
+        if data is None:
+            return None
+        if isinstance(data, BaseModel):
+            return data.model_dump(mode="json")
+        if self.payload_schema is None:
+            return data
+        if isinstance(data, self.payload_schema):
+            return data.model_dump(mode="json")
+        return self.payload_schema.model_validate(data).model_dump(mode="json")
+
+    @staticmethod
+    def _normalize_event_value(value: object) -> str | None:
+        if value is None:
+            return None
+        if isinstance(value, Enum):
+            return str(value.value)
+        return str(value)

tp_common-0.0.5/src/tp_common/event_service/schemas.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import Any, TypeVar
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+
+
+class BaseEventType(str, Enum):
+    CREATE = "create"
+    UPDATE = "update"
+    DELETE = "delete"
+    SNAPSHOT = "snapshot"
+
+    @classmethod
+    def _missing_(cls, value: object) -> BaseEventType | None:
+        if not isinstance(value, str):
+            return None
+        mapping = {
+            "c": cls.CREATE,
+            "u": cls.UPDATE,
+            "d": cls.DELETE,
+            "r": cls.SNAPSHOT,
+        }
+        return mapping.get(value.lower())
+
+
+class BaseEventPayload(BaseModel):
+    before: dict[str, Any] | None = Field(None, description="Схема до изменений")
+    after: dict[str, Any] | None = Field(None, description="Схема после изменений")
+    event: str | None = Field(
+        default=None,
+        validation_alias=AliasChoices("event"),
+        serialization_alias="event",
+    )
+
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+
+
+class TypedEventPayload[ModelT: BaseModel](BaseModel):
+    before: ModelT | None = None
+    after: ModelT | None = None
+    event: Enum | None = None
+
+    model_config = ConfigDict(extra="allow")
+
+
+# Для примера
+class UserPayload(BaseModel):
+    id: int
+    name: str
+    description: str | None = None
+    is_active: bool
+    created_at: datetime
+    updated_at: datetime | None = None

tp_common-0.0.5/src/tp_common/event_service/workers/base_event_worker.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from enum import Enum
+from logging import Logger
+from typing import TypeVar, cast
+
+from pydantic import BaseModel
+
+from tp_common.event_service.consumer_event_service import ConsumeEventService
+from tp_common.event_service.producer_event_service import ProducerEventService
+from tp_common.event_service.schemas import (
+    BaseEventPayload,
+    BaseEventType,
+    TypedEventPayload,
+)
+
+ModelT = TypeVar("ModelT", bound=BaseModel)
+EventEnumT = TypeVar("EventEnumT", bound=Enum)
+
+
+class BaseEventWorker[ModelT: BaseModel, EventEnumT: Enum]:
+    def __init__(
+        self,
+        logger: Logger,
+        group_id: str,
+        group_name: str,
+        producer_group_name: str,
+        payload_schema: type[ModelT],
+        event_enum: type[EventEnumT] = cast(type[EventEnumT], BaseEventType),
+        subscribe_to: list[EventEnumT] | None = None,
+    ) -> None:
+        self.consumer_service = ConsumeEventService(
+            group_id=group_id,
+            group_name=group_name,
+            logger=logger,
+            payload_schema=payload_schema,
+            event_enum=event_enum,
+            subscribe_to=subscribe_to,
+        )
+        self.producer_service = ProducerEventService(
+            logger=logger,
+            group_name=producer_group_name,
+            payload_schema=payload_schema,
+        )
+
+    def start(self) -> None:
+        self.subscribe_to_queue()
+        while True:
+            print("PROCESS")
+            self.process()
+
+    def subscribe_to_queue(self) -> None:
+        self.consumer_service.subscribe()
+
+    def process(self) -> None:
+        result = self.consumer_service.consume_filtered()
+        if result is None:
+            return
+        msg, payload = result
+        print(msg, payload)
+        self.handle_update(payload)
+        self.consumer_service.commit(msg)
+
+    def handle_update(self, payload: TypedEventPayload[ModelT]) -> None:
+        before = payload.before
+        after = payload.after
+        if not before or not after:
+            return
+
+        events = self.get_event_types(before, after)
+        for event_type in events:
+            out_payload = TypedEventPayload[ModelT](
+                before=before,
+                after=after,
+                event=event_type,
+            )
+            self.produce(out_payload)
+
+    def get_event_types(self, before: ModelT, after: ModelT) -> list[Enum]:
+        raise NotImplementedError("get_event_types must be implemented in subclass")
+
+    def produce(self, payload: BaseEventPayload | TypedEventPayload[ModelT]) -> None:
+        self.producer_service.publish(payload)

{tp_common-0.0.3 → tp_common-0.0.5}/src/tp_common/route/shames.py

@@ -1,3 +1,7 @@
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+
 class BaseResponse(BaseModel):
     model_config = ConfigDict(
         alias_generator=to_camel,