fix: fix data types

Author: emptybutton

deploy/dev/tgdb/conf.yaml

@@ -14,7 +14,7 @@ conf:
   horizon:
     max_len: 10_000
     transaction:
-      max_age_seconds: 10
+      max_age_seconds: 120
 
   message_cache:
     max_len: 1_000_000

src/tgdb/infrastructure/adapters/channel.py

@@ -1,3 +1,4 @@
+from asyncio import wait_for
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 
@@ -15,6 +16,7 @@ class AsyncMapChannel(Channel):
     _async_map: AsyncMap[
         XID, NoTransactionError | TransactionNotCommittingError | None
     ]
+    _timeout_seconds: int | float
 
     async def publish(
         self,
@@ -32,5 +34,8 @@ async def publish(
             del self._async_map[error_commit_xid]
 
     async def wait(self, xid: XID) -> Notification:
-        notification_error = await self._async_map[xid]
+        notification_error = await wait_for(
+            self._async_map[xid], self._timeout_seconds
+        )
+
         return Notification(notification_error)

src/tgdb/infrastructure/adapters/relations.py

@@ -24,7 +24,7 @@ async def relation(self, relation_number: Number) -> Relation:
             lambda it: it.number() == relation_number
         )
         if relation is None:
-            raise NoRelationError(relation_number)
+            raise NoRelationError
 
         return relation
 
@@ -57,6 +57,9 @@ async def __aexit__(
         traceback: TracebackType | None,
     ) -> None: ...
 
+    def cache(self) -> InMemoryDb[Relation]:
+        return self._cached_relations
+
     async def relation(self, relation_number: Number) -> Relation:
         """
         :raises tgdb.application.relation.ports.relations.NoRelationError:

src/tgdb/infrastructure/telethon/in_telegram_bytes.py

@@ -1,5 +1,5 @@
 from collections.abc import Awaitable, Generator
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from io import BytesIO
 from typing import Any, cast
 
@@ -14,39 +14,23 @@ class InTelegramBytes(Awaitable[bytes | None]):
     _pool_to_select: TelegramClientPool
     _chat_id: int
 
-    _cached_stored_bytes: bytes | None = field(init=False, default=None)
-
     def __await__(self) -> Generator[Any, Any, bytes | None]:
         return self._get().__await__()
 
     async def set(self, bytes: bytes) -> None:
-        client = self._pool_to_insert()
-
-        await client.send_message(
-            self._chat_id, file=bytes
-        )
-        self._cached_stored_bytes = bytes
+        await self._pool_to_insert().send_message(self._chat_id, file=bytes)
 
     async def _get(self) -> bytes | None:
-        if self._cached_stored_bytes is not None:
-            return self._cached_stored_bytes
-
-        await self._refresh()
-        return self._cached_stored_bytes
-
-    async def _refresh(self) -> None:
         messages = await self._pool_to_select().get_messages(
-            self._chat_id, limit=1, min_id=1
+            self._chat_id, min_id=1
         )
         messages = cast(TotalList, messages)
 
         if not messages:
-            return
+            return None
 
         last_message = messages[-1]
 
         with BytesIO() as stream:
             await self._pool_to_select().download_file(last_message, stream)
-            stored_bytes = stream.getvalue()
-
-        self._cached_stored_bytes = stored_bytes
+            return stream.getvalue()

src/tgdb/main/common/di.py

@@ -2,7 +2,7 @@
 from collections.abc import AsyncIterator, Sequence
 from typing import NewType
 
-from dishka import Provider, Scope, make_container, provide
+from dishka import AnyOf, Provider, Scope, make_container, provide
 from in_memory_db import InMemoryDb
 
 from tgdb.application.common.ports.buffer import Buffer
@@ -69,16 +69,17 @@ def provide_conf(self, envs: Envs) -> TgdbConfig:
 class CommonProvider(Provider):
     provide_clock = provide(PerfCounterClock, provides=Clock, scope=Scope.APP)
     provide_uuids = provide(UUIDs4, provides=UUIDs, scope=Scope.APP)
-    provide_queque = provide(
+    provide_commit_queque = provide(
         staticmethod(lambda: InMemoryQueque(AsyncQueque())),
         provides=Queque[Sequence[Commit | PreparedCommit]],
         scope=Scope.APP
     )
-    provide_channel = provide(
-        staticmethod(lambda: AsyncMapChannel(AsyncMap())),
-        provides=Channel,
-        scope=Scope.APP,
-    )
+
+    @provide(scope=Scope.APP)
+    def provide_channel(self, config: TgdbConfig) -> Channel:
+        return AsyncMapChannel(
+            AsyncMap(), config.horizon.transaction.max_age_seconds
+        )
 
     @provide(scope=Scope.APP)
     async def provide_bot_pool(
@@ -178,22 +179,17 @@ async def provide_buffer(
         async with biffer:
             yield biffer
 
-    @provide(scope=Scope.APP)
-    def provide_relation_cache(self) -> RelationCache:
-        return RelationCache(InMemoryDb())
-
-    @provide(scope=Scope.APP)
+    @provide(scope=Scope.APP, )
     async def provide_relations(
         self,
         config: TgdbConfig,
         bot_pool: BotPool,
         user_bot_pool: UserBotPool,
-        relation_cache: RelationCache,
-    ) -> AsyncIterator[Relations]:
+    ) -> AsyncIterator[AnyOf[Relations, InTelegramReplicableRelations]]:
         in_tg_bytes = InTelegramBytes(
             bot_pool, user_bot_pool, config.relations.chat
         )
-        relations = InTelegramReplicableRelations(in_tg_bytes, relation_cache)
+        relations = InTelegramReplicableRelations(in_tg_bytes, InMemoryDb())
 
         async with relations:
             yield relations

src/tgdb/main/server/di.py

@@ -8,7 +8,8 @@
 from tgdb.application.relation.ports.relation_views import RelationViews
 from tgdb.application.relation.view_all_relations import ViewAllRelations
 from tgdb.application.relation.view_relation import ViewRelation
-from tgdb.main.common.di import CommonProvider, MainIOProvider, RelationCache
+from tgdb.infrastructure.adapters.relations import InTelegramReplicableRelations
+from tgdb.main.common.di import CommonProvider, MainIOProvider
 from tgdb.presentation.adapters.relation_views import (
     RelationSchemasFromInMemoryDbAsRelationViews,
 )
@@ -27,9 +28,9 @@
 class FastAPIProvider(Provider):
     @provide(scope=Scope.APP)
     def provide_relation_views(
-        self, relation_cache: RelationCache
+        self, relations: InTelegramReplicableRelations
     ) -> RelationViews[RelationListSchema, RelationSchema | None]:
-        return RelationSchemasFromInMemoryDbAsRelationViews(relation_cache)
+        return RelationSchemasFromInMemoryDbAsRelationViews(relations.cache())
 
     provide_view_relation = provide(
         ViewRelation[RelationListSchema, RelationSchema | None],

src/tgdb/presentation/fastapi/common/schemas/operator.py

@@ -1,7 +1,8 @@
-from typing import Literal
+from typing import Annotated, Literal
 from uuid import UUID
 
-from pydantic import BaseModel, Field, PositiveInt
+from annotated_types import Ge
+from pydantic import BaseModel, Field
 
 from tgdb.application.common.operator import (
     DeletedTupleOperator,
@@ -16,7 +17,7 @@
 
 class InsertOperatorSchema(BaseModel):
     action: Literal["insert"] = "insert"
-    relation_number: PositiveInt = Field(alias="relationNumber")
+    relation_number: Annotated[int, Ge(0)] = Field(alias="relationNumber")
     scalars: tuple[Scalar, ...]
 
     def decoded(self) -> NewTupleOperator:
@@ -25,7 +26,7 @@ def decoded(self) -> NewTupleOperator:
 
 class UpdateOperatorSchema(BaseModel):
     action: Literal["update"] = "update"
-    relation_number: PositiveInt = Field(alias="relationNumber")
+    relation_number: Annotated[int, Ge(0)] = Field(alias="relationNumber")
     tid: TID
     scalars: tuple[Scalar, ...]
 

src/tgdb/presentation/fastapi/relation/routes/create_relation.py

@@ -1,8 +1,11 @@
 
+from typing import Annotated
+
+from annotated_types import Ge
 from dishka.integrations.fastapi import FromDishka, inject
 from fastapi import APIRouter, status
 from fastapi.responses import Response
-from pydantic import BaseModel, Field, PositiveInt
+from pydantic import BaseModel, Field
 
 from tgdb.application.relation.create_relation import CreateRelation
 from tgdb.entities.numeration.number import Number
@@ -36,7 +39,7 @@ class CreateRelationSchema(BaseModel):
 @inject
 async def _(
     create_relation: FromDishka[CreateRelation],
-    relation_number: PositiveInt,
+    relation_number: Annotated[int, Ge(0)],
     request_body: CreateRelationSchema,
 ) -> Response:
     await create_relation(

src/tgdb/presentation/fastapi/relation/routes/view_relation.py

@@ -1,8 +1,9 @@
+from typing import Annotated
 
+from annotated_types import Ge
 from dishka.integrations.fastapi import FromDishka, inject
 from fastapi import APIRouter, status
 from fastapi.responses import JSONResponse, Response
-from pydantic import PositiveInt
 
 from tgdb.application.relation.view_relation import ViewRelation
 from tgdb.entities.numeration.number import Number
@@ -32,7 +33,7 @@ async def _(
     view_relation: FromDishka[
         ViewRelation[RelationListSchema, RelationSchema | None]
     ],
-    relation_number: PositiveInt,
+    relation_number: Annotated[int, Ge(0)],
 ) -> Response:
     view = await view_relation(Number(relation_number))
 

src/tgdb/presentation/fastapi/relation/routes/view_tuples.py

@@ -1,9 +1,11 @@
 from collections.abc import Iterable
+from typing import Annotated
 
+from annotated_types import Ge
 from dishka.integrations.fastapi import FromDishka, inject
 from fastapi import APIRouter, status
 from fastapi.responses import JSONResponse, Response
-from pydantic import BaseModel, Field, PositiveInt
+from pydantic import BaseModel, Field
 
 from tgdb.application.relation.view_tuples import ViewTuples
 from tgdb.entities.horizon.transaction import XID
@@ -23,7 +25,7 @@
 
 
 class ViewTupleSchema(BaseModel):
-    attribute_number: PositiveInt = Field(alias="attributeNumber")
+    attribute_number: Annotated[int, Ge(0)] = Field(alias="attributeNumber")
     attribute_scalar: Scalar = Field(alias="attributeScalar")
 
 
@@ -54,7 +56,7 @@ def of(cls, tuples: Iterable[Tuple]) -> "ViewedTuplesSchema":
 @inject
 async def _(
     view_tuples: FromDishka[ViewTuples],
-    relation_number: PositiveInt,
+    relation_number: Annotated[int, Ge(0)],
     request_body: ViewTupleSchema,
     xid: XID | None = None,
 ) -> Response: