feat(infrastructure): add all adapters

Author: emptybutton

src/tgdb/application/common/ports/tuples.py

@@ -14,6 +14,7 @@ async def tuples_with_attribute(
         relation_number: Number,
         attribute_number: Number,
         attribute_scalar: Scalar,
+        /,
     ) -> Sequence[Tuple]: ...
 
     @abstractmethod

src/tgdb/entities/relation/tuple.py

@@ -1,5 +1,6 @@
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from dataclasses import dataclass
+from typing import Any, overload
 from uuid import UUID
 
 from tgdb.entities.numeration.number import Number
@@ -12,7 +13,7 @@
 
 
 @dataclass(frozen=True)
-class Tuple:
+class Tuple(Sequence[Scalar]):
     tid: TID
     relation_version_id: RelationVersionID
     scalars: tuple[Scalar, ...]
@@ -32,6 +33,18 @@ def matches(self, schema: Schema) -> bool:
             for scalar, domain in zip(self, schema, strict=True)
         )
 
+    @overload
+    def __getitem__(self, index: int, /) -> Scalar: ...
+
+    @overload
+    def __getitem__(self, sclice: "slice[Any, Any, Any]", /) -> Sequence[Scalar]:
+        ...
+
+    def __getitem__(
+        self, key: "int | slice[Any, Any, Any]", /
+    ) -> Scalar | Sequence[Scalar]:
+        return self.scalars[key]
+
 
 def tuple_(
     *scalars: Scalar,

src/tgdb/infrastructure/adapters/buffer.py

@@ -1,3 +1,4 @@
+import pickle
 from asyncio import Event, wait_for
 from collections import deque
 from collections.abc import AsyncIterator, Sequence
@@ -8,10 +9,7 @@
 
 from tgdb.application.common.ports.buffer import Buffer
 from tgdb.entities.horizon.transaction import PreparedCommit
-from tgdb.infrastructure.pydantic.commit_encoding import (
-    PreparedCommitListSchema,
-)
-from tgdb.infrastructure.telethon.in_telegram_big_text import InTelegramBigText
+from tgdb.infrastructure.telethon.in_telegram_bytes import InTelegramBytes
 
 
 @dataclass(frozen=True, unsafe_hash=False)
@@ -49,18 +47,23 @@ def _refresh_overflow(self) -> None:
 @dataclass(frozen=True)
 class InTelegramReplicablePreparedCommitBuffer(Buffer[PreparedCommit]):
     _buffer: Buffer[PreparedCommit]
-    _in_tg_encoded_commits: InTelegramBigText
+    _in_tg_encoded_commits: InTelegramBytes
 
     async def __aenter__(self) -> Self:
         encoded_commits = await self._in_tg_encoded_commits
 
         if encoded_commits is None:
             return self
 
-        commit_list_schema = (
-            PreparedCommitListSchema.model_validate_json(encoded_commits)
-        )
-        for commit in commit_list_schema.commits:
+        commits = pickle.loads(encoded_commits)
+
+        if not isinstance(commits, list):
+            raise TypeError(str(commits))
+
+        for commit in commits:
+            if not isinstance(commit, PreparedCommit):
+                raise TypeError(str(commits))
+
             await self._buffer.add(commit)
 
         return self
@@ -77,9 +80,7 @@ async def add(self, commit: PreparedCommit, /) -> None:
 
     async def __aiter__(self) -> AsyncIterator[Sequence[PreparedCommit]]:
         async for commits in self._buffer:
-            commit_list_schema = PreparedCommitListSchema(commits=commits)
-            encoded_encoded_commits = commit_list_schema.model_dump_json()
-
-            await self._in_tg_encoded_commits.set(encoded_encoded_commits)
+            encoded_commits = pickle.dumps(list(commits))
+            await self._in_tg_encoded_commits.set(encoded_commits)
 
             yield commits

src/tgdb/infrastructure/adapters/relations.py

@@ -1,5 +1,7 @@
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
+import pickle
+from dataclasses import dataclass, field
+from types import TracebackType
+from typing import Self, cast
 
 from in_memory_db import InMemoryDb
 
@@ -10,6 +12,7 @@
 )
 from tgdb.entities.numeration.number import Number
 from tgdb.entities.relation.relation import Relation
+from tgdb.infrastructure.telethon.in_telegram_bytes import InTelegramBytes
 
 
 @dataclass(frozen=True)
@@ -24,10 +27,11 @@ async def relation(self, relation_number: Number) -> Relation:
         relation = self._db.select_one(
             lambda it: it.number() == relation_number
         )
-
         if relation is None:
             raise NoRelationError(relation_number)
 
+        return relation
+
     async def add(self, relation: Relation) -> None:
         """
         :raises tgdb.application.common.ports.relations.NotUniqueRelationNumberError:
@@ -43,32 +47,78 @@ async def add(self, relation: Relation) -> None:
         self._db.insert(relation)
 
 
-@dataclass(frozen=True)
-class InMemoryRelations(Relations):
-    _db: InMemoryDb[Relation]
+@dataclass
+class InTelegramReplicableRelations(Relations):
+    _in_telegram_encoded_relations: InTelegramBytes
+    _cached_relations: InMemoryDb[Relation] | None = field(
+        init=False, default=None
+    )
+
+    async def __aenter__(self) -> Self:
+        loaded_relations = await self._loaded_relations()
+        self._cached_relations = loaded_relations
+
+        return self
+
+    async def __aexit__(
+        self,
+        error_type: type[BaseException] | None,
+        error: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None: ...
 
     async def relation(self, relation_number: Number) -> Relation:
         """
         :raises tgdb.application.common.ports.relations.NoRelationError:
         """
 
-        relation = self._db.select_one(
+        if self._cached_relations is None:
+            raise ValueError
+
+        relation = self._cached_relations.select_one(
             lambda it: it.number() == relation_number
         )
 
         if relation is None:
             raise NoRelationError(relation_number)
 
+        return relation
+
     async def add(self, relation: Relation) -> None:
         """
         :raises tgdb.application.common.ports.relations.NotUniqueRelationNumberError:
         """  # noqa: E501
 
-        selected_relation = self._db.select_one(
+        if self._cached_relations is None:
+            raise ValueError
+
+        selected_relation = self._cached_relations.select_one(
             lambda it: it.number() == relation.number()
         )
 
         if selected_relation is not None:
             raise NotUniqueRelationNumberError(relation.number())
 
-        self._db.insert(relation)
+        self._cached_relations.insert(relation)
+
+        encoded_cached_relations = pickle.dumps(self._cached_relations)
+        await self._in_telegram_encoded_relations.set(encoded_cached_relations)
+
+    async def _loaded_relations(self) -> InMemoryDb[Relation]:
+        encoded_relations = await self._in_telegram_encoded_relations
+
+        if encoded_relations is None:
+            return InMemoryDb()
+
+        relations = pickle.loads(encoded_relations)
+
+        if relations is None:
+            return InMemoryDb()
+        if not isinstance(relations, InMemoryDb):
+            raise TypeError(relations)
+
+        for relation in relations:
+            if not isinstance(relation, Relation):
+                raise TypeError(relation)
+
+        return cast(InMemoryDb[Relation], relations)