lint+refactor containers

Author: vladimirgubarik

app/application/repository/interfaces.py

@@ -1,6 +1,7 @@
 """Record repository interface."""
 
 from abc import ABC, abstractmethod
+from types import TracebackType
 from typing import List, Self
 
 from app.domain.entities.sample_record import SampleRecord
@@ -10,11 +11,17 @@ class IUnitOfWork(ABC):
     """Interface for unit of work operations."""
 
     @abstractmethod
-    async def __aenter__(self):
+    async def __aenter__(self) -> Self:
         return self
 
     @abstractmethod
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    @abstractmethod
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
         pass
 
 
@@ -81,4 +88,3 @@ async def get_by_id(self, record_id: int) -> SampleRecord:
     async def get_all(self) -> List[SampleRecord]:
         """Get all records from the database"""
         pass
-

app/application/use_cases/interfaces.py

@@ -11,7 +11,7 @@
 
 
 class ISampleRecordUseCases(ABC):
-    """Interface for record use cases."""
+    """Interface for the sample record use cases."""
 
     @abstractmethod
     async def create_record(

app/application/use_cases/record_use_cases.py

@@ -12,7 +12,7 @@
 
 
 class SampleRecordUseCases(ISampleRecordUseCases):
-    """Implementation of samplr record use cases."""
+    """Implementation of sample record use cases."""
 
     def __init__(self, record_repo: ISampleRecordRepository):
         self._repo = record_repo

app/decorators/mapper/context.py

@@ -1,9 +1,10 @@
 from functools import cached_property
-from typing import Callable, Any
+from typing import Any, Callable
 
 
 class ExceptionContext:
-    """Class to store exception rising context."""
+    """Class to get exception rising context."""
+
     SENSITIVE_KEYS: frozenset[str] = frozenset(
         ("password", "token", "key", "secret", "auth", "credential", "passwd")
     )
@@ -22,8 +23,7 @@ def __init__(
 
     @cached_property
     def formatted_context(self) -> str:
-        """Format exception context for logging.
-        """
+        """Format exception context for logging."""
         error_context = [
             f"Error in function '{self.func.__module__}.{self.func.__qualname__}'"
         ]

app/decorators/mapper/exception_mapper.py

@@ -8,15 +8,15 @@
 
 from app.decorators.mapper.context import ExceptionContext
 from app.decorators.mapper.factories import ExceptionFactory
-from app.logger import logger
 
 ExceptionOrTupleOfExceptions = Type[Exception] | tuple[Type[Exception], ...]
 
 
 class ExceptionMapper:
     """Exception-mapping decorator with bounded LRU caching and dynamic MRO lookup.
 
-    The main decorator purpose is map exception between application layers and enrich exceptions by context.
+    The main decorator purpose is map exception between application layers and enrich
+        exceptions by context.
     """
 
     def __init__(
@@ -100,7 +100,7 @@ def _get_exception_factory(
                 self._lru_cache[exc_type] = target_exception_factory
                 return target_exception_factory
 
-        # exception is not presented in base mapping, but catchall presented in mapping dict
+        # exception is not presented in base mapping, but catchall is presented
         if self.exception_catchall_factory:
             self._lru_cache[exc_type] = self.exception_catchall_factory
             return self.exception_catchall_factory

app/decorators/mapper/factories.py

@@ -1,10 +1,13 @@
 from abc import ABC, abstractmethod
+from typing import Any
 
 from app.decorators.mapper.context import ExceptionContext
 
 
 class ContextAwareError(Exception):
-    def __init__(self, message: str, context: ExceptionContext = None, *args):
+    def __init__(
+        self, message: str, context: ExceptionContext | None = None, *args: Any
+    ):
         super().__init__(message, *args)
         self.context = context
 
@@ -44,13 +47,11 @@ class EnrichedExceptionFactory(ExceptionFactory):
     Create and manage enriched exceptions based on a given exception type.
 
     This class provides a mechanism to create exceptions dynamically,
-    enriching them with a formatted context. It extends the behavior of
-    the base ExceptionFactory class by incorporating the concept of a
-    generated error type and formatted context.
+    enriching them with a formatted context.
 
     :ivar generated_error: The type of exception to generate when creating
                            an enriched exception.
-    :type generated_error: type[Exception]
+    :type generated_error: type[ContextAwareError]
     """
 
     def __init__(self, generated_error: type[ContextAwareError]):

app/domain/entities/sample_record.py

@@ -3,7 +3,6 @@
 from dataclasses import dataclass
 
 
-
 @dataclass
 class SampleRecord:
     """Record entity representing a simple record in the system."""

app/infrastructure/containers.py

@@ -1,10 +1,9 @@
 import asyncio
-from importlib import import_module
 
 from dependency_injector import containers, providers
 from dependency_injector.providers import Callable, Factory, Singleton
 from httpx import AsyncClient, Limits
-from pybotx import Bot
+from pybotx import Bot, HandlerCollector
 from redis import asyncio as aioredis
 
 from app.application.use_cases.record_use_cases import SampleRecordUseCases
@@ -20,7 +19,6 @@
     WriteSampleRecordUnitOfWork,
 )
 from app.logger import logger
-
 from app.presentation.bot.error_handlers.internal_error_handler import (
     internal_error_handler,
 )
@@ -81,12 +79,12 @@ def __call__(self) -> asyncio.Task:
         return self._get_task()
 
 
-class ApplicationStartupContainer(containers.DeclarativeContainer):
-    """Container for application startup dependencies."""
+class BaseStartupContainer(containers.DeclarativeContainer):
+    """Общий контейнер для старта бота."""
 
-    redis_client = Singleton(lambda: aioredis.from_url(settings.REDIS_DSN))
+    redis_client = providers.Singleton(lambda: aioredis.from_url(settings.REDIS_DSN))
 
-    redis_repo = Factory(
+    redis_repo = providers.Factory(
         RedisRepo,
         redis=redis_client,
         prefix=strings.BOT_PROJECT_NAME,
@@ -107,16 +105,8 @@ class ApplicationStartupContainer(containers.DeclarativeContainer):
         {} if not settings.RAISE_BOT_EXCEPTIONS else {Exception: internal_error_handler}
     )
 
-    # Ленивая загрузка коллекторов
-    @staticmethod
-    def get_collectors():
-        common = import_module("app.presentation.bot.commands.common")
-        sample_record = import_module("app.presentation.bot.commands.sample_record")
-        return [common.collector, sample_record.collector]
-
     bot = providers.Singleton(
         Bot,
-        collectors=Callable(get_collectors),
         bot_accounts=settings.BOT_CREDENTIALS,
         exception_handlers=exception_handlers,  # type: ignore
         default_callback_timeout=settings.BOTX_CALLBACK_TIMEOUT_IN_SECONDS,
@@ -128,54 +118,40 @@ def get_collectors():
         callback_repo=callback_repo,
     )
 
-    # Используем менеджер задач для ленивой инициализации
+
+class ApplicationStartupContainer(BaseStartupContainer):
+    """Контейнер приложения с ленивой загрузкой collectors."""
+
+    @staticmethod
+    def get_collectors() -> list[HandlerCollector]:
+        from app.presentation.bot.commands.common import collector as common_collector
+        from app.presentation.bot.commands.sample_record import collector as sample_record_collector
+        return [common_collector, sample_record_collector]
+
+    bot = providers.Singleton(
+        Bot,
+        collectors=providers.Callable(get_collectors),
+        **BaseStartupContainer.bot.kwargs,
+    )
+
     callback_task_manager = providers.Singleton(
         CallbackTaskManager,
-        callback_repo,
+        BaseStartupContainer.callback_repo,
     )
 
-    # Провайдер который возвращает задачу через менеджер
     process_callbacks_task = providers.Callable(
         lambda manager: manager(),
         callback_task_manager,
     )
 
 
-class WorkerStartupContainer(containers.DeclarativeContainer):
-    redis_client = Singleton(lambda: aioredis.from_url(settings.REDIS_DSN))
-
-    redis_repo = Factory(
-        RedisRepo,
-        redis=redis_client,
-        prefix=strings.BOT_PROJECT_NAME,
-    )
-
-    async_client = providers.Singleton(
-        AsyncClient,
-        timeout=settings.BOT_ASYNC_CLIENT_TIMEOUT_IN_SECONDS,
-        limits=Limits(max_keepalive_connections=None, max_connections=None),
-    )
+class WorkerStartupContainer(BaseStartupContainer):
+    """Контейнер воркера с прямым импортом collectors."""
 
-    callback_repo = providers.Singleton(
-        CallbackRedisRepo,
-        redis=redis_client,
-    )
     from app.presentation.bot.commands import common, sample_record
 
-    exception_handlers = (
-        {} if not settings.RAISE_BOT_EXCEPTIONS else {Exception: internal_error_handler}
-    )
-
     bot = providers.Singleton(
         Bot,
-        collectors=[common.collector, sample_record.collector],
-        bot_accounts=settings.BOT_CREDENTIALS,
-        exception_handlers=exception_handlers,  # type: ignore
-        default_callback_timeout=settings.BOTX_CALLBACK_TIMEOUT_IN_SECONDS,
-        httpx_client=async_client,
-        middlewares=[
-            smart_logger_middleware,
-            answer_error_middleware,
-        ],
-        callback_repo=callback_repo,
-    )
+        collectors=[common.collector, sample_record.collector],  # type:ignore
+        **BaseStartupContainer.bot.kwargs,
+    )

app/infrastructure/db/sample_record/models.py

@@ -1,6 +1,6 @@
 """Database models declarations."""
 
-from sqlalchemy import String, CheckConstraint
+from sqlalchemy import CheckConstraint, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 from app.infrastructure.db.sqlalchemy import Base

app/infrastructure/db/sqlalchemy.py

@@ -1,15 +1,12 @@
 """SQLAlchemy helpers."""
 
-from asyncio import current_task
-from contextlib import asynccontextmanager
-from functools import lru_cache, wraps
-from typing import Any, Callable
+from functools import lru_cache
+from typing import Callable
 
 from sqlalchemy import MetaData
 from sqlalchemy.ext.asyncio import (
     AsyncEngine,
     AsyncSession,
-    async_scoped_session,
     async_sessionmaker,
     create_async_engine,
 )
@@ -41,6 +38,7 @@ def make_url_sync(url: str) -> str:
 
 Base = declarative_base(metadata=MetaData(naming_convention=convention))
 
+
 @lru_cache(maxsize=1)
 def get_engine() -> AsyncEngine:
     """Lazily initialize and cache a single SQLAlchemy async engine."""
@@ -57,6 +55,7 @@ def get_session_factory() -> async_sessionmaker:
     engine = get_engine()
     return async_sessionmaker(bind=engine, expire_on_commit=False)
 
+
 #
 # def provide_session(func: Callable) -> Callable:
 #     """