apexdevkit 1.28.2__tar.gz → 1.29.1__tar.gz

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

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

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

@@ -6,8 +6,7 @@ from functools import cached_property
 from typing import Any, Generic, TypeVar
 
 from apexdevkit.formatter import Formatter
-from apexdevkit.repository.decorator import BruteForceBatch
-from apexdevkit.repository.interface import Repository
+from apexdevkit.repository import BruteForceBatch, Repository
 
 RawItem = Mapping[str, Any]
 RawCollection = Iterable[RawItem]

{apexdevkit-1.28.2 → apexdevkit-1.29.1}/apexdevkit/repository/__init__.py

@@ -1,29 +1,37 @@
-from apexdevkit.repository.base import RepositoryBase
-from apexdevkit.repository.database import (
+from apexdevkit.repository.core import (
+    BruteForceBatch,
     Connection,
     Connector,
     Cursor,
     Database,
     DatabaseCommand,
+    Repository,
+    RepositoryBase,
+    RepositoryDecorator,
 )
 from apexdevkit.repository.in_memory import (
     InMemoryByteStore,
     InMemoryRepository,
     KeyValueStore,
 )
-from apexdevkit.repository.interface import Repository
-from apexdevkit.repository.mssql import MsSqlRepository
+from apexdevkit.repository.sql import MsSqlRepository, SqliteRepository
 
 __all__ = [
+    # Core
+    "BruteForceBatch",
     "Connection",
     "Connector",
     "Cursor",
     "Database",
     "DatabaseCommand",
-    "InMemoryRepository",
-    "InMemoryByteStore",
-    "KeyValueStore",
     "Repository",
     "RepositoryBase",
+    "RepositoryDecorator",
+    # In-memory
+    "InMemoryByteStore",
+    "InMemoryRepository",
+    "KeyValueStore",
+    # SQL
     "MsSqlRepository",
+    "SqliteRepository",
 ]

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

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

{apexdevkit-1.28.2/apexdevkit/repository → apexdevkit-1.29.1/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.1/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.1/apexdevkit/repository/core/interface.py

@@ -0,0 +1,55 @@
+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.28.2/apexdevkit/repository/repository.py → apexdevkit-1.29.1/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.1/apexdevkit/repository/in_memory/__init__.py

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,51 @@
+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()

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

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Iterable, MutableMapping
+from dataclasses import dataclass, field
+from typing import Any, 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)
+
+    @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/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.1/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.1/apexdevkit/repository/sql}/mssql.py

@@ -9,7 +9,7 @@ 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
+from apexdevkit.repository.sql.field import NotNone, SqlFieldManager, _SqlField
 
 ItemT = TypeVar("ItemT")
 

{apexdevkit-1.28.2/apexdevkit/repository → apexdevkit-1.29.1/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.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "1.28.2"
+version = "1.29.1"
 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/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