fix(infrastructure): fix linter errors

Author: emptybutton

pyproject.toml

@@ -48,6 +48,10 @@ strict = true
 no_namespace_packages = true
 allow_redefinition = true
 
+[[tool.mypy.overrides]]
+module = ["telethon.*"]
+follow_untyped_imports = true
+
 [tool.ruff]
 src = ["src"]
 preview = true

src/tgdb/infrastructure/adapters/heap.py

@@ -115,7 +115,7 @@ async def _insert(self, new_row: NewRow, is_duplicate: bool) -> None:
         tg_new_message = await self._pool_to_insert().send_message(
             self._heap_id, encoded_heap_row(new_row.row)
         )
-        self._message_map[new_row.row.id] = message(tg_new_message)
+        self._message_map[new_row.row.id] = message(tg_new_message)  # type: ignore[arg-type]
 
     async def _update(self, mutated_row: MutatedRow) -> None:
         message = await self._message(mutated_row)

src/tgdb/infrastructure/async_queque.py

@@ -1,12 +1,11 @@
 from asyncio import Event
 from collections import deque
-from collections.abc import AsyncIterator, Iterator, Sequence
+from collections.abc import AsyncIterator, Iterator
 from dataclasses import dataclass, field
-from typing import Any, overload
 
 
 @dataclass(frozen=True, unsafe_hash=False)
-class AsyncQueque[ValueT](Sequence[ValueT]):
+class AsyncQueque[ValueT]:
     _values: deque[ValueT] = field(default_factory=deque)
     _is_synced: Event = field(default_factory=Event, init=False)
     _offset_by_iteration_event: dict[Event, int] = field(
@@ -26,18 +25,8 @@ def __bool__(self) -> bool:
     def __iter__(self) -> Iterator[ValueT]:
         return iter(self._values)
 
-    @overload
-    def __getitem__(self, index: int, /) -> ValueT: ...
-
-    @overload
-    def __getitem__(
-        self, slice_: "slice[Any, Any, Any]", /
-    ) -> Sequence[ValueT]: ...
-
-    def __getitem__(
-        self, value: "int | slice[Any, Any, Any]", /
-    ) -> Sequence[ValueT] | ValueT:
-        return self._values[value]
+    def __getitem__(self, index: int, /) -> ValueT:
+        return self._values[index]
 
     def push(self, value: ValueT) -> None:
         self._values.append(value)
@@ -87,9 +76,7 @@ async def _iteration(self, is_active: Event) -> AsyncIterator[ValueT]:
                 self._is_synced.set()
 
     def _refresh(self) -> None:
-        min_offset = min(
-            self._offset_by_iteration_event.values(), default=-1
-        )
+        min_offset = min(self._offset_by_iteration_event.values(), default=-1)
 
         if min_offset >= 0:
             self._values.popleft()

src/tgdb/infrastructure/primitive_encoding.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import cast
 from urllib import parse
 from uuid import UUID
 
@@ -67,4 +68,4 @@ def decoded_primitive[PrimitiveT: Primitive](
 ) -> PrimitiveT:
     decoded = _decoding_by_type[type_]
 
-    return decoded(encoded_value)
+    return cast(PrimitiveT, decoded(encoded_value))

src/tgdb/infrastructure/telegram_secrets.py

@@ -7,7 +7,6 @@
 class TelegramSecrets:
     app_api_id: int
     app_api_hash: str
-    bot_token: str
 
     @classmethod
     def load(cls, secrets_file_path: Path) -> "TelegramSecrets":
@@ -17,5 +16,4 @@ def load(cls, secrets_file_path: Path) -> "TelegramSecrets":
             return TelegramSecrets(
                 app_api_id=raw_secrets["app_api_id"],
                 app_api_hash=raw_secrets["app_api_hash"],
-                bot_token=raw_secrets["bot_token"],
             )

src/tgdb/infrastructure/telethon/chat_id_range.py

@@ -1,38 +1,51 @@
+from asyncio import gather
 from collections import deque
-from collections.abc import Iterator, Sequence
+from collections.abc import Iterator
 from contextlib import AbstractAsyncContextManager
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from pathlib import Path
 from types import TracebackType
-from typing import Self
+from typing import Self, cast
 
 from telethon import TelegramClient
+from telethon.sessions.string import StringSession
+from telethon.types import InputPeerUser
 
 
-@dataclass(init=False)
+@dataclass(frozen=True, unsafe_hash=False)
 class TelegramClientPool(AbstractAsyncContextManager["TelegramClientPool"]):
     _clients: deque[TelegramClient]
-    _client_by_id: dict[int, TelegramClient]
 
-    def __init__(self, clients: Sequence[TelegramClient]) -> None:
-        self._clients = deque(clients, len(clients))
-        self._client_by_id = dict()
+    _client_by_id: dict[int, TelegramClient] = field(
+        init=False, default_factory=dict
+    )
 
     async def __aenter__(self) -> Self:
         for client in self._clients:
-            client_info = await client.get_me(input_peer=True)
+            client_info = (
+                cast(InputPeerUser, await client.get_me(input_peer=True))
+            )
             client_id = client_info.user_id
 
             self._client_by_id[client_id] = client
 
+        await gather(*(
+            client.__aenter__()  # type: ignore[no-untyped-call]
+            for client in self._clients
+        ))
+
         return self
 
     async def __aexit__(
         self,
-        _: type[BaseException] | None,
-        __: BaseException | None,
-        ___: TracebackType | None,
+        error_type: type[BaseException] | None,
+        error: BaseException | None,
+        traceback: TracebackType | None,
     ) -> None:
-        return
+        await gather(*(
+            client.__aexit__(error_type, error, traceback)  # type: ignore[no-untyped-call]
+            for client in self._clients
+        ))
 
     def __call__(self, client_id: int | None = None) -> TelegramClient:
         if client_id is None:
@@ -51,3 +64,16 @@ def __call__(self, client_id: int | None = None) -> TelegramClient:
     def __iter__(self) -> Iterator[TelegramClient]:
         while True:
             yield self()
+
+
+def loaded_client_pool_from_farm_file(
+    farm_file_path: Path, app_api_id: int, app_api_hash: str
+) -> TelegramClientPool:
+    with farm_file_path.open() as farm_file:
+        return TelegramClientPool(deque(
+            TelegramClient(
+                StringSession(session_token), app_api_id, app_api_hash
+            )
+            for session_token in farm_file
+            if session_token
+        ))

src/tgdb/infrastructure/telethon/client_pool.py

@@ -5,7 +5,7 @@
 from types import TracebackType
 from typing import Any, Self, cast
 
-from telethon.types import Message
+from telethon.hints import TotalList
 
 from tgdb.infrastructure.telethon.client_pool import TelegramClientPool
 from tgdb.infrastructure.telethon.vacuum import AutoVacuum
@@ -19,7 +19,7 @@ class InTelegramBigText(Awaitable[str | None]):
     _auto_vacuum: AutoVacuum
 
     _tasks: TaskGroup = field(init=False, default_factory=TaskGroup)
-    _cached_value: str | None = field(init=False, default=None)
+    _cached_stored_text: str | None = field(init=False, default=None)
 
     async def __aenter__(self) -> Self:
         await self._tasks.__aenter__()
@@ -46,28 +46,30 @@ async def set(self, text: str) -> None:
         )
 
         self._auto_vacuum.update_horizon(last_message.id)
+        self._cached_stored_text = text
 
     async def _get(self) -> str | None:
-        if self._cached_value is not None:
-            return self._cached_value
+        if self._cached_stored_text is not None:
+            return self._cached_stored_text
 
         await self._refresh()
 
-        return self._cached_value
+        return self._cached_stored_text
 
     async def _refresh(self) -> None:
         messages = await self._pool_to_select().get_messages(
             self._chat_id, limit=1
         )
+        messages = cast(TotalList, messages)
 
         if not messages:
             return
 
-        last_message = cast(Message, messages[-1])
+        last_message = messages[-1]
 
         with BytesIO() as stream:
             await self._pool_to_select().download_file(last_message, stream)
             encoded_text = stream.getvalue()
 
         self._auto_vacuum.update_horizon(last_message.id)
-        self._cached_value = encoded_text.decode()
+        self._cached_stored_text = encoded_text.decode()

src/tgdb/infrastructure/telethon/in_telegram_big_text.py

@@ -4,7 +4,7 @@
 from types import TracebackType
 from typing import Any, Self, cast
 
-from telethon.types import Message
+from telethon.hints import TotalList
 
 from tgdb.infrastructure.primitive_encoding import (
     Primitive,
@@ -64,11 +64,12 @@ async def _refresh(self) -> None:
         client = self._pool_to_select()
 
         messages = await client.get_messages(self._chat_id, limit=1)
+        messages = cast(TotalList, messages)
 
         if not messages:
             return
 
-        last_message = cast(Message, messages[-1])
+        last_message = messages[-1]
 
         self._auto_vacuum.update_horizon(last_message.id)
         self._cached_value = decoded_primitive(

src/tgdb/infrastructure/telethon/in_telegram_primitive.py

@@ -1,9 +1,12 @@
-from telethon.types import Message as TelethonMessage
+from telethon.tl.custom.message import Message as TelethonMessage
+from telethon.tl.types import PeerUser
 
 from tgdb.entities.message import Message
 
 
 def message(telethon_message: TelethonMessage) -> Message:
+    assert isinstance(telethon_message.from_id, PeerUser)
+
     return Message(
         id=telethon_message.id,
         author_id=telethon_message.from_id.user_id,