feat(presentation): add fastapi

Author: emptybutton

pyproject.toml

@@ -61,10 +61,13 @@ indent-width = 4
 [tool.ruff.lint]
 select = [
     "ANN", "F", "W", "E", "B", "C90", "N", "UP", "YTT", "ASYNC", "PL", "RUF",
-    "Q", "RET", "SLF", "SLOT", "SIM", "TID252", "TCH", "ARG", "PTH", "ERA", "TRY",
-    "PERF", "INP", "I", "S", "FAST", "TID", "TCH", "INT"
+    "Q", "RET", "SLF", "SLOT", "SIM", "TID252", "TCH", "ARG", "PTH", "ERA",
+    "TRY", "PERF", "INP", "I", "S", "FAST", "TID", "TCH", "INT"
+]
+ignore = [
+    "N818", "RUF009", "UP018", "PLR6301", "PLR0913", "PLW0108", "TC006",
+    "S101", "TC003", "TC002"
 ]
-ignore = ["N818", "RUF009", "UP018", "PLR6301", "PLR0913", "PLW0108", "TC006", "S101"]
 
 [tool.ruff.lint.isort]
 lines-after-imports = 2

src/tgdb/entities/transaction.py

@@ -1,5 +1,5 @@
 from collections.abc import Iterable, Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from uuid import UUID
 
 from tgdb.entities.logic_time import LogicTime
@@ -23,6 +23,10 @@ class TransactionConflict:
     marks: frozenset[Mark]
 
 
+@dataclass(frozen=True)
+class NoTransaction: ...
+
+
 @dataclass(frozen=True)
 class TransactionOkCommit:
     transaction_id: UUID
@@ -32,7 +36,7 @@ class TransactionOkCommit:
 @dataclass(frozen=True)
 class TransactionFailedCommit:
     transaction_id: UUID
-    conflict: TransactionConflict | None
+    reason: TransactionConflict | NoTransaction = field(kw_only=True)
 
 
 type TransactionCommit = TransactionOkCommit | TransactionFailedCommit
@@ -71,7 +75,7 @@ def commit(self) -> TransactionCommit:
 
         if conflict is not None:
             self._die()
-            return TransactionFailedCommit(self.id, conflict)
+            return TransactionFailedCommit(self.id, reason=conflict)
 
         for transaction in self._concurrent_transactions:
             transaction._transactions_with_possible_conflict.append(self)

src/tgdb/entities/transaction_horizon.py

@@ -12,6 +12,7 @@
     StartOperator,
 )
 from tgdb.entities.transaction import (
+    NoTransaction,
     Transaction,
     TransactionCommit,
     TransactionFailedCommit,
@@ -114,7 +115,7 @@ def _add_operator(self, operator: Operator) -> TransactionCommit | None:
 
             case CommitOperator(), None:
                 return TransactionFailedCommit(
-                    operator.transaction_id, conflict=None
+                    operator.transaction_id, reason=NoTransaction()
                 )
 
             case _:

src/tgdb/infrastructure/adapters/operator_serialization.py

@@ -0,0 +1,16 @@
+from collections.abc import Sequence
+from uuid import UUID
+
+from tgdb.application.ports.notification import Notification
+from tgdb.entities.transaction import TransactionCommit
+from tgdb.presentation.async_map import AsyncMap
+
+
+class TransactionCommitListNotificationToAsyncMap(
+    Notification[Sequence[TransactionCommit]]
+):
+    _map: AsyncMap[UUID, TransactionCommit]
+
+    async def send(self, commits: Sequence[TransactionCommit], /) -> None:
+        for commit in commits:
+            self._map[commit.transaction_id] = commit

src/tgdb/presentation/__init__.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+
+from tgdb.application.ports.operator_serialization import OperatorSerialization
+from tgdb.entities.operator import Operator
+from tgdb.presentation.fastapi.schemas.entity import EntitySchema
+
+
+@dataclass(frozen=True)
+class OperatorSerializationToOperator(OperatorSerialization[Operator | None]):
+    async def deserialized(self, operator: Operator | None) -> Operator | None:
+        return operator
+
+
+@dataclass(frozen=True)
+class OperatorSerializationToEntitySchema[OperatorT: Operator](
+    OperatorSerialization[EntitySchema[OperatorT]]
+):
+    async def deserialized(self, schema: EntitySchema[OperatorT]) -> OperatorT:
+        return schema.entity()

src/tgdb/presentation/adapters/__init__.py

@@ -0,0 +1,26 @@
+from dataclasses import dataclass, field
+
+from tgdb.presentation.async_result import AsyncResult
+
+
+@dataclass(frozen=True, unsafe_hash=False)
+class AsyncMap[KeyT, ValueT]:
+    _map: dict[KeyT, AsyncResult[ValueT]] = field(
+        init=False, default_factory=dict
+    )
+
+    def __getitem__(self, key: KeyT) -> AsyncResult[ValueT]:
+        if key in self._map:
+            return self._map[key]
+
+        result = AsyncResult[ValueT]()
+        self._map[key] = result
+
+        return result
+
+    def __setitem__(self, key: KeyT, value: ValueT) -> None:
+        if key not in self._map:
+            return
+
+        result = self._map[key]
+        result.set(value)

src/tgdb/presentation/adapters/notification.py

@@ -0,0 +1,21 @@
+from asyncio import Event
+from collections.abc import Awaitable, Generator
+from dataclasses import dataclass, field
+from typing import Any, cast
+
+
+@dataclass
+class AsyncResult[ValueT](Awaitable[ValueT]):
+    _value: ValueT | None = field(init=False, default=None)
+    _is_value_set: Event = field(init=False, default_factory=Event)
+
+    def set(self, value: ValueT) -> None:
+        self._value = value
+        self._is_value_set.set()
+
+    def __await__(self) -> Generator[Any, Any, ValueT]:
+        return self._get().__await__()
+
+    async def _get(self) -> ValueT:
+        await self._is_value_set.wait()
+        return cast(ValueT, self._value)