apexdevkit 1.28.2__tar.gz → 1.29.2__tar.gz

{apexdevkit-1.28.2 → apexdevkit-1.29.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apexdevkit
-Version: 1.28.2
+Version: 1.29.2
 Summary: Apex Development Tools for python.
 License-File: LICENSE
 Author: Apex Dev

{apexdevkit-1.28.2 → apexdevkit-1.29.2}/apexdevkit/fastapi/service.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
 from functools import cached_property
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic
 
 from apexdevkit.formatter import Formatter
-from apexdevkit.repository.decorator import BruteForceBatch
-from apexdevkit.repository.interface import Repository
+from apexdevkit.repository import BruteForceBatch, Repository
+from apexdevkit.repository.core import ItemT
 
 RawItem = Mapping[str, Any]
 RawCollection = Iterable[RawItem]
@@ -59,9 +59,6 @@ class RestfulService:  # pragma: no cover
         raise NotImplementedError(self.delete_one.__name__)
 
 
-ItemT = TypeVar("ItemT")
-
-
 @dataclass(frozen=True)
 class RestfulRepository(RestfulService, Generic[ItemT]):
     repository: Repository[ItemT]

{apexdevkit-1.28.2 → apexdevkit-1.29.2}/apexdevkit/formatter.py

@@ -85,8 +85,8 @@ class DataclassFormatter(Generic[_TargetT]):
 
         return self
 
-    def load(self, raw: Mapping[str, Any]) -> _TargetT:
-        raw = FluentDict[Any](deepcopy(raw)).select(
+    def load(self, source: Mapping[str, Any]) -> _TargetT:
+        source = FluentDict[Any](deepcopy(source)).select(
             *self.resource.__annotations__.keys(),
             "id",
             "idempotency_id",
@@ -95,27 +95,27 @@ class DataclassFormatter(Generic[_TargetT]):
         for key in fields(self.resource):  # type: ignore
             types = get_type_hints(self.resource)
             key_type = types[key.name]
-            if key.name not in raw:
+            if key.name not in source:
                 continue
             if key.name in self.sub_formatters:
-                raw[key.name] = (
-                    self.sub_formatters[key.name].load(raw.pop(key.name))
-                    if raw[key.name]
-                    else raw[key.name]
+                source[key.name] = (
+                    self.sub_formatters[key.name].load(source.pop(key.name))
+                    if source[key.name]
+                    else source[key.name]
                 )
             elif is_dataclass(key_type):
-                raw[key.name] = DataclassFormatter(key_type).load(raw[key.name])  # type: ignore
+                source[key.name] = DataclassFormatter(key_type).load(source[key.name])  # type: ignore
             else:
                 args = get_args(key_type)
                 if len(args) == 1 and is_dataclass(args[0]):
-                    raw[key.name] = ListFormatter(DataclassFormatter(args[0])).load(  # type: ignore
-                        raw[key.name]
+                    source[key.name] = ListFormatter(DataclassFormatter(args[0])).load(  # type: ignore
+                        source[key.name]
                     )
 
-        return self.resource(**raw)
+        return self.resource(**source)
 
-    def dump(self, item: _TargetT) -> Mapping[str, Any]:
-        return asdict(item)  # type: ignore
+    def dump(self, target: _TargetT) -> Mapping[str, Any]:
+        return asdict(target)  # type: ignore
 
 
 class ValueFormatter:

apexdevkit-1.29.2/apexdevkit/repository/__init__.py

@@ -0,0 +1,41 @@
+from .core import (
+    BruteForceBatch,
+    Connection,
+    Connector,
+    Cursor,
+    Database,
+    DatabaseCommand,
+    Repository,
+    RepositoryBase,
+    RepositoryDecorator,
+)
+from .core.interface import Entity
+from .in_memory import (
+    CacheMixin,
+    InMemoryByteStore,
+    InMemoryRepository,
+    KeyValueStore,
+)
+from .sql import MsSqlRepository, SqliteRepository
+
+__all__ = [
+    "Entity",
+    # Core
+    "BruteForceBatch",
+    "Connection",
+    "Connector",
+    "Cursor",
+    "Database",
+    "DatabaseCommand",
+    "Repository",
+    "RepositoryBase",
+    "RepositoryDecorator",
+    # In-memory
+    "CacheMixin",
+    "InMemoryByteStore",
+    "InMemoryRepository",
+    "KeyValueStore",
+    # SQL
+    "MsSqlRepository",
+    "SqliteRepository",
+]

apexdevkit-1.29.2/apexdevkit/repository/core/__init__.py

@@ -0,0 +1,27 @@
+from .database import (
+    Connection,
+    ConnectionContextManager,
+    Connector,
+    Cursor,
+    Database,
+    DatabaseCommand,
+)
+from .decorator import BruteForceBatch, RepositoryDecorator
+from .interface import ItemT, Repository, RepositoryBase
+
+__all__ = [
+    # Database
+    "Connection",
+    "ConnectionContextManager",
+    "Connector",
+    "Cursor",
+    "Database",
+    "DatabaseCommand",
+    # Decorator
+    "RepositoryDecorator",
+    "BruteForceBatch",
+    # Interface
+    "ItemT",
+    "Repository",
+    "RepositoryBase",
+]

{apexdevkit-1.28.2/apexdevkit/repository → apexdevkit-1.29.2/apexdevkit/repository/core}/database.py

@@ -97,3 +97,15 @@ class DatabaseCommand:
 
     def __str__(self) -> str:  # pragma: no cover
         return self.value % self.payload
+
+
+class ConnectionContextManager(AbstractContextManager[Connection]):
+    def __init__(self, connection: Connection) -> None:
+        self.connection = connection
+
+    def __enter__(self) -> Connection:
+        return self.connection
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        self.connection.cursor().close()
+        self.connection.close()

{apexdevkit-1.28.2/apexdevkit/repository → apexdevkit-1.29.2/apexdevkit/repository/core}/decorator.py

@@ -1,8 +1,8 @@
 from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
-from typing import Any, Generic
+from typing import Generic
 
-from apexdevkit.repository.interface import ItemT, Repository
+from .interface import ItemT, Repository
 
 
 @dataclass
@@ -21,9 +21,6 @@ class RepositoryDecorator(Generic[ItemT]):  # pragma: no cover
     def delete(self, item_id: str) -> None:
         self.inner.delete(item_id)
 
-    def bind(self, **kwargs: Any) -> Repository[ItemT]:
-        return self.inner.bind(**kwargs)
-
     def __iter__(self) -> Iterator[ItemT]:
         return self.inner.__iter__()
 

apexdevkit-1.29.2/apexdevkit/repository/core/interface.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Iterator
+from dataclasses import dataclass, field
+from typing import Generic, Protocol, TypeVar
+from uuid import uuid4
+
+
+def _uuid() -> str:
+    return str(uuid4())
+
+
+@dataclass(frozen=True, kw_only=True)
+class Entity:
+    id: str = field(default_factory=_uuid)
+    idempotency_id: str | None = field(default=None)
+
+
+ItemT = TypeVar("ItemT", bound=Entity)
+KeyFn = Callable[[ItemT], str]
+
+
+class Repository(Protocol[ItemT]):  # pragma: no cover
+    def create(self, item: ItemT) -> ItemT:
+        pass
+
+    def read(self, item_id: str) -> ItemT:
+        pass
+
+    def update(self, item: ItemT) -> None:
+        pass
+
+    def delete(self, item_id: str) -> None:
+        pass
+
+    def __iter__(self) -> Iterator[ItemT]:
+        pass
+
+    def __len__(self) -> int:
+        pass
+
+
+class BatchRepository(Repository[ItemT], Protocol[ItemT]):  # pragma: no cover
+    def create_many(self, items: Iterable[ItemT]) -> Iterable[ItemT]:
+        pass
+
+    def update_many(self, items: Iterable[ItemT]) -> None:
+        pass
+
+
+class RepositoryBase(Generic[ItemT]):  # pragma: no cover
+    def create(self, item: ItemT) -> ItemT:
+        raise NotImplementedError
+
+    def read(self, item_id: str) -> ItemT:
+        raise NotImplementedError
+
+    def update(self, item: ItemT) -> None:
+        raise NotImplementedError
+
+    def delete(self, item_id: str) -> None:
+        raise NotImplementedError
+
+    def __iter__(self) -> Iterator[ItemT]:
+        raise NotImplementedError
+
+    def __len__(self) -> int:
+        raise NotImplementedError

apexdevkit-1.28.2/apexdevkit/repository/repository.py → apexdevkit-1.29.2/apexdevkit/repository/core/multi.py

@@ -2,13 +2,12 @@ from __future__ import annotations
 
 from collections.abc import Callable, Iterator
 from dataclasses import dataclass, field
-from typing import Generic, TypeVar
+from typing import Generic
 
 from apexdevkit.error import DoesNotExistError
 from apexdevkit.formatter import Formatter
-from apexdevkit.repository import Repository, RepositoryBase
 
-ItemT = TypeVar("ItemT")
+from .interface import ItemT, Repository, RepositoryBase
 
 
 @dataclass(frozen=True)

apexdevkit-1.29.2/apexdevkit/repository/in_memory/__init__.py

@@ -0,0 +1,10 @@
+from .mixin import CacheMixin
+from .repository import InMemoryRepository
+from .store import InMemoryByteStore, KeyValueStore
+
+__all__ = [
+    "CacheMixin",
+    "InMemoryRepository",
+    "InMemoryByteStore",
+    "KeyValueStore",
+]

apexdevkit-1.29.2/apexdevkit/repository/in_memory/mixin.py

@@ -0,0 +1,20 @@
+from collections import defaultdict
+from collections.abc import MutableMapping
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any
+
+from .store import InMemoryByteStore, KeyValueStore
+
+
+@dataclass(frozen=True)
+class CacheMixin:
+    @cached_property
+    def _entries(self) -> MutableMapping[str, KeyValueStore[Any]]:
+        return defaultdict(InMemoryByteStore)
+
+    def store_for(self, name: str) -> KeyValueStore[Any]:
+        return self._entries[name]
+
+    def clear(self) -> None:
+        self._entries.clear()

apexdevkit-1.29.2/apexdevkit/repository/in_memory/repository.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import suppress
+from dataclasses import dataclass, field
+
+from apexdevkit.error import DoesNotExistError, ExistsError
+from apexdevkit.key_fn import AttributeKey
+from apexdevkit.repository.core import ItemT, RepositoryBase
+from apexdevkit.repository.core.interface import KeyFn
+
+from .store import InMemoryByteStore, KeyValueStore
+
+
+@dataclass(frozen=True)
+class InMemoryRepository(RepositoryBase[ItemT]):
+    store: KeyValueStore[ItemT] = field(default_factory=InMemoryByteStore)
+    keys: list[KeyFn[ItemT]] = field(default_factory=lambda: [AttributeKey("id")])
+
+    def and_key(self, function: KeyFn[ItemT]) -> InMemoryRepository[ItemT]:
+        return self.with_key(function)
+
+    def with_key(self, function: KeyFn[ItemT]) -> InMemoryRepository[ItemT]:
+        self.keys.append(function)
+
+        return self
+
+    def and_seeded(self, *items: ItemT) -> InMemoryRepository[ItemT]:
+        return self.with_seeded(*items)
+
+    def with_seeded(self, *items: ItemT) -> InMemoryRepository[ItemT]:
+        for seed in items:
+            with suppress(ExistsError):
+                self.create(seed)
+
+        return self
+
+    def create(self, item: ItemT) -> ItemT:
+        self._ensure_does_not_exist(item)
+        self.store.set(item.id, item)
+
+        return item
+
+    def _ensure_does_not_exist(self, new: ItemT) -> None:
+        for existing in self:
+            for key in self.keys:
+                if key(new) == key(existing):
+                    ExistsError(existing).with_duplicate(key).fire()
+
+    def update(self, item: ItemT) -> None:
+        self.delete(item.id)
+        self.create(item)
+
+    def delete(self, item_id: str) -> None:
+        item = self.read(item_id)
+        self.store.drop(item.id)
+
+    def read(self, item_id: str) -> ItemT:
+        for key in self.keys:
+            for item in self:
+                if key(item) == str(item_id):
+                    return item
+
+        raise DoesNotExistError(item_id)
+
+    def __iter__(self) -> Iterator[ItemT]:
+        return iter(self.store.values())
+
+    def __len__(self) -> int:
+        return self.store.count()

apexdevkit-1.29.2/apexdevkit/repository/in_memory/store.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Generic, Protocol
+
+from apexdevkit.formatter import Formatter, PickleFormatter
+from apexdevkit.repository.core.interface import ItemT
+
+
+class KeyValueStore(Protocol[ItemT]):  # pragma: no cover
+    def count(self) -> int:
+        pass
+
+    def set(self, key: str, value: ItemT) -> None:
+        pass
+
+    def get(self, key: str) -> ItemT:
+        pass
+
+    def drop(self, key: str) -> None:
+        pass
+
+    def values(self) -> Iterable[ItemT]:
+        pass
+
+
+@dataclass
+class InMemoryByteStore(Generic[ItemT]):
+    formatter: Formatter[bytes, ItemT] = field(default_factory=PickleFormatter)
+
+    items: dict[str, bytes] = field(default_factory=dict)
+
+    def count(self) -> int:
+        return len(self.items)
+
+    def set(self, key: str, value: ItemT) -> None:
+        self.items[key] = self.formatter.dump(value)
+
+    def get(self, key: str) -> ItemT:
+        return self.formatter.load(self.items[key])
+
+    def drop(self, key: str) -> None:
+        del self.items[key]
+
+    def values(self) -> Iterable[ItemT]:
+        for raw in self.items.values():
+            yield self.formatter.load(raw)

apexdevkit-1.29.2/apexdevkit/repository/sql/__init__.py

@@ -0,0 +1,11 @@
+from .field import NotNone, SqlFieldBuilder, SqlFieldManager
+from .mssql import MsSqlRepository
+from .sqlite import SqliteRepository
+
+__all__ = [
+    "NotNone",
+    "SqlFieldBuilder",
+    "SqlFieldManager",
+    "MsSqlRepository",
+    "SqliteRepository",
+]

{apexdevkit-1.28.2/apexdevkit/repository → apexdevkit-1.29.2/apexdevkit/repository/sql}/connector.py

@@ -9,6 +9,7 @@ from typing import Any
 import pymssql
 
 from apexdevkit.repository import Connection
+from apexdevkit.repository.core.database import ConnectionContextManager
 
 
 @dataclass(frozen=True)
@@ -63,18 +64,6 @@ class MsSqlConnector:
         )
 
 
-class ConnectionContextManager(AbstractContextManager[Connection]):
-    def __init__(self, connection: Connection) -> None:
-        self.connection = connection
-
-    def __enter__(self) -> Connection:
-        return self.connection
-
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        self.connection.cursor().close()
-        self.connection.close()
-
-
 @dataclass
 class MsSqlConnectionAdapter:
     connection: pymssql.Connection[pymssql.DictRow]

{apexdevkit-1.28.2/apexdevkit/repository → apexdevkit-1.29.2/apexdevkit/repository/sql}/mssql.py

@@ -2,16 +2,14 @@ from __future__ import annotations
 
 from collections.abc import Iterable, Iterator, Mapping
 from dataclasses import dataclass
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic
 
 from pymssql.exceptions import DatabaseError, OperationalError
 
 from apexdevkit.error import DoesNotExistError, ExistsError
 from apexdevkit.formatter import Formatter
-from apexdevkit.repository import Database, DatabaseCommand, RepositoryBase
-from apexdevkit.repository.sql import NotNone, SqlFieldManager, _SqlField
-
-ItemT = TypeVar("ItemT")
+from apexdevkit.repository.core import Database, DatabaseCommand, ItemT, RepositoryBase
+from apexdevkit.repository.sql.field import NotNone, SqlFieldManager, _SqlField
 
 
 @dataclass

{apexdevkit-1.28.2/apexdevkit/repository → apexdevkit-1.29.2/apexdevkit/repository/sql}/sqlite.py

@@ -8,8 +8,8 @@ from typing import Any, Generic
 from apexdevkit.error import DoesNotExistError, ExistsError
 from apexdevkit.formatter import Formatter
 from apexdevkit.repository import Database, DatabaseCommand, RepositoryBase
-from apexdevkit.repository.interface import ItemT
-from apexdevkit.repository.sql import NotNone, SqlFieldManager, _SqlField
+from apexdevkit.repository.core.interface import ItemT
+from apexdevkit.repository.sql.field import NotNone, SqlFieldManager, _SqlField
 
 
 @dataclass(frozen=True)
@@ -17,9 +17,6 @@ class SqliteRepository(RepositoryBase[ItemT]):
     db: Database
     table: SqlTable[ItemT]
 
-    def bind(self, **kwargs: Any) -> SqliteRepository[ItemT]:
-        return SqliteRepository(self.db, self.table.bind(**kwargs))
-
     def __iter__(self) -> Iterator[ItemT]:
         for raw in self.db.execute(self.table.select_all()).fetch_all():
             yield self.table.load(raw)
@@ -61,9 +58,6 @@ class SqliteRepository(RepositoryBase[ItemT]):
 
 
 class SqlTable(Generic[ItemT]):  # pragma: no cover
-    def bind(self, **_: Any) -> SqlTable[ItemT]:
-        return self
-
     def count_all(self) -> DatabaseCommand:
         raise NotImplementedError
 

{apexdevkit-1.28.2 → apexdevkit-1.29.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "1.28.2"
+version = "1.29.2"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [
@@ -30,7 +30,7 @@ faker = "*"
 
 
 [tool.poetry.group.lint.dependencies]
-apexcodexpy = "*"
+apexcodexpy = "0.3.1"
 
 [tool.mypy]
 ignore_missing_imports = true

apexdevkit-1.28.2/apexdevkit/repository/__init__.py

@@ -1,29 +0,0 @@
-from apexdevkit.repository.base import RepositoryBase
-from apexdevkit.repository.database import (
-    Connection,
-    Connector,
-    Cursor,
-    Database,
-    DatabaseCommand,
-)
-from apexdevkit.repository.in_memory import (
-    InMemoryByteStore,
-    InMemoryRepository,
-    KeyValueStore,
-)
-from apexdevkit.repository.interface import Repository
-from apexdevkit.repository.mssql import MsSqlRepository
-
-__all__ = [
-    "Connection",
-    "Connector",
-    "Cursor",
-    "Database",
-    "DatabaseCommand",
-    "InMemoryRepository",
-    "InMemoryByteStore",
-    "KeyValueStore",
-    "Repository",
-    "RepositoryBase",
-    "MsSqlRepository",
-]

apexdevkit-1.28.2/apexdevkit/repository/base.py

@@ -1,27 +0,0 @@
-from collections.abc import Iterator
-from typing import Any, Generic
-
-from apexdevkit.repository.interface import ItemT, Repository
-
-
-class RepositoryBase(Generic[ItemT]):  # pragma: no cover
-    def create(self, item: ItemT) -> ItemT:
-        raise NotImplementedError
-
-    def read(self, item_id: str) -> ItemT:
-        raise NotImplementedError
-
-    def update(self, item: ItemT) -> None:
-        raise NotImplementedError
-
-    def delete(self, item_id: str) -> None:
-        raise NotImplementedError
-
-    def bind(self, **kwargs: Any) -> Repository[ItemT]:
-        raise NotImplementedError
-
-    def __iter__(self) -> Iterator[ItemT]:
-        raise NotImplementedError
-
-    def __len__(self) -> int:
-        raise NotImplementedError

apexdevkit-1.28.2/apexdevkit/repository/in_memory.py

@@ -1,209 +0,0 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from collections.abc import Callable, Iterable, Iterator, MutableMapping
-from contextlib import suppress
-from dataclasses import dataclass, field
-from typing import Any, Generic, Protocol, Self
-
-from apexdevkit.error import DoesNotExistError, ExistsError
-from apexdevkit.formatter import Formatter, PickleFormatter
-from apexdevkit.key_fn import AttributeKey
-from apexdevkit.repository import RepositoryBase
-from apexdevkit.repository.interface import ItemT, Repository
-
-_KeyFunction = Callable[[ItemT], str]
-
-
-@dataclass(frozen=True)
-class InMemoryRepository(Generic[ItemT]):
-    store: KeyValueStore[ItemT] = field(default_factory=lambda: InMemoryByteStore())
-    keys: list[_KeyFunction[ItemT]] = field(default_factory=list)
-    seeds: frozenset[ItemT] = field(default_factory=frozenset)
-
-    def with_store(self, value: KeyValueStore[ItemT]) -> InMemoryRepository[ItemT]:
-        return InMemoryRepository(store=value, keys=self.keys, seeds=self.seeds)
-
-    def and_key(self, function: _KeyFunction[ItemT]) -> InMemoryRepository[ItemT]:
-        return self.with_key(function)
-
-    def with_key(self, function: _KeyFunction[ItemT]) -> InMemoryRepository[ItemT]:
-        return InMemoryRepository(
-            store=self.store,
-            keys=[*self.keys, function],
-            seeds=self.seeds,
-        )
-
-    def and_seeded(self, *items: ItemT) -> InMemoryRepository[ItemT]:
-        return self.with_seeded(*items)
-
-    def with_seeded(self, *items: ItemT) -> InMemoryRepository[ItemT]:
-        return InMemoryRepository(
-            store=self.store,
-            keys=self.keys,
-            seeds=self.seeds.union(set(items)),
-        )
-
-    def build(self) -> Repository[ItemT]:
-        return self._seed(self._create())
-
-    def _seed(self, repository: Repository[ItemT]) -> Repository[ItemT]:
-        for seed in self.seeds:
-            with suppress(ExistsError):
-                repository.create(seed)
-
-        return repository
-
-    def _create(self) -> Repository[ItemT]:
-        match len(self.keys):
-            case 0:
-                return _SingleKeyRepository(self.store, pk=AttributeKey("id"))
-            case 1:
-                return _SingleKeyRepository(self.store, pk=self.keys[0])
-            case _:
-                return _ManyKeyRepository(self.store, keys=self.keys)
-
-
-class KeyValueStore(Protocol[ItemT]):  # pragma: no cover
-    def count(self) -> int:
-        pass
-
-    def set(self, key: str, value: ItemT) -> None:
-        pass
-
-    def get(self, key: str) -> ItemT:
-        pass
-
-    def drop(self, key: str) -> None:
-        pass
-
-    def values(self) -> Iterable[ItemT]:
-        pass
-
-
-@dataclass
-class InMemoryByteStore(Generic[ItemT]):
-    formatter: Formatter[bytes, ItemT] = field(default_factory=PickleFormatter)
-
-    items: dict[str, bytes] = field(default_factory=dict)
-
-    def count(self) -> int:
-        return len(self.items)
-
-    def set(self, key: str, value: ItemT) -> None:
-        self.items[key] = self.formatter.dump(value)
-
-    def get(self, key: str) -> ItemT:
-        return self.formatter.load(self.items[key])
-
-    def drop(self, key: str) -> None:
-        del self.items[key]
-
-    def values(self) -> Iterable[ItemT]:
-        for raw in self.items.values():
-            yield self.formatter.load(raw)
-
-    @dataclass
-    class Cache:
-        items: MutableMapping[str, InMemoryByteStore[Any]] = field(init=False)
-
-        def __post_init__(self) -> None:
-            self.items = defaultdict(InMemoryByteStore)
-
-        def store_for(self, name: str) -> InMemoryByteStore[Any]:
-            return self.items[name]
-
-        def clear(self) -> None:
-            self.items.clear()
-
-
-@dataclass
-class _SingleKeyRepository(RepositoryBase[ItemT]):
-    store: KeyValueStore[ItemT]
-    pk: _KeyFunction[ItemT]
-
-    def bind(self, **_: Any) -> Self:  # pragma: no cover
-        return self
-
-    def create(self, item: ItemT) -> ItemT:
-        self._ensure_does_not_exist(item)
-        self.store.set(self.pk(item), item)
-
-        return item
-
-    def _ensure_does_not_exist(self, new: ItemT) -> None:
-        try:
-            existing = self.store.get(self.pk(new))
-        except KeyError:
-            return
-
-        ExistsError(existing).with_duplicate(self.pk).fire()
-
-    def update(self, item: ItemT) -> None:
-        self.delete(self.pk(item))
-        self.create(item)
-
-    def delete(self, item_id: str) -> None:
-        try:
-            self.store.drop(item_id)
-        except KeyError as e:
-            raise DoesNotExistError(item_id) from e
-
-    def read(self, item_id: str) -> ItemT:
-        try:
-            return self.store.get(item_id)
-        except KeyError as e:
-            raise DoesNotExistError(item_id) from e
-
-    def __iter__(self) -> Iterator[ItemT]:
-        return iter(self.store.values())
-
-    def __len__(self) -> int:
-        return self.store.count()
-
-
-@dataclass
-class _ManyKeyRepository(RepositoryBase[ItemT]):
-    store: KeyValueStore[ItemT]
-
-    keys: list[_KeyFunction[ItemT]] = field(default_factory=list)
-
-    def bind(self, **_: Any) -> Self:  # pragma: no cover
-        return self
-
-    def create(self, item: ItemT) -> ItemT:
-        self._ensure_does_not_exist(item)
-        self.store.set(self._pk(item), item)
-
-        return item
-
-    def _ensure_does_not_exist(self, new: ItemT) -> None:
-        for existing in self:
-            for key in self.keys:
-                if key(new) == key(existing):
-                    ExistsError(existing).with_duplicate(key).fire()
-
-    def _pk(self, item: ItemT) -> str:
-        return self.keys[0](item)
-
-    def update(self, item: ItemT) -> None:
-        self.delete(self._pk(item))
-        self.create(item)
-
-    def delete(self, item_id: str) -> None:
-        item = self.read(item_id)
-        self.store.drop(self._pk(item))
-
-    def read(self, item_id: str) -> ItemT:
-        for key in self.keys:
-            for item in self:
-                if key(item) == str(item_id):
-                    return item
-
-        raise DoesNotExistError(item_id)
-
-    def __iter__(self) -> Iterator[ItemT]:
-        return iter(self.store.values())
-
-    def __len__(self) -> int:
-        return self.store.count()

apexdevkit-1.28.2/apexdevkit/repository/interface.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable, Iterator
-from typing import Any, Protocol, TypeVar
-
-ItemT = TypeVar("ItemT")
-
-
-class Repository(Protocol[ItemT]):  # pragma: no cover
-    def create(self, item: ItemT) -> ItemT:
-        pass
-
-    def read(self, item_id: str) -> ItemT:
-        pass
-
-    def update(self, item: ItemT) -> None:
-        pass
-
-    def delete(self, item_id: str) -> None:
-        pass
-
-    def bind(self, **kwargs: Any) -> Repository[ItemT]:
-        pass
-
-    def __iter__(self) -> Iterator[ItemT]:
-        pass
-
-    def __len__(self) -> int:
-        pass
-
-
-class BatchRepository(Repository[ItemT], Protocol[ItemT]):  # pragma: no cover
-    def create_many(self, items: Iterable[ItemT]) -> Iterable[ItemT]:
-        pass
-
-    def update_many(self, items: Iterable[ItemT]) -> None:
-        pass