chore(telethon): cache indexes, not their messages

Author: emptybutton

src/tgdb/infrastructure/telethon/in_telegram_heap.py

@@ -10,8 +10,13 @@
 from tgdb.entities.relation.tuple import TID, Tuple
 from tgdb.entities.tools.assert_ import assert_
 from tgdb.infrastructure.heap_tuple_encoding import HeapTupleEncoding
+from tgdb.infrastructure.lazy_map import LazyMap
 from tgdb.infrastructure.telethon.client_pool import TelegramClientPool
-from tgdb.infrastructure.telethon.lazy_message_map import LazyMessageMap
+from tgdb.infrastructure.telethon.index import (
+    MessageIndex,
+    TupleIndex,
+    message_index,
+)
 
 
 @dataclass(frozen=True)
@@ -27,7 +32,7 @@ class InTelegramHeap:
     _pool_to_delete: TelegramClientPool
     _heap_id: int
     _encoded_tuple_max_len: int
-    _message_map: LazyMessageMap
+    _index_map: LazyMap[TupleIndex, MessageIndex | None]
 
     _page_len: ClassVar = 4000
 
@@ -93,38 +98,42 @@ async def tuples_with_attribute(
         )
 
     async def insert_idempotently(self, tuple: Tuple) -> None:
-        message_ = await self._message_map[self._heap_id, tuple.tid]
+        message_index_ = await self._index_map[self._heap_id, tuple.tid]
 
-        if message_ is not None:
+        if message_index_ is not None:
             return
 
         new_message = await self._pool_to_insert().send_message(
             self._heap_id, HeapTupleEncoding.encoded_tuple(tuple)
         )
-        self._message_map[self._heap_id, tuple.tid] = new_message
+        self._index_map[self._heap_id, tuple.tid] = message_index(new_message)
 
     async def insert(self, tuple: Tuple) -> None:
         new_message = await self._pool_to_insert().send_message(
             self._heap_id, HeapTupleEncoding.encoded_tuple(tuple)
         )
-        self._message_map[self._heap_id, tuple.tid] = new_message
+        self._index_map[self._heap_id, tuple.tid] = message_index(new_message)
 
     async def update(self, tuple: Tuple) -> None:
-        message = await self._message_map[self._heap_id, tuple.tid]
+        message_index = await self._index_map[self._heap_id, tuple.tid]
 
-        if message is None:
+        if message_index is None:
             return
 
