apexdevkit 1.29.1__tar.gz → 1.29.3__tar.gz

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/PKG-INFO

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

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/apexdevkit/fastapi/service.py

@@ -3,10 +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 import BruteForceBatch, Repository
+from apexdevkit.repository.core import ItemT
 
 RawItem = Mapping[str, Any]
 RawCollection = Iterable[RawItem]
@@ -58,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]
@@ -69,7 +67,7 @@ class RestfulRepository(RestfulService, Generic[ItemT]):
 
     @cached_property
     def _batch(self) -> BruteForceBatch[ItemT]:
-        return BruteForceBatch(self.repository)
+        return BruteForceBatch(inner=self.repository)
 
     def create_one(self, item: RawItem) -> RawItem:
         return self.formatter.dump(self.repository.create(self.formatter.load(item)))

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/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.1 → apexdevkit-1.29.3}/apexdevkit/repository/__init__.py

@@ -1,22 +1,25 @@
-from apexdevkit.repository.core import (
+from .core import (
     BruteForceBatch,
     Connection,
     Connector,
     Cursor,
     Database,
     DatabaseCommand,
+    NoRepository,
     Repository,
-    RepositoryBase,
     RepositoryDecorator,
 )
-from apexdevkit.repository.in_memory import (
+from .core.interface import Entity
+from .in_memory import (
+    CacheMixin,
     InMemoryByteStore,
     InMemoryRepository,
     KeyValueStore,
 )
-from apexdevkit.repository.sql import MsSqlRepository, SqliteRepository
+from .sql import MsSqlRepository, SqliteRepository
 
 __all__ = [
+    "Entity",
     # Core
     "BruteForceBatch",
     "Connection",
@@ -24,10 +27,11 @@ __all__ = [
     "Cursor",
     "Database",
     "DatabaseCommand",
+    "NoRepository",
     "Repository",
-    "RepositoryBase",
     "RepositoryDecorator",
     # In-memory
+    "CacheMixin",
     "InMemoryByteStore",
     "InMemoryRepository",
     "KeyValueStore",

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/apexdevkit/repository/core/__init__.py

@@ -6,8 +6,9 @@ from .database import (
     Database,
     DatabaseCommand,
 )
-from .decorator import BruteForceBatch, RepositoryDecorator
-from .interface import Repository, RepositoryBase
+from .decorator import BruteForceBatch, NoRepository, RepositoryDecorator
+from .interface import Entity, ItemT, KeyFn, Repository
+from .mixin import ContainsMixin
 
 __all__ = [
     # Database
@@ -21,6 +22,11 @@ __all__ = [
     "RepositoryDecorator",
     "BruteForceBatch",
     # Interface
+    "Entity",
+    "ItemT",
+    "KeyFn",
     "Repository",
-    "RepositoryBase",
+    "NoRepository",
+    # Mixin
+    "ContainsMixin",
 ]

apexdevkit-1.29.3/apexdevkit/repository/core/decorator.py

@@ -0,0 +1,63 @@
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass, field
+
+from .interface import ItemT, Repository
+
+
+class NoRepository(Repository[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
+
+    def __contains__(self, item: object) -> bool:
+        raise NotImplementedError
+
+
+@dataclass(frozen=True, kw_only=True)
+class RepositoryDecorator(Repository[ItemT]):  # pragma: no cover
+    inner: Repository[ItemT] = field(default_factory=NoRepository)
+
+    def create(self, item: ItemT) -> ItemT:
+        return self.inner.create(item)
+
+    def read(self, item_id: str) -> ItemT:
+        return self.inner.read(item_id)
+
+    def update(self, item: ItemT) -> None:
+        self.inner.update(item)
+
+    def delete(self, item_id: str) -> None:
+        self.inner.delete(item_id)
+
+    def __iter__(self) -> Iterator[ItemT]:
+        return iter(self.inner)
+
+    def __len__(self) -> int:
+        return len(self.inner)
+
+    def __contains__(self, item: object) -> bool:
+        return item in self.inner
+
+
+@dataclass(frozen=True, kw_only=True)
+class BruteForceBatch(RepositoryDecorator[ItemT]):
+    def create_many(self, items: Iterable[ItemT]) -> Iterable[ItemT]:
+        return [self.inner.create(item) for item in items]
+
+    def update_many(self, items: Iterable[ItemT]) -> None:
+        for item in items:
+            self.inner.update(item)

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Collection, Iterable
+from dataclasses import dataclass, field
+from typing import 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(Collection[ItemT], 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
+
+
+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

apexdevkit-1.29.3/apexdevkit/repository/core/mixin.py

@@ -0,0 +1,24 @@
+from typing import Generic
+
+from apexdevkit.error import DoesNotExistError
+from apexdevkit.repository.core import Entity, ItemT
+
+
+class ContainsMixin(Generic[ItemT]):
+    def __contains__(self, item: object) -> bool:
+        match item:
+            case Entity():
+                return self.contains_id(item.id)
+            case _:
+                return False
+
+    def contains_id(self, value: str) -> bool:
+        try:
+            self.read(value)
+        except DoesNotExistError:
+            return False
+
+        return True
+
+    def read(self, item_id: str) -> ItemT:
+        raise NotImplementedError

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/apexdevkit/repository/core/multi.py

@@ -7,7 +7,8 @@ from typing import Generic
 from apexdevkit.error import DoesNotExistError
 from apexdevkit.formatter import Formatter
 
-from .interface import ItemT, Repository, RepositoryBase
+from . import ContainsMixin
+from .interface import ItemT, Repository
 
 
 @dataclass(frozen=True)
@@ -20,7 +21,7 @@ class NoFormatter(Generic[ItemT]):
 
 
 @dataclass(frozen=True)
-class MultipleRepository(RepositoryBase[ItemT]):
+class MultipleRepository(ContainsMixin[ItemT], Repository[ItemT]):
     repositories: list[_InnerRepository[ItemT]]
 
     def create(self, item: ItemT) -> ItemT:

apexdevkit-1.29.3/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.3/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.3/apexdevkit/repository/in_memory/repository.py

@@ -0,0 +1,69 @@
+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 ContainsMixin, ItemT, KeyFn, Repository
+
+from .store import InMemoryByteStore, KeyValueStore
+
+
+@dataclass(frozen=True)
+class InMemoryRepository(ContainsMixin[ItemT], Repository[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.1 → apexdevkit-1.29.3}/apexdevkit/repository/in_memory/store.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from collections import defaultdict
-from collections.abc import Iterable, MutableMapping
+from collections.abc import Iterable
 from dataclasses import dataclass, field
-from typing import Any, Generic, Protocol
+from typing import Generic, Protocol
 
 from apexdevkit.formatter import Formatter, PickleFormatter
 from apexdevkit.repository.core.interface import ItemT
@@ -47,16 +46,3 @@ class InMemoryByteStore(Generic[ItemT]):
     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()

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/apexdevkit/repository/sql/mssql.py

@@ -2,20 +2,25 @@ 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.field import NotNone, SqlFieldManager, _SqlField
+from apexdevkit.repository.core import (
+    ContainsMixin,
+    Database,
+    DatabaseCommand,
+    ItemT,
+    Repository,
+)
 
-ItemT = TypeVar("ItemT")
+from .field import NotNone, SqlFieldManager, _SqlField
 
 
 @dataclass
-class MsSqlRepository(RepositoryBase[ItemT]):
+class MsSqlRepository(ContainsMixin[ItemT], Repository[ItemT]):
     db: Database
     table: SqlTable[ItemT]
 

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/apexdevkit/repository/sql/sqlite.py

@@ -7,13 +7,19 @@ 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.core.interface import ItemT
-from apexdevkit.repository.sql.field import NotNone, SqlFieldManager, _SqlField
+from apexdevkit.repository.core import (
+    ContainsMixin,
+    Database,
+    DatabaseCommand,
+    ItemT,
+    Repository,
+)
+
+from .field import NotNone, SqlFieldManager, _SqlField
 
 
 @dataclass(frozen=True)
-class SqliteRepository(RepositoryBase[ItemT]):
+class SqliteRepository(ContainsMixin[ItemT], Repository[ItemT]):
     db: Database
     table: SqlTable[ItemT]
 

{apexdevkit-1.29.1 → apexdevkit-1.29.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "1.29.1"
+version = "1.29.3"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [

apexdevkit-1.29.1/apexdevkit/repository/core/decorator.py

@@ -1,37 +0,0 @@
-from collections.abc import Iterable, Iterator
-from dataclasses import dataclass
-from typing import Generic
-
-from .interface import ItemT, Repository
-
-
-@dataclass
-class RepositoryDecorator(Generic[ItemT]):  # pragma: no cover
-    inner: Repository[ItemT]
-
-    def create(self, item: ItemT) -> ItemT:
-        return self.inner.create(item)
-
-    def read(self, item_id: str) -> ItemT:
-        return self.inner.read(item_id)
-
-    def update(self, item: ItemT) -> None:
-        self.inner.update(item)
-
-    def delete(self, item_id: str) -> None:
-        self.inner.delete(item_id)
-
-    def __iter__(self) -> Iterator[ItemT]:
-        return self.inner.__iter__()
-
-    def __len__(self) -> int:
-        return self.inner.__len__()
-
-
-class BruteForceBatch(RepositoryDecorator[ItemT]):
-    def create_many(self, items: Iterable[ItemT]) -> Iterable[ItemT]:
-        return [self.inner.create(item) for item in items]
-
-    def update_many(self, items: Iterable[ItemT]) -> None:
-        for item in items:
-            self.inner.update(item)

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

@@ -1,55 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Callable, Iterable, Iterator
-from typing import Generic, Protocol, TypeVar
-
-ItemT = TypeVar("ItemT")
-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.29.1/apexdevkit/repository/in_memory/__init__.py

@@ -1,8 +0,0 @@
-from apexdevkit.repository.in_memory.builder import InMemoryRepository
-from apexdevkit.repository.in_memory.store import InMemoryByteStore, KeyValueStore
-
-__all__ = [
-    "InMemoryRepository",
-    "InMemoryByteStore",
-    "KeyValueStore",
-]

apexdevkit-1.29.1/apexdevkit/repository/in_memory/builder.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from contextlib import suppress
-from dataclasses import dataclass, field
-from typing import Generic
-
-from apexdevkit.error import ExistsError
-from apexdevkit.key_fn import AttributeKey
-from apexdevkit.repository.core.interface import ItemT, KeyFn, Repository
-
-from .multi_key import MultiKeyRepository
-from .single_key import SingleKeyRepository
-from .store import InMemoryByteStore, KeyValueStore
-
-
-@dataclass(frozen=True)
-class InMemoryRepository(Generic[ItemT]):
-    store: KeyValueStore[ItemT] = field(default_factory=lambda: InMemoryByteStore())
-    keys: list[KeyFn[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: KeyFn[ItemT]) -> InMemoryRepository[ItemT]:
-        return self.with_key(function)
-
-    def with_key(self, function: KeyFn[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 MultiKeyRepository(self.store, keys=self.keys)

apexdevkit-1.29.1/apexdevkit/repository/in_memory/multi_key.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterator
-from dataclasses import dataclass, field
-
-from apexdevkit.error import DoesNotExistError, ExistsError
-from apexdevkit.repository.core.interface import ItemT, KeyFn, RepositoryBase
-
-from .store import KeyValueStore
-
-
-@dataclass
-class MultiKeyRepository(RepositoryBase[ItemT]):
-    store: KeyValueStore[ItemT]
-
-    keys: list[KeyFn[ItemT]] = field(default_factory=list)
-
-    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.29.1/apexdevkit/repository/in_memory/single_key.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterator
-from dataclasses import dataclass
-
-from apexdevkit.error import DoesNotExistError, ExistsError
-from apexdevkit.repository.core.interface import ItemT, KeyFn, RepositoryBase
-
-from .store import KeyValueStore
-
-
-@dataclass
-class SingleKeyRepository(RepositoryBase[ItemT]):
-    store: KeyValueStore[ItemT]
-    pk: KeyFn[ItemT]
-
-    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()