fix: fix linter errors

Author: emptybutton

pyproject.toml

@@ -76,6 +76,7 @@ lines-after-imports = 2
 "src/tgdb/entities/*" = ["PLR2004"]
 "src/tgdb/application/*" = ["PLR0917"]
 "src/tgdb/infrastructure/adapters/*" = ["RUF029"]
+"src/tgdb/infrastructure/*" = ["S403", "S301"]
 "tests/*" = ["PLR0124", "PLR0917", "S106", "C901", "PLR2004"]
 "__init__.py" = ["PLC0414"]
 

src/tgdb/entities/horizon/horizon.py

@@ -140,7 +140,7 @@ def commit_transaction(
         self,
         time: LogicTime,
         xid: XID,
-        effects: Sequence[HorizonWriteEffect] | None,
+        effects: Sequence[HorizonWriteEffect],
     ) -> Commit | PreparedCommit:
         """
         :raises tgdb.entities.horizon.horizon.NotMonotonicTimeError:

src/tgdb/entities/relation/tuple.py

@@ -37,7 +37,9 @@ def matches(self, schema: Schema) -> bool:
     def __getitem__(self, index: int, /) -> Scalar: ...
 
     @overload
-    def __getitem__(self, sclice: "slice[Any, Any, Any]", /) -> Sequence[Scalar]:
+    def __getitem__(
+        self, sclice: "slice[Any, Any, Any]", /
+    ) -> Sequence[Scalar]:
         ...
 
     def __getitem__(

src/tgdb/infrastructure/adapters/tuples.py

@@ -18,10 +18,7 @@
     MutatedTuple,
     NewTuple,
 )
-from tgdb.infrastructure.heap_tuple_encoding import HeapTupleEncoding
-from tgdb.infrastructure.telethon.client_pool import TelegramClientPool
 from tgdb.infrastructure.telethon.in_telegram_heap import InTelegramHeap
-from tgdb.infrastructure.telethon.lazy_message_map import LazyMessageMap
 
 
 @dataclass(frozen=True, unsafe_hash=False)
@@ -97,7 +94,9 @@ async def tuples_with_attribute(
         attribute_number: Number,
         attribute_scalar: Scalar,
     ) -> Sequence[Tuple]:
-        
+        return await self._heap.tuples_with_attribute(
+            relation_number, attribute_number, attribute_scalar
+        )
 
     async def map(
         self, transaction_effects: Sequence[TransactionEffect]

src/tgdb/infrastructure/heap_tuple_encoding.py

@@ -16,8 +16,9 @@
 
 
 class Separator(Enum):
-    first_level = "\uffff"
-    second_level = "\ufffe"
+    top_tuple = "\uffff"
+    top_metadata = "\ufffe"
+    top_attribute = "\ufffd"
 
 
 heap_tuple_table = ReversibleTranslationTable({
@@ -28,32 +29,35 @@ class Separator(Enum):
 class HeapTupleEncoding:
     @staticmethod
     def encoded_tuple(tuple_: Tuple) -> str:
-        encoded_metadata = HeapTupleMetadataEncoding.encoded_metadata(tuple_)
+        encoded_metadata = _HeapTupleMetadataEncoding.encoded_metadata(
+            int(tuple_.relation_version_id.relation_version_number),
+            int(tuple_.relation_version_id.relation_number),
+            tuple_.tid,
+        )
         encoded_attributes = (
-            HeapTupleAttributeEncoding.encoded_attribute(
+            _HeapTupleAttributeEncoding.encoded_attribute(
                 int(tuple_.relation_version_id.relation_number),
                 attribute_number,
                 tuple_[attribute_number],
             )
             for attribute_number in range(len(tuple_))
         )
 
-        encoded_tuple_without_end = Separator.first_level.value.join(
+        return Separator.top_tuple.value.join(
             (encoded_metadata, *encoded_attributes)
         )
-        return f"{encoded_tuple_without_end}{Separator.first_level.value}"
 
     @staticmethod
     def decoded_tuple(encoded_tuple: str) -> Tuple:
         encoded_metadata, *encoded_attributes = (
-            encoded_tuple.split(Separator.first_level.value)
+            encoded_tuple.split(Separator.top_tuple.value)
         )
 
-        tid, relation_version_id = HeapTupleMetadataEncoding.decoded_metadata(
+        tid, relation_version_id = _HeapTupleMetadataEncoding.decoded_metadata(
             encoded_metadata
         )
         scalars = tuple(map(
-            HeapTupleAttributeEncoding.decoded_scalar, encoded_attributes
+            _HeapTupleAttributeEncoding.decoded_scalar, encoded_attributes
         ))
 
         return Tuple(tid, relation_version_id, scalars)
@@ -64,35 +68,35 @@ def id_of_encoded_tuple_with_attribute(
         attribute_number: int,
         attribute_scalar: Scalar,
     ) -> str:
-        encoded_attribute = HeapTupleAttributeEncoding.encoded_attribute(
+        return _HeapTupleAttributeEncoding.encoded_attribute(
             relation_number,
             attribute_number,
             attribute_scalar
         )
 
-        return (
-            f"{Separator.first_level.value}"
-            f"{encoded_attribute}"
-            f"{Separator.first_level.value}"
-        )
+    @staticmethod
+    def id_of_encoded_tuple_with_tid(tid: TID) -> str:
+        return _HeapTupleMetadataEncoding.id_of_encoded_tuple_with_tid(tid)
 
 
-type HeapTupleMetadata = tuple[TID, RelationVersionID]
+type _HeapTupleMetadata = tuple[TID, RelationVersionID]
 
 
-class HeapTupleMetadataEncoding:
+class _HeapTupleMetadataEncoding:
     @staticmethod
-    def encoded_metadata(tuple: Tuple) -> str:
-        return Separator.second_level.value.join((
-            encoded_int(int(tuple.relation_version_id.relation_version_number)),
-            encoded_int(int(tuple.relation_version_id.relation_number)),
-            encoded_uuid(tuple.tid),
+    def encoded_metadata(
+        relation_number: int, relation_version_number: int, tid: TID
+    ) -> str:
+        return Separator.top_metadata.value.join((
+            encoded_int(relation_version_number),
+            encoded_int(relation_number),
+            encoded_uuid(tid),
         ))
 
     @staticmethod
-    def decoded_metadata(encoded_metadata: str) -> HeapTupleMetadata:
+    def decoded_metadata(encoded_metadata: str) -> _HeapTupleMetadata:
         encoded_version_number, encoded_relation_number, encoded_tid = (
-            encoded_metadata.split(Separator.second_level.value)
+            encoded_metadata.split(Separator.top_metadata.value)
         )
 
         relation_version_number = (Number(decoded_int(encoded_version_number)))
@@ -103,15 +107,19 @@ def decoded_metadata(encoded_metadata: str) -> HeapTupleMetadata:
 
         return tid, version_id
 
+    @staticmethod
+    def id_of_encoded_tuple_with_tid(tid: TID) -> str:
+        return f"{Separator.top_metadata.value}{encoded_uuid(tid)}"
+
 
-class HeapTupleAttributeEncoding:
+class _HeapTupleAttributeEncoding:
     @staticmethod
     def encoded_attribute(
         relation_number: int,
         attribute_number: int,
         scalar: Scalar,
     ) -> str:
-        return Separator.second_level.value.join((
+        return Separator.top_attribute.value.join((
             encoded_int(relation_number),
             encoded_int(attribute_number),
             encoded_primitive_with_type(scalar, heap_tuple_table),
@@ -120,7 +128,7 @@ def encoded_attribute(
     @staticmethod
     def decoded_scalar(encoded_attribute: str) -> Scalar:
         _, _, encoded_scalar = encoded_attribute.split(
-            Separator.second_level.value
+            Separator.top_attribute.value
         )
 
         return decoded_primitive_with_type(encoded_scalar, heap_tuple_table)

src/tgdb/infrastructure/lazy_map.py

@@ -7,7 +7,7 @@
 @dataclass(frozen=True, unsafe_hash=False)
 class LazyMap[KeyT, ValueT]:
     _computed_map_max_len: int
-    value_by_key: Callable[[KeyT], Awaitable[ValueT | None]]
+    _external_value: Callable[[KeyT], Awaitable[ValueT | None]]
     _computed_map: OrderedDict[KeyT, ValueT] = field(
         init=False, default_factory=OrderedDict
     )
@@ -16,7 +16,7 @@ async def __getitem__(self, key: KeyT) -> ValueT | None:
         with suppress(KeyError):
             return self._computed_map[key]
 
-        value = await self.value_by_key(key)
+        value = await self._external_value(key)
 
         if value is None:
             return None

src/tgdb/infrastructure/primitive_encoding.py

@@ -1,7 +1,7 @@
-from collections.abc import Callable, Iterable, Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import cast
+from typing import Any, cast
 from uuid import UUID
 
 
@@ -127,7 +127,7 @@ def decoded_none(encoded_value: str) -> None:
         raise ValueError(encoded_value)
 
 
-_decoded_body_func_by_type = {
+_decoded_body_func_by_type: dict[type[Any], Callable[[str], Primitive]] = {
     bool: decoded_bool,
     int: decoded_int,
     str: decoded_str,

src/tgdb/infrastructure/telethon/in_telegram_heap.py

@@ -56,7 +56,7 @@ async def insert_idempotently(self, tuple: Tuple) -> None:
 
     async def insert(self, tuple: Tuple) -> None:
         new_message = await self._pool_to_insert().send_message(
-            self._heap_id, HeapTupleEncoding.encoded_tuple(tuple.tuple)
+            self._heap_id, HeapTupleEncoding.encoded_tuple(tuple)
         )
         self._message_map[tuple.tid] = new_message
 
@@ -66,7 +66,7 @@ async def update(self, tuple: Tuple) -> None:
         if message is None:
             return
 
-        await self._pool_to_edit(message.sender_id).edit_message(
+        await self._pool_to_edit(message.sender_id).edit_message(  # type: ignore[attr-defined]
             self._heap_id, message.id, HeapTupleEncoding.encoded_tuple(tuple)
         )
 

src/tgdb/infrastructure/telethon/lazy_message_map.py

@@ -4,6 +4,7 @@
 from telethon.tl.types import Message
 
 from tgdb.entities.relation.tuple import TID
+from tgdb.infrastructure.heap_tuple_encoding import HeapTupleEncoding
 from tgdb.infrastructure.lazy_map import LazyMap
 from tgdb.infrastructure.telethon.client_pool import TelegramClientPool
 
@@ -14,16 +15,16 @@
 def lazy_message_map(
     chat_id: int, pool: TelegramClientPool, computed_map_max_len: int
 ) -> LazyMessageMap:
-    async def message_of_row(tid: TID) -> Message | None:
-        query = row_with_id_query(tid)
+    async def tuple_message(tid: TID) -> Message | None:
+        search = HeapTupleEncoding.id_of_encoded_tuple_with_tid(tid)
 
         messages = cast(TotalList, await pool().get_messages(
-            chat_id, search=query, limit=1
+            chat_id, search=search, limit=1
         ))
 
         if not messages:
             return None
 
-        return messages[0]
+        return cast(Message | None, messages[0])
 
-    return LazyMap(computed_map_max_len, message_of_row)
+    return LazyMap(computed_map_max_len, tuple_message)