-        await self._pool_to_edit(message.sender_id).edit_message(  # type: ignore[attr-defined]
-            self._heap_id, message.id, HeapTupleEncoding.encoded_tuple(tuple)
+        message_id, sender_id = message_index
+
+        await self._pool_to_edit(sender_id).edit_message(
+            self._heap_id, message_id, HeapTupleEncoding.encoded_tuple(tuple)
         )
 
     async def delete_tuple_with_tid(self, tid: TID) -> None:
-        message = await self._message_map[self._heap_id, tid]
+        message_index = await self._index_map[self._heap_id, tid]
 
-        if message is None:
+        if message_index is None:
             return
 
+        message_id, _ = message_index
+
         await self._pool_to_delete().delete_messages(
-            self._heap_id, [message.id]
+            self._heap_id, [message_id]
         )

src/tgdb/infrastructure/telethon/index.py

@@ -0,0 +1,15 @@
+from telethon.tl.types import Message
+
+from tgdb.entities.relation.tuple import TID
+
+
+type MessageID = int
+type SenderID = int
+type ChatID = int
+
+type MessageIndex = tuple[MessageID, SenderID]
+type TupleIndex = tuple[ChatID, TID]
+
+
+def message_index(message: Message) -> MessageIndex:
+    return message.id, message.sender_id  # type: ignore[attr-defined]

…rastructure/telethon/lazy_message_map.py …tgdb/infrastructure/telethon/lazy_map.pysrc/tgdb/infrastructure/telethon/lazy_message_map.py renamed to src/tgdb/infrastructure/telethon/lazy_map.py src/tgdb/infrastructure/telethon/lazy_message_map.py renamed to src/tgdb/infrastructure/telethon/lazy_map.py

@@ -7,29 +7,31 @@
 from tgdb.infrastructure.heap_tuple_encoding import HeapTupleEncoding
 from tgdb.infrastructure.lazy_map import ExternalValue, LazyMap, NoExternalValue
 from tgdb.infrastructure.telethon.client_pool import TelegramClientPool
+from tgdb.infrastructure.telethon.index import (
+    MessageIndex,
+    TupleIndex,
+    message_index,
+)
 
 
-type ChatID = int
-type LazyMessageMap = LazyMap[tuple[ChatID, TID], Message]
+type MessageIndexLazyMap = LazyMap[TupleIndex, MessageIndex | None]
 
 
-def lazy_message_map(
+def message_index_lazy_map(
     pool: TelegramClientPool, cache_map_max_len: int
-) -> LazyMessageMap:
-    async def tuple_message(
-        chat_id_and_tid: tuple[ChatID, TID]
-    ) -> ExternalValue[Message]:
-        chat_id, tid = chat_id_and_tid
+) -> LazyMap[TupleIndex, MessageIndex | None]:
+    async def tuple_message(tuple_index: TupleIndex) -> MessageIndex | None:
+        chat_id, tid = tuple_index
 
         search = HeapTupleEncoding.id_of_encoded_tuple_with_tid(tid)
-
         messages = cast(TotalList, await pool().get_messages(
             chat_id, search=search, limit=1
         ))
 
         if not messages:
-            return NoExternalValue()
+            return None
 
-        return cast(Message, messages[0])
+        message = cast(Message, messages[0])
+        return message_index(message)
 
     return LazyMap(cache_map_max_len, tuple_message)

src/tgdb/main/common/di.py

@@ -45,9 +45,9 @@
 )
 from tgdb.infrastructure.telethon.in_telegram_bytes import InTelegramBytes
 from tgdb.infrastructure.telethon.in_telegram_heap import InTelegramHeap
-from tgdb.infrastructure.telethon.lazy_message_map import (
-    LazyMessageMap,
-    lazy_message_map,
+from tgdb.infrastructure.telethon.lazy_map import (
+    MessageIndexLazyMap,
+    message_index_lazy_map,
 )
 from tgdb.infrastructure.typenv.envs import Envs
 
@@ -119,16 +119,16 @@ def provide_lazy_message_map(
         self,
         user_bot_pool: UserBotPool,
         conf: Conf,
-    ) -> LazyMessageMap:
-        return lazy_message_map(user_bot_pool, conf.message_cache.max_len)
+    ) -> MessageIndexLazyMap:
+        return message_index_lazy_map(user_bot_pool, conf.message_cache.max_len)
 
     @provide(scope=Scope.APP)
     def provide_in_telegram_heap(
         self,
         bot_pool: BotPool,
         user_bot_pool: UserBotPool,
         conf: Conf,
-        lazy_message_map: LazyMessageMap,
+        message_index_lazy_map: MessageIndexLazyMap,
     ) -> InTelegramHeap:
         return InTelegramHeap(
             bot_pool,
@@ -137,7 +137,7 @@ def provide_in_telegram_heap(
             bot_pool,
             conf.heap.chat,
             InTelegramHeap.encoded_tuple_max_len(conf.heap.page.fullness),
-            lazy_message_map,
+            message_index_lazy_map,
         )
 
     provide_tuples = provide(

src/tgdb/presentation/fastapi/common/app.py

@@ -7,6 +7,7 @@
 from dishka.integrations.fastapi import setup_dishka
 from fastapi import APIRouter, FastAPI
 
+from tgdb.presentation.fastapi.common.error_handling import add_error_handling
 from tgdb.presentation.fastapi.common.tags import tags_metadata
 
 
@@ -57,5 +58,6 @@ async def app_from(container: AsyncContainer) -> FastAPI:
         app.include_router(router)
 
     setup_dishka(container=container, app=app)
+    add_error_handling(app)
 
     return app