refactor lint

vladimirgubarik · vladimirgubarik · commit 890ba588e5c2 · 2025-08-08T12:24:11.000+03:00
diff --git a/app/infrastructure/containers.py b/app/infrastructure/containers.py
@@ -1,10 +1,12 @@
 import asyncio
+from typing import Callable as TypeCallable
 
 from dependency_injector import containers, providers
 from dependency_injector.providers import Callable, Factory
 from httpx import AsyncClient, Limits
 from pybotx import Bot, HandlerCollector
 from redis import asyncio as aioredis
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.application.use_cases.record_use_cases import SampleRecordUseCases
 from app.infrastructure.repositories.caching.callback_redis_repo import (
@@ -29,7 +31,9 @@
 
 
 class BotSampleRecordCommandContainer(containers.DeclarativeContainer):
-    session_factory = providers.Dependency()
+    session_factory: providers.Dependency[TypeCallable[[], AsyncSession]] = (
+        providers.Dependency()
+    )
 
     ro_unit_of_work: Factory[ReadOnlySampleRecordUnitOfWork] = Factory(
         ReadOnlySampleRecordUnitOfWork, session_factory
diff --git a/app/infrastructure/repositories/sample_record.py b/app/infrastructure/repositories/sample_record.py
@@ -21,14 +21,14 @@
 from app.decorators.mapper.exception_mapper import (
     ExceptionMapper,
 )
-from app.decorators.mapper.factories import EnrichedExceptionFactory
+from app.decorators.mapper.factories import ContextAwareError, EnrichedExceptionFactory
 from app.domain.entities.sample_record import SampleRecord
 from app.infrastructure.db.sample_record.models import SampleRecordModel
 from app.infrastructure.db.sqlalchemy import AsyncSession
 
 
 class IntegrityErrorFactory(EnrichedExceptionFactory):
-    def make_exception(self, context: ExceptionContext) -> Exception:
+    def make_exception(self, context: ExceptionContext) -> ContextAwareError:
         if not (orig := getattr(context.original_exception, "orig", None)):
             return self.generated_error(context.formatted_context)
 
diff --git a/app/infrastructure/repositories/unit_of_work.py b/app/infrastructure/repositories/unit_of_work.py
@@ -1,4 +1,5 @@
-import asyncio
+from types import TracebackType
+from typing import Self
 
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 
@@ -10,38 +11,56 @@
 
 
 class ReadOnlySampleRecordUnitOfWork(ISampleRecordUnitOfWork):
+    def __init__(self, session_factory: async_sessionmaker):
+        super().__init__()
+        self.session_factory = session_factory
+        self._session: AsyncSession | None = None
+
     def get_sample_record_repository(self) -> ISampleRecordRepository:
         if not self._session:
             raise RuntimeError("Session is not initialized")
 
         return SampleRecordRepository(self._session)
 
-    def __init__(self, session_factory: async_sessionmaker):
-        super().__init__()
-        self.session_factory = session_factory
-        self._session: AsyncSession | None = None
-
-    async def __aenter__(self):
+    async def __aenter__(self) -> Self:
         self._session = self.session_factory()
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        if not self._session:
+            return
+
         try:
-            # Recommended for explicit resources cleanup
-            await self._session.rollback()
+            if exc_type is not None or self._session.in_transaction():
+                await self._session.rollback()
         finally:
             await self._session.close()
+            self._session = None
 
 
 class WriteSampleRecordUnitOfWork(ReadOnlySampleRecordUnitOfWork):
     """Unit of Work for write operations with full transaction management."""
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> Self:
         self._session = self.session_factory()
-        await asyncio.wait_for(self._session.begin(), timeout=5)
+
+        await self._session.begin()
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        if not self._session:
+            return
+
         try:
             if exc_type:
                 await self._session.rollback()
diff --git a/app/presentation/bot/command_handlers/base_handler.py b/app/presentation/bot/command_handlers/base_handler.py
@@ -15,7 +15,7 @@ def __init__(
         self,
         bot: Bot,
         message: IncomingMessage,
-        exception_handler_executor: ExceptionHandlersChainExecutor | None,
+        exception_handler_executor: ExceptionHandlersChainExecutor,
     ):
         self._bot = bot
         self._message = message
diff --git a/app/presentation/bot/command_handlers/sample_record.py b/app/presentation/bot/command_handlers/sample_record.py
@@ -19,6 +19,7 @@
 from app.presentation.bot.error_handlers.exceptions_chain_executor import (
     DEFAULT_HANDLERS_WITH_EXPLAIN,
     ExceptionHandlersChainExecutor,
+    HandlerOrHandlerClass,
 )
 from app.presentation.bot.resources.strings import (
     SAMPLE_RECORD_CREATED_ANSWER,
@@ -39,15 +40,18 @@
 class CreateSampleRecordHandler(BaseCommandHandler):
     incoming_argument_parser = BotXJsonRequestParser(SampleRecordCreateRequestSchema)
 
-    _EXCEPTIONS_HANDLERS = DEFAULT_HANDLERS_WITH_EXPLAIN + [
-        SendErrorExplainToUserHandler(
-            exception_explain_mapping={
-                RecordAlreadyExistsError: "Запись с такими параметрами уже существует",
-                RecordCreateError: "Внутренняя ошибка создания записи",
-                MessageValidationError: "Неправильный формат данных",
-            }
-        )
-    ]
+    _EXCEPTIONS_HANDLERS: list[HandlerOrHandlerClass] = (
+        DEFAULT_HANDLERS_WITH_EXPLAIN
+        + [
+            SendErrorExplainToUserHandler(
+                exception_explain_mapping={
+                    RecordAlreadyExistsError: "Запись с такими параметрами существует",
+                    RecordCreateError: "Внутренняя ошибка создания записи",
+                    MessageValidationError: "Неправильный формат данных",
+                }
+            )
+        ]
+    )
 
     def __init__(
         self,
@@ -87,14 +91,17 @@ class DeleteSampleRecordHandler(BaseCommandHandler):
         SampleRecordGetOrDeleteRequestSchema
     )
 
-    _EXCEPTIONS_HANDLERS = DEFAULT_HANDLERS_WITH_EXPLAIN + [
-        SendErrorExplainToUserHandler(
-            exception_explain_mapping={
-                RecordDoesNotExistError: "Запиcь с указанным id не найдена",
-                MessageValidationError: "Неправильный формат данных",
-            }
-        )
-    ]
+    _EXCEPTIONS_HANDLERS: list[HandlerOrHandlerClass] = (
+        DEFAULT_HANDLERS_WITH_EXPLAIN
+        + [
+            SendErrorExplainToUserHandler(
+                exception_explain_mapping={
+                    RecordDoesNotExistError: "Запиcь с указанным id не найдена",
+                    MessageValidationError: "Неправильный формат данных",
+                }
+            )
+        ]
+    )
 
     def __init__(
         self,
@@ -132,14 +139,17 @@ class GetSampleRecordHandler(BaseCommandHandler):
         SampleRecordGetOrDeleteRequestSchema
     )
 
-    _EXCEPTIONS_HANDLERS = DEFAULT_HANDLERS_WITH_EXPLAIN + [
-        SendErrorExplainToUserHandler(
-            exception_explain_mapping={
-                RecordDoesNotExistError: "Запиcь с указанным id не найдена",
-                MessageValidationError: "Неправильный формат данных",
-            }
-        )
-    ]
+    _EXCEPTIONS_HANDLERS: list[HandlerOrHandlerClass] = (
+        DEFAULT_HANDLERS_WITH_EXPLAIN
+        + [
+            SendErrorExplainToUserHandler(
+                exception_explain_mapping={
+                    RecordDoesNotExistError: "Запиcь с указанным id не найдена",
+                    MessageValidationError: "Неправильный формат данных",
+                }
+            )
+        ]
+    )
     exception_handler_chain_executor = ExceptionHandlersChainExecutor(
         _EXCEPTIONS_HANDLERS
     )
@@ -162,7 +172,7 @@ def __init__(
 
     async def handle_logic(
         self,
-        request_parameter: SampleRecordGetOrDeleteRequestSchema,
+        request_parameter: SampleRecordGetOrDeleteRequestSchema,  # type: ignore
     ) -> None:
         async with self.unit_of_work as uof:
             record = await self._use_cases(
diff --git a/app/presentation/bot/error_handlers/base_handlers.py b/app/presentation/bot/error_handlers/base_handlers.py
@@ -67,10 +67,11 @@ async def handle_exception(
                     await self.next_handler.handle_exception(
                         exc, bot, message, exception_id
                     )
-            except Exception as exc:
+            except Exception as inner_exc:
                 logger.error(
                     f"Error handling exception {exception_id}",
                     exc_info=True,
+                    exc=inner_exc,
                 )
                 if self._stop_on_failure:
                     return
diff --git a/app/presentation/bot/error_handlers/exceptions_chain_executor.py b/app/presentation/bot/error_handlers/exceptions_chain_executor.py
@@ -1,3 +1,4 @@
+from abc import ABCMeta
 from uuid import uuid4
 
 from pybotx import Bot, IncomingMessage
@@ -9,6 +10,10 @@
     SendErrorExplainToUserHandler,
 )
 
+HandlerOrHandlerClass = (
+    AbstractExceptionHandler | type[AbstractExceptionHandler] | ABCMeta
+)
+
 
 class ExceptionHandlersChainExecutor:
     """
@@ -24,7 +29,8 @@ class ExceptionHandlersChainExecutor:
     """
 
     def __init__(
-        self, handlers: list[type[AbstractExceptionHandler] | AbstractExceptionHandler]
+        self,
+        handlers: list[HandlerOrHandlerClass] | None = None,
     ):
         self._chain_head, self._chain_tail = self._create_chain(handlers)
 
@@ -52,13 +58,26 @@ async def execute_chain(
         await self._chain_head.handle_exception(exc, bot, message, exception_id)
 
     def _get_handler(
-        self, handler: AbstractExceptionHandler | type[AbstractExceptionHandler]
+        self,
+        handler: HandlerOrHandlerClass,
     ) -> AbstractExceptionHandler:
         return handler if isinstance(handler, AbstractExceptionHandler) else handler()
 
     def _create_chain(
-        self, handlers: list[type[AbstractExceptionHandler] | AbstractExceptionHandler]
+        self,
+        handlers: list[HandlerOrHandlerClass] | None = None,
     ) -> tuple[AbstractExceptionHandler | None, AbstractExceptionHandler | None]:
+        """
+        Create a linked list of exception handlers from the given list.
+
+        This method takes a sequence of exception handler classes or instances
+        and chains them together into a linked list. The returned tuple contains
+        the head and tail of the constructed chain.
+
+        warning:
+           This method modifies the passed objects of
+           class:`AbstractExceptionHandler` type in place.
+        """
         if not handlers:
             return None, None
 
@@ -71,29 +90,39 @@ def _create_chain(
             tail_handler = new_tail_handler
         return head_handler, tail_handler
 
-    def extend(
-        self, handlers: list[AbstractExceptionHandler | type[AbstractExceptionHandler]]
-    ):
+    def extend(self, handlers: list[HandlerOrHandlerClass] | None) -> None:
         """Append handlers to the chain"""
+        if not handlers:
+            return
+
         new_head, new_tail = self._create_chain(handlers)
-        if self._chain_head is None:
+        if self._is_empty():
             self._chain_head = new_head
         else:
-            self._chain_tail.next_handler = new_head
+            # The tail and head cannot be None at the same time.
+            self._chain_tail.next_handler = new_head  # type: ignore
 
         self._chain_tail = new_tail
 
-    def append(
-        self, handler: AbstractExceptionHandler | type[AbstractExceptionHandler]
-    ):
-        """Append handler to the end of chain"""
+    def append(self, handler: HandlerOrHandlerClass) -> None:
+        """Append handler to the end of a chain"""
         new_tail = self._get_handler(handler)
-        self._chain_tail.next_handler = new_tail
 
+        if self._is_empty():
+            self._chain_head = new_tail
+            self._chain_tail = new_tail
+        else:
+            self._chain_tail.next_handler = new_tail  # type:ignore
+
+    def _is_empty(self) -> bool:
+        return self._chain_head is None and self._chain_tail is None
 
-DEFAULT_HANDLERS = [
+
+DEFAULT_HANDLERS: list[HandlerOrHandlerClass] = [
     LoggingExceptionHandler,
     DropFSMOnErrorHandler,
 ]
 
-DEFAULT_HANDLERS_WITH_EXPLAIN = DEFAULT_HANDLERS + [SendErrorExplainToUserHandler]
+DEFAULT_HANDLERS_WITH_EXPLAIN: list[HandlerOrHandlerClass] = DEFAULT_HANDLERS + [
+    SendErrorExplainToUserHandler
+]
diff --git a/pyproject.toml b/pyproject.toml
@@ -64,6 +64,9 @@ deepdiff = "^8.5.0"
 
 
 
+[tool.poetry.group.dev.dependencies]
+types-psycopg2 = "^2.9.21.20250718"
+
 [build-system]
 requires = ["poetry>=1.1.12"]
 build-backend = "poetry.masonry.api"
diff --git a/tests/integration/bot_commands/bot_factories.py b/tests/integration/bot_commands/bot_factories.py
@@ -71,14 +71,14 @@ class Meta:
 class IncomingMessageFactory(Factory):
     """Factory for incoming messages."""
 
-    bot: BotAccount = factory.SubFactory(BotAccountFactory)
-    sync_id: UUID = factory.Faker("uuid4")
+    bot: BotAccount = factory.SubFactory(BotAccountFactory)  # type: ignore
+    sync_id: UUID = factory.Faker("uuid4")  # type: ignore
     source_sync_id: Optional[UUID] = None
-    body: str = factory.Faker("text", max_nb_chars=100)
+    body: str = factory.Faker("text", max_nb_chars=100)  # type: ignore
     data: dict[str, Any] = {}
     metadata: dict = {}
-    sender: UserSender = factory.SubFactory(UserSenderFactory)
-    chat: Chat = factory.SubFactory(ChatFactory)
+    sender: UserSender = factory.SubFactory(UserSenderFactory)  # type: ignore
+    chat: Chat = factory.SubFactory(ChatFactory)  # type: ignore
     raw_command: Optional[str] = None
 
     class Meta:
diff --git a/tests/integration/bot_commands/test_sample_record.py b/tests/integration/bot_commands/test_sample_record.py
diff --git a/tests/integration/repository/test_sample_record_repository.py b/tests/integration/repository/test_sample_record_repository.py
diff --git a/tests/unit/error_handlers/test_chain_executor.py b/tests/unit/error_handlers/test_chain_executor.py

Original file line number	Diff line number	Diff line change
`@@ -67,10 +67,11 @@ async def handle_exception(`
`67`	`67`	`await self.next_handler.handle_exception(`
`68`	`68`	`exc, bot, message, exception_id`
`69`	`69`	`)`
`70`		`- except Exception as exc:`
	`70`	`+ except Exception as inner_exc:`
`71`	`71`	`logger.error(`
`72`	`72`	`f"Error handling exception {exception_id}",`
`73`	`73`	`exc_info=True,`
	`74`	`+ exc=inner_exc,`
`74`	`75`	`)`
`75`	`76`	`if self._stop_on_failure:`
`76`	`77`	`return`