apexdevkit 1.13.7__tar.gz → 1.13.9__tar.gz

{apexdevkit-1.13.7 → apexdevkit-1.13.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apexdevkit
-Version: 1.13.7
+Version: 1.13.9
 Summary: Apex Development Tools for python.
 Author: Apex Dev
 Author-email: dev@apex.ge

{apexdevkit-1.13.7 → apexdevkit-1.13.9}/apexdevkit/fastapi/router.py

@@ -281,7 +281,6 @@ class RestfulRouter:
 
     def with_sub_resource(self, **names: APIRouter) -> Self:
         for name, router in names.items():
-            print(self.item_path)
             self.router.include_router(router, prefix=f"{self.item_path}/{name}")
 
         return self

{apexdevkit-1.13.7 → apexdevkit-1.13.9}/apexdevkit/formatter.py

@@ -14,6 +14,15 @@ class Formatter(Protocol[_SourceT, _TargetT]):  # pragma: no cover
         pass
 
 
+@dataclass
+class NoFormatter(Formatter[Any, Any]):
+    def load(self, source: Any) -> Any:
+        return source
+
+    def dump(self, target: Any) -> Any:
+        return target
+
+
 @dataclass
 class ListFormatter(Generic[_SourceT, _TargetT]):
     inner: Formatter[_SourceT, _TargetT]

apexdevkit-1.13.9/apexdevkit/key_fn.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class AttributeKey:
+    name: str
+
+    def __call__(self, item: Any) -> str:
+        return str(getattr(item, self.name))

{apexdevkit-1.13.7 → apexdevkit-1.13.9}/apexdevkit/repository/__init__.py

@@ -6,7 +6,11 @@ from apexdevkit.repository.database import (
     Database,
     DatabaseCommand,
 )
-from apexdevkit.repository.in_memory import InMemoryRepository
+from apexdevkit.repository.in_memory import (
+    InMemoryKeyValueStore,
+    InMemoryRepository,
+    KeyValueStore,
+)
 from apexdevkit.repository.interface import Repository
 
 __all__ = [
@@ -16,6 +20,8 @@ __all__ = [
     "Database",
     "DatabaseCommand",
     "InMemoryRepository",
+    "InMemoryKeyValueStore",
+    "KeyValueStore",
     "Repository",
     "RepositoryBase",
 ]

apexdevkit-1.13.9/apexdevkit/repository/in_memory.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Generic, Iterable, Iterator, Protocol, Self
+
+from apexdevkit.error import DoesNotExistError, ExistsError
+from apexdevkit.formatter import Formatter, NoFormatter
+from apexdevkit.key_fn import AttributeKey
+from apexdevkit.repository import RepositoryBase
+from apexdevkit.repository.interface import ItemT, Repository
+
+KeyFunction = Callable[[Any], str]
+_Raw = dict[str, Any]
+
+
+@dataclass
+class InMemoryRepository(Generic[ItemT]):
+    store: KeyValueStore[ItemT] = field(default_factory=lambda: InMemoryKeyValueStore())
+    keys: list[KeyFunction] = field(default_factory=list)
+    seeds: list[ItemT] = field(default_factory=list)
+
+    def with_formatter(self, value: Formatter[_Raw, ItemT]) -> Self:
+        return self.with_store(InMemoryKeyValueStore(value))
+
+    def with_store(self, value: KeyValueStore[ItemT]) -> Self:
+        self.store = value
+
+        return self
+
+    def and_key(self, function: KeyFunction) -> Self:
+        return self.with_key(function)
+
+    def with_key(self, function: KeyFunction) -> Self:
+        self.keys.append(function)
+
+        return self
+
+    def and_seeded(self, *items: ItemT) -> Self:
+        return self.with_seeded(*items)
+
+    def with_seeded(self, *items: ItemT) -> Self:
+        self.seeds.extend(items)
+
+        return self
+
+    def build(self) -> Repository[ItemT]:
+        return self._seed(self._create())
+
+    def _seed(self, repository: Repository[ItemT]) -> Repository[ItemT]:
+        for seed in self.seeds:
+            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 InMemoryKeyValueStore(Generic[ItemT]):
+    formatter: Formatter[_Raw, ItemT] = field(default_factory=NoFormatter)
+    items: dict[str, _Raw] = 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 _SingleKeyRepository(RepositoryBase[ItemT]):
+    store: KeyValueStore[ItemT]
+    pk: KeyFunction
+
+    def bind(self, **kwargs: 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:
+            raise DoesNotExistError(item_id)
+
+    def read(self, item_id: str) -> ItemT:
+        try:
+            return self.store.get(item_id)
+        except KeyError:
+            raise DoesNotExistError(item_id)
+
+    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] = field(default_factory=list)
+
+    def bind(self, **kwargs: 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:
+            error = ExistsError(existing)
+
+            for key in self.keys:
+                if key(new) == key(existing):
+                    error.with_duplicate(key)
+
+            error.fire()
+
+    def _pk(self, item: ItemT) -> Any:
+        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.13.7 → apexdevkit-1.13.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "apexdevkit"
-version = "1.13.7"
+version = "1.13.9"
 description = "Apex Development Tools for python."
 authors = ["Apex Dev <dev@apex.ge>"]
 readme = "README.md"

apexdevkit-1.13.7/apexdevkit/repository/alternative/__init__.py

@@ -1,7 +0,0 @@
-from apexdevkit.repository.alternative.base import MemoryPersistence
-from apexdevkit.repository.alternative.formatter_repository import FormatterRepository
-
-__all__ = [
-    "MemoryPersistence",
-    "FormatterRepository",
-]

apexdevkit-1.13.7/apexdevkit/repository/alternative/base.py

@@ -1,49 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Any, Iterator
-
-from apexdevkit.error import DoesNotExistError, ExistsError
-
-_Raw = dict[str, Any]
-
-
-@dataclass
-class MemoryPersistence:  # pragma: no cover
-    items: dict[str, _Raw] = field(init=False, default_factory=dict)
-
-    def create(self, item: _Raw) -> _Raw:
-        self._ensure_does_not_exist(item)
-        self.items[item["id"]] = item
-
-        return item
-
-    def _ensure_does_not_exist(self, new: _Raw) -> None:
-        if new["id"] in self.items.keys():
-            error = ExistsError(self.items[new["id"]])
-            error.with_duplicate(lambda item: f"id<{item['id']}>")
-            error.fire()
-
-    def read(self, item_id: str) -> _Raw:
-        self._ensure_exists(item_id)
-
-        return self.items[item_id]
-
-    def _ensure_exists(self, item_id: str) -> None:
-        if item_id not in self.items.keys():
-            raise DoesNotExistError(item_id)
-
-    def update(self, item: _Raw) -> None:
-        self._ensure_exists(item["id"])
-
-        self.delete(item["id"])
-        self.create(item)
-
-    def delete(self, item_id: str) -> None:
-        self._ensure_exists(item_id)
-
-        self.items.pop(item_id)
-
-    def __iter__(self) -> Iterator[_Raw]:
-        yield from self.items.values()
-
-    def __len__(self) -> int:
-        return len(self.items)

apexdevkit-1.13.7/apexdevkit/repository/alternative/formatter_repository.py

@@ -1,50 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Generic, Iterator, Self
-
-from apexdevkit.formatter import Formatter
-from apexdevkit.repository.alternative import MemoryPersistence
-from apexdevkit.repository.interface import ItemT
-
-_Raw = dict[str, Any]
-
-
-@dataclass
-class FormatterRepository(Generic[ItemT]):
-    base: MemoryPersistence
-    formatter: Formatter[_Raw, ItemT]
-
-    def create(self, item: ItemT) -> ItemT:
-        return self.formatter.load(self.base.create(self.formatter.dump(item)))
-
-    def create_many(self, items: list[ItemT]) -> list[ItemT]:
-        return [
-            self.formatter.load(
-                self.base.create(
-                    self.formatter.dump(item),
-                ),
-            )
-            for item in items
-        ]
-
-    def read(self, item_id: str) -> ItemT:
-        return self.formatter.load(self.base.read(item_id))
-
-    def update(self, item: ItemT) -> None:
-        self.base.update(self.formatter.dump(item))
-
-    def update_many(self, items: list[ItemT]) -> None:
-        for item in items:
-            self.base.update(self.formatter.dump(item))
-
-    def delete(self, item_id: str) -> None:
-        self.base.delete(item_id)
-
-    def bind(self, **kwargs: Any) -> Self:
-        return self
-
-    def __iter__(self) -> Iterator[ItemT]:
-        for raw in self.base:
-            yield self.formatter.load(raw)
-
-    def __len__(self) -> int:
-        return len(self.base)

apexdevkit-1.13.7/apexdevkit/repository/in_memory.py

@@ -1,90 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Any, Callable, Iterable, Iterator, Self
-
-from apexdevkit.error import DoesNotExistError, ExistsError
-from apexdevkit.formatter import Formatter
-from apexdevkit.repository import RepositoryBase
-from apexdevkit.repository.interface import ItemT
-
-KeyFunction = Callable[[Any], str]
-_Raw = dict[str, Any]
-
-
-@dataclass
-class AttributeKey:
-    name: str
-
-    def __call__(self, item: Any) -> str:
-        return str(getattr(item, self.name))
-
-
-@dataclass
-class InMemoryRepository(RepositoryBase[ItemT]):
-    formatter: Formatter[_Raw, ItemT]
-    items: dict[str, _Raw] = field(default_factory=dict)
-
-    _keys: list[KeyFunction] = field(init=False, default_factory=list)
-
-    def bind(self, **kwargs: Any) -> Self:
-        return self
-
-    def with_key(self, function: KeyFunction) -> Self:
-        self._keys.append(function)
-
-        return self
-
-    def with_seeded(self, *items: ItemT) -> Self:
-        for item in items:
-            self.create(item)
-
-        return self
-
-    def create(self, item: ItemT) -> ItemT:
-        self._ensure_does_not_exist(item)
-        self.items[self._pk(item)] = self.formatter.dump(item)
-
-        return item
-
-    def _ensure_does_not_exist(self, new: ItemT) -> None:
-        for existing in self:
-            error = ExistsError(existing)
-
-            for key in self._keys:
-                if key(new) == key(existing):
-                    error.with_duplicate(key)
-
-            error.fire()
-
-    def _pk(self, item: ItemT) -> Any:
-        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)
-        del self.items[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]:
-        yield from [self.formatter.load(raw) for raw in self.items.values()]
-
-    def __len__(self) -> int:
-        return len(self.items)
-
-    def search(self, **kwargs: Any) -> Iterable[ItemT]:
-        items = []
-
-        for item in self.items.values():
-            if kwargs.items() <= item.items():
-                items.append(self.formatter.load(item))
-
-        return items