ref(entities): add replation

Author: emptybutton

src/tgdb/entities/entity.py

@@ -0,0 +1,171 @@
+from collections import OrderedDict
+from collections.abc import Sequence
+from dataclasses import dataclass
+from itertools import batched, pairwise
+from uuid import UUID
+
+from tgdb.entities.number import Number
+from tgdb.entities.relation.domain import Domain
+from tgdb.entities.relation.scalar import Scalar
+from tgdb.entities.relation.schema import Schema
+
+
+@dataclass(frozen=True)
+class PartitionVersion:
+    number: Number
+    schema: Schema
+    migration_id: UUID
+
+
+class NotIncrementedPartitionVersionError(Exception): ...
+
+
+class PartitionWithoutVersionsError(Exception): ...
+
+
+# UUID @ str | bool int
+
+#  00000000000000000000000000000001:0:0:qweqweqweqwe oaksdoaksd qweq
+#  00000000000000000000000000000001:0:1:
+
+
+@dataclass(frozen=True)
+class Partition:
+    """
+    :raises tgdb.entities.relation.schema.PartitionWithoutVersionsError:
+    :raises tgdb.entities.relation.schema.NotIncrementedPartitionVersionError:
+    """
+
+    number: Number
+    _version_map: OrderedDict[Number, PartitionVersion]
+
+    def __post_init__(self) -> None:
+        if not self._version_map:
+            raise PartitionWithoutVersionsError
+
+        for number, next_number in pairwise(self._version_map):
+            if next(number) != next_number:
+                raise NotIncrementedPartitionVersionError
+
+    def last_version(self) -> PartitionVersion:
+        return self._version_map.keys()
+
+    def old_versions(self) -> Sequence[PartitionVersion]:
+        return self._versions[:-1]
+
+    def migrate(
+        self,
+        new_version_schema: Schema,
+        new_version_migration_id: UUID,
+    ) -> None:
+        new_version = PartitionVersion(
+            next(self.last_version().number),
+            new_version_schema,
+            new_version_migration_id,
+        )
+        self._versions.append(new_version)
+
+    def remove_old_versions(self, *, count: int) -> None:
+        if count >= len(self._versions):
+            raise PartitionWithoutVersionsError
+
+        for _ in range(count):
+            self._versions.pop(0)
+
+    @classmethod
+    def new(cls, number: Number, schema: Schema) -> "Partition":
+        return Partition(number, [PartitionVersion(Number(0), schema)])
+
+
+class EntityWithoutPartitionsError(Exception): ...
+
+
+class DifferentlyIdentifyingPartitionError(Exception): ...
+
+
+class InvalidPartitionMapError(Exception): ...
+
+
+class NoPartitionError(Exception): ...
+
+
+@dataclass(frozen=True)
+class Entity:
+    """
+    :raises tgdb.entities.entity.EntityWithoutPartitionsError:
+    :raises tgdb.entities.entity.InvalidPartitionMapError:
+    """
+
+    number: Number
+    _partition_map: dict[Number, Partition]
+
+    def __post_init__(self) -> None:
+        if not self._partition_map:
+            raise EntityWithoutPartitionsError
+
+        for number, partition in self._partition_map.items():
+            if number != partition.number:
+                raise InvalidPartitionMapError
+
+    @classmethod
+    def new(cls, number: Number, schema: Schema) -> "Entity":
+        return Entity(number, {Number(0): Partition.new(Number(0), schema)})
+
+    def add_partition(self, schema: Schema) -> None:
+        new_partition = Partition.new(
+            next(self._last_partition().number), schema
+        )
+        self._partition_map[new_partition.number] = new_partition
+
+    def partition_numbers(self) -> tuple[Number, ...]:
+        return tuple(self._partition_map.keys())
+
+    def partition_last_version(
+        self, partition_number: Number
+    ) -> PartitionVersion | None:
+        partition = self._partition_map.get(partition_number)
+
+        if partition is None:
+            return None
+
+        return partition.last_version()
+
+    def partition_old_versions(
+        self, partition_number: Number
+    ) -> Sequence[PartitionVersion] | None:
+        partition = self._partition_map.get(partition_number)
+
+        if partition is None:
+            return None
+
+        return partition.old_versions()
+
+    def migrate_partition(
+        self,
+        partition_number: Number,
+        new_schema: Schema,
+        migration_id: UUID,
+    ) -> None:
+        """
+        :raises tgdb.entities.entity.NoPartitionError:
+        :raises tgdb.entities.entity.DifferentlyIdentifyingPartitionError:
+        """
+
+        partition = self._partition_map.get(partition_number)
+
+        if partition is None:
+            raise NoPartitionError
+
+        partition
+
+        return partition.old_versions()
+
+    def remove_old_versions(self, *, count: int) -> None:
+        if count >= len(self._versions):
+            raise PartitionWithoutVersionsError
+
+        for _ in range(count):
+            self._versions.pop(0)
+
+    def _last_partition(self) -> Partition:
+        return self._partition_map[max(self._partition_map)]

src/tgdb/entities/message.py

@@ -2,7 +2,7 @@
 from collections.abc import Iterator, Sequence
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, overload
+from typing import Any, Self, overload
 from uuid import UUID
 
 
