feat: make it better, faster, stronger

Author: emptybutton

pyproject.toml

@@ -27,12 +27,13 @@ dev = [
     "mypy[faster-cache]==1.15.0",
     "ruff==0.9.7",
     "pytest==8.3.4",
-    "pytest-asyncio==0.25.3",
     "pytest-cov==6.0.0",
+    "pytest-asyncio==0.25.3",
+    "pytest-timeout==2.4.0",
     "dirty-equals==0.8.0",
     "httpx==0.27.2",
     "httpx-ws==0.7.2",
-    "pytest-timeout==2.4.0",
+    "plotext==5.2.8",
 ]
 
 [build-system]

src/tgdb/application/horizon/start_transaction.py

@@ -4,6 +4,7 @@
 from tgdb.application.common.ports.shared_horizon import SharedHorizon
 from tgdb.application.common.ports.uuids import UUIDs
 from tgdb.entities.horizon.transaction import (
+    XID,
     IsolationLevel,
 )
 
@@ -14,9 +15,13 @@ class StartTransaction:
     shared_horizon: SharedHorizon
     clock: Clock
 
-    async def __call__(self, isolation_level: IsolationLevel) -> None:
+    async def __call__(self, isolation_level: IsolationLevel) -> XID:
+        """
+        :raises tgdb.entities.horizon.horizon.InvalidTransactionStateError:
+        """
+
         time = await self.clock
         xid = await self.uuids.random_uuid()
 
         async with self.shared_horizon as horizon:
-            horizon.start_transaction(time, xid, isolation_level)
+            return horizon.start_transaction(time, xid, isolation_level)

src/tgdb/application/view_tuples.py

@@ -1,3 +1,4 @@
+from collections.abc import Sequence
 from dataclasses import dataclass
 
 from tgdb.application.common.ports.clock import Clock
@@ -7,6 +8,7 @@
 from tgdb.entities.horizon.transaction import XID
 from tgdb.entities.numeration.number import Number
 from tgdb.entities.relation.scalar import Scalar
+from tgdb.entities.relation.tuple import Tuple
 from tgdb.entities.relation.tuple_effect import viewed_tuple
 from tgdb.entities.relation.versioned_tuple import versioned_tuple
 
@@ -24,7 +26,7 @@ async def __call__(
         relation_number: Number,
         attribute_number: Number,
         scalar: Scalar,
-    ) -> None:
+    ) -> Sequence[Tuple]:
         """
         :raises tgdb.application.common.ports.relations.NoRelationError:
         :raises tgdb.entities.horizon.horizon.NoTransactionError:
@@ -46,3 +48,5 @@ async def __call__(
             for viewed_tuple_ in viewed_tuples:
                 time = await self.clock
                 horizon.include(time, xid, viewed_tuple_)
+
+        return tuples

src/tgdb/entities/__init__.py

@@ -1,11 +0,0 @@
-from time import monotonic_ns
-
-
-n = 100_000
-
-x = monotonic_ns()
-frozenset(range(n)) & frozenset(range(n * 2))
-print(monotonic_ns() - x)
-
-
-# 1 000 000 000

src/tgdb/entities/horizon/horizon.py

@@ -87,7 +87,7 @@ def start_transaction(
         """
 
         assert_(
-            xid not in chain(*self._transaction_maps()),
+            all(xid not in map for map in self._transaction_maps()),
             else_=InvalidTransactionStateError,
         )
 

src/tgdb/entities/relation/domain.py

@@ -55,7 +55,7 @@ def __contains__(self, scalar: Scalar) -> bool:
 
 
 @dataclass(frozen=True)
-class SetDomain[T: bool | int | str | datetime | UUID](Domain):
+class SetDomain[T: int | str | datetime | UUID](Domain):
     values: tuple[T, ...]
     _type: type[T]
     _is_nonable: bool

src/tgdb/infrastructure/async_map.py

@@ -1,5 +1,5 @@
 from asyncio import Future
-from collections.abc import Awaitable
+from collections.abc import Awaitable, Iterator
 from dataclasses import dataclass, field
 
 
@@ -9,6 +9,12 @@ class AsyncMap[KeyT, ValueT]:
         init=False, default_factory=dict
     )
 
+    def __iter__(self) -> Iterator[KeyT]:
+        return iter(self._map)
+
+    def __len__(self) -> int:
+        return len(self._map)
+
     def __getitem__(self, key: KeyT) -> Awaitable[ValueT]:
         if key in self._map:
             return self._map[key]
@@ -20,6 +26,9 @@ def __getitem__(self, key: KeyT) -> Awaitable[ValueT]:
 
     def __setitem__(self, key: KeyT, result: ValueT) -> None:
         if key not in self._map:
+            futute_result = Future[ValueT]()
+            futute_result.set_result(result)
+            self._map[key] = futute_result
             return
 
         futute_result = self._map[key]

src/tgdb/infrastructure/lazy_map.py

@@ -1,35 +1,54 @@
 from collections import OrderedDict
 from collections.abc import Awaitable, Callable
-from contextlib import suppress
 from dataclasses import dataclass, field
+from typing import ClassVar
+
+
+class NoExternalValue:
+    _instance: "ClassVar[NoExternalValue | None]" = None
+
+    def __new__(cls) -> "NoExternalValue":
+        if NoExternalValue._instance is not None:
+            return NoExternalValue._instance
+
+        instance = super().__new__(cls)
+        NoExternalValue._instance = instance
+
+        return instance
+
+
+type ExternalValue[ValueT] = ValueT | NoExternalValue
 
 
 @dataclass(frozen=True, unsafe_hash=False)
 class LazyMap[KeyT, ValueT]:
-    _computed_map_max_len: int
-    _external_value: Callable[[KeyT], Awaitable[ValueT | None]]
-    _computed_map: OrderedDict[KeyT, ValueT] = field(
+    _cache_map_max_len: int
+    _external_value: Callable[[KeyT], Awaitable[ExternalValue[ValueT]]]
+
+    _cache_map: OrderedDict[KeyT, ExternalValue[ValueT]] = field(
         init=False, default_factory=OrderedDict
     )
 
-    async def __getitem__(self, key: KeyT) -> ValueT | None:
-        with suppress(KeyError):
-            return self._computed_map[key]
+    def cache_map(self) -> OrderedDict[KeyT, ExternalValue[ValueT]]:
+        return OrderedDict(self._cache_map)
 
-        value = await self._external_value(key)
+    async def __getitem__(self, key: KeyT) -> ValueT:
+        if key in self._cache_map:
+            return self._output(self._cache_map[key])
 
-        if value is None:
-            return None
+        value = await self._external_value(key)
+        self._cache_map[key] = value
 
-        self._computed_map[key] = value
+        if len(self._cache_map) > self._cache_map_max_len:
+            self._cache_map.pop(next(iter(self._cache_map)))
 
-        if len(self._computed_map) > self._computed_map_max_len:
-            self._computed_map.pop(next(iter(self._computed_map)))
-
-        return value
+        return self._output(value)
 
     def __setitem__(self, key: KeyT, value: ValueT) -> None:
-        self._computed_map[key] = value
+        self._cache_map[key] = value
+
+    def _output(self, value: ExternalValue[ValueT]) -> ValueT:
+        if isinstance(value, NoExternalValue):
+            raise KeyError
 
-    def __delitem__(self, key: KeyT) -> None:
-        del self._computed_map[key]
+        return value

src/tgdb/presentation/fastapi/error_handling.py

@@ -0,0 +1,50 @@
+from fastapi import FastAPI, Response, status
+from fastapi.responses import JSONResponse
+
+from tgdb.entities.horizon.horizon import (
+    InvalidTransactionStateError,
+    NoTransactionError,
+)
+from tgdb.entities.horizon.transaction import (
+    ConflictError,
+    NonSerializableWriteTransactionError,
+)
+from tgdb.presentation.fastapi.schemas.errors import (
+    InvalidTransactionStateSchema,
+    NoTransactionSchema,
+    TransactionConflictSchema,
+)
+
+
+def add_error_handling(app: FastAPI) -> None:
+    @app.exception_handler(ConflictError)
+    def _(conflict: ConflictError) -> Response:
+        schema = TransactionConflictSchema.of(conflict)
+
+        return JSONResponse(
+            schema.model_dump(mode="json", by_alias=True),
+            status_code=status.HTTP_409_CONFLICT,
+        )
+
+    @app.exception_handler(NoTransactionError)
+    def _(_: object) -> Response:
+        return JSONResponse(
+            NoTransactionSchema().model_dump(mode="json", by_alias=True),
+            status_code=status.HTTP_404_NOT_FOUND,
+        )
+
+    @app.exception_handler(InvalidTransactionStateError)
+    def _(_: object) -> Response:
+        schema = InvalidTransactionStateSchema()
+        return JSONResponse(
+            schema.model_dump(mode="json", by_alias=True),
+            status_code=status.HTTP_404_NOT_FOUND,
+        )
+
+    @app.exception_handler(NonSerializableWriteTransactionError)
+    def _(_: object) -> Response:
+        schema = InvalidTransactionStateSchema()
+        return JSONResponse(
+            schema.model_dump(mode="json", by_alias=True),
+            status_code=status.HTTP_404_NOT_FOUND,
+        )

src/tgdb/presentation/fastapi/routers.py

@@ -1,6 +1,7 @@
 from tgdb.presentation.fastapi.routes.commit_transaction import (
     commit_transaction_router,
 )
+from tgdb.presentation.fastapi.routes.healthcheck import healthcheck_router
 from tgdb.presentation.fastapi.routes.rollback_transaction import (
     rollback_transaction_router,
 )
@@ -9,6 +10,13 @@
 )
 
 
+_monitoring_routers = (
+    healthcheck_router,
+    rollback_transaction_router,
+    commit_transaction_router,
+)
+
+
 _transaction_routers = (
     start_transaction_router,
     rollback_transaction_router,
@@ -17,5 +25,6 @@
 
 
 all_routers = (
+    *_monitoring_routers,
     *_transaction_routers,
 )