@@ -20,8 +20,8 @@ def __post_init__(self) -> None:
     def __int__(self) -> "int":
         return self.int
 
-    def __add__(self, other: "Number | int") -> "Number":
-        return Number(self.int + int(other))
+    def __next__(self) -> "Number":
+        return Number(self.int + 1)
 
-    def __radd__(self, other: "int") -> "Number":
-        return Number(self.int + other)
+    def __lt__(self, other: "Number") -> bool:
+        return self.int < other.int

src/tgdb/entities/number.py

@@ -16,6 +16,12 @@ def is_nonable(self) -> bool: ...
     @abstractmethod
     def __contains__(self, scalar: Scalar) -> bool: ...
 
+    @abstractmethod
+    def __eq__(self, other: object) -> bool: ...
+
+    @abstractmethod
+    def __hash__(self) -> int: ...
+
 
 @dataclass(frozen=True)
 class IntDomain(Domain):

src/tgdb/entities/relation/domain.py

@@ -2,16 +2,25 @@
 from dataclasses import dataclass
 from typing import Any, overload
 
-from tgdb.entities.number import Number
 from tgdb.entities.relation.domain import Domain
 from tgdb.entities.relation.scalar import Scalar
 
 
-@dataclass(frozen=True, unsafe_hash=False, eq=False)
-class SchemaPartitionVersion:  # noqa: PLW1641
-    number: Number
+class EmptyRelationSchemaError(Exception): ...
+
+
+@dataclass(frozen=True)
+class Schema:
+    """
+    :raises tgdb.entities.relation.schema.EmptyRelationSchemaError:
+    """
+
     domains: tuple[Domain, ...]
 
+    def __post_init__(self) -> None:
+        if not self.domains:
+            raise EmptyRelationSchemaError
+
     def __contains__(self, tuple_: tuple[Scalar, ...]) -> bool:
         if len(self) != len(tuple_):
             return False
@@ -21,18 +30,6 @@ def __contains__(self, tuple_: tuple[Scalar, ...]) -> bool:
             for domain, scalar in zip(self, tuple_, strict=True)
         )
 
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, SchemaPartitionVersion):
-            return False
-
-        if len(self) != len(other):
-            return False
-
-        return all(
-            schema1 == schema2
-            for schema1, schema2 in zip(self, other, strict=True)
-        )
-
     def __iter__(self) -> Iterator[Domain]:
         return iter(self.domains)
 
@@ -51,75 +48,3 @@ def __getitem__(
 
     def __len__(self) -> int:
         return len(self.domains)
-
-
-@dataclass(frozen=True, unsafe_hash=False)
-class SchemaPartition:
-    number: int
-    _versions: list[SchemaPartitionVersion]
-
-    def __post_init__(self) -> None:
-        if not self._versions:
-            raise SchemaWithoutVersionsError
-
-        for version_index in range(len(self._versions) - 1):
-            version = self._versions[version_index]
-            next_version = self._versions[version_index]
-
-            self._validate_increment(version, next_version)
-
-    def last_version(self) -> SchemaPartitionVersion:
-        return self._versions[-1]
-
-    def old_versions(self) -> Sequence[SchemaPartitionVersion]:
-        return self._versions[:-1]
-
-    def add_version(self, domains: tuple[Domain, ...]) -> None:
-        new_version = SchemaPartitionVersion(
-            self.last_version().number + 1, domains,
-        )
-        self._versions.append(new_version)
-
-    def remove_old_versions(self, *, count: int) -> None:
-        if count >= len(self._versions):
-            raise SchemaWithoutVersionsError
-
-        for _ in range(count):
-            self._versions.pop(0)
-
-    def _validate_increment(
-        self,
-        prevous_version: SchemaPartitionVersion,
-        new_version: SchemaPartitionVersion,
-    ) -> None:
-        if prevous_version.number + 1 != new_version.number:
-            raise NotIncrementedSchemaVersionsError
-
-
-class NotIncrementedSchemaVersionsError(Exception): ...
-
-
-# | id int | id str |
-
-
-@dataclass(frozen=True, unsafe_hash=False)
-class Schema:
-    number: Number
-    _partitions: list[SchemaPartition]
-
-    def __post_init__(self) -> None:
-        if not self._partitions:
-            raise SchemaWithoutVersionsError
-
-        for version_index in range(len(self._partitions) - 1):
-            version = self._partitions[version_index]
-            next_version = self._partitions[version_index]
-
-            self._validate_increment(version, next_version)
-
-
-class NotIncrementedSchemaVersionsError(Exception): ...
-
-
-class SchemaWithoutVersionsError(Exception): ...
-

src/tgdb/entities/relation/schema.py

@@ -6,7 +6,6 @@
 
 from tgdb.entities.logic_time import LogicTime
 from tgdb.entities.mark import Mark
-from tgdb.entities.message import Message
 from tgdb.entities.row import RowID, RowVersion
 
 
@@ -27,7 +26,6 @@ class ViewedRow:
 @dataclass(frozen=True)
 class MutatedRow:
     row_version: RowVersion
-    message: Message | None
 
     @property
     def id(self) -> RowID:
@@ -37,7 +35,6 @@ def id(self) -> RowID:
 @dataclass(frozen=True)
 class DeletedRow:
     id: RowID
-    message: Message | None
 
 
 type TransactionScalarEffect = (