apexdevkit 1.8.10__tar.gz → 1.9.2__tar.gz

{apexdevkit-1.8.10 → apexdevkit-1.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apexdevkit
-Version: 1.8.10
+Version: 1.9.2
 Summary: Apex Development Tools for python.
 Author: Apex Dev
 Author-email: dev@apex.ge
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: fastapi
 Requires-Dist: httpx
+Requires-Dist: pymongo
 Description-Content-Type: text/markdown
 
 # apexdevkit

{apexdevkit-1.8.10 → apexdevkit-1.9.2}/apexdevkit/fastapi/service.py

@@ -51,10 +51,10 @@ ItemT = TypeVar("ItemT")
 
 @dataclass
 class RestfulRepositoryBuilder(Generic[ItemT]):
-    formatter: Formatter[ItemT] = field(init=False)
+    formatter: Formatter[dict[str, Any], ItemT] = field(init=False)
     repository: Repository[Any, ItemT] = field(init=False)
 
-    def with_formatter(self, formatter: Formatter[ItemT]) -> Self:
+    def with_formatter(self, formatter: Formatter[dict[str, Any], ItemT]) -> Self:
         self.formatter = formatter
 
         return self
@@ -70,7 +70,7 @@ class RestfulRepositoryBuilder(Generic[ItemT]):
 
 @dataclass
 class _RestfulRepository(RestfulService, Generic[ItemT]):
-    formatter: Formatter[ItemT]
+    formatter: Formatter[dict[str, Any], ItemT]
     repository: Repository[Any, ItemT]
 
     def create_one(self, item: RawItem) -> RawItem:

apexdevkit-1.9.2/apexdevkit/formatter.py

@@ -0,0 +1,50 @@
+from copy import deepcopy
+from dataclasses import asdict, dataclass, field
+from typing import Any, Generic, Protocol, Self, TypeVar
+
+_SourceT = TypeVar("_SourceT")
+_TargetT = TypeVar("_TargetT")
+
+
+class Formatter(Protocol[_SourceT, _TargetT]):  # pragma: no cover
+    def load(self, source: _SourceT) -> _TargetT:
+        pass
+
+    def dump(self, target: _TargetT) -> _SourceT:
+        pass
+
+
+@dataclass
+class ListFormatter(Generic[_SourceT, _TargetT]):
+    inner: Formatter[_SourceT, _TargetT]
+
+    def load(self, source: list[_SourceT]) -> list[_TargetT]:
+        return [self.inner.load(item) for item in source]
+
+    def dump(self, target: list[_TargetT]) -> list[_SourceT]:
+        return [self.inner.dump(item) for item in target]
+
+
+@dataclass
+class DataclassFormatter(Generic[_TargetT]):
+    resource: type[_TargetT]
+    sub_formatters: dict[str, Formatter[Any, Any]] = field(default_factory=dict)
+
+    def and_nested(self, **formatters: Formatter[Any, Any]) -> Self:
+        return self.with_nested(**formatters)
+
+    def with_nested(self, **formatters: Formatter[Any, Any]) -> Self:
+        self.sub_formatters.update(formatters)
+
+        return self
+
+    def load(self, raw: dict[str, Any]) -> _TargetT:
+        raw = deepcopy(raw)
+
+        for key, formatter in self.sub_formatters.items():
+            raw[key] = formatter.load(raw.pop(key))
+
+        return self.resource(**raw)
+
+    def dump(self, item: _TargetT) -> dict[str, Any]:
+        return asdict(item)  # type: ignore

{apexdevkit-1.8.10 → apexdevkit-1.9.2}/apexdevkit/repository/connector.py

@@ -1,7 +1,9 @@
 import sqlite3
 from dataclasses import dataclass
 from functools import cached_property
-from typing import ContextManager
+from typing import Any, ContextManager
+
+from pymongo import MongoClient
 
 from apexdevkit.repository import Connection
 
@@ -30,3 +32,13 @@ class SqliteInMemoryConnector:
         connection.row_factory = sqlite3.Row
 
         return connection
+
+
+@dataclass
+class MongoDBConnector:
+    dsn: str
+
+    def connect(self) -> ContextManager[MongoClient[Any]]:
+        connection: MongoClient[Any] = MongoClient(self.dsn)
+
+        return connection

{apexdevkit-1.8.10 → apexdevkit-1.9.2}/apexdevkit/repository/database.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, ContextManager, Iterable, Protocol, Self
+from typing import Any, ContextManager, Dict, Iterable, Iterator, Protocol, Self
+
+from pymongo import MongoClient
+from pymongo.collection import Collection, ReturnDocument
+from pymongo.results import DeleteResult, InsertOneResult
 
 _RawData = dict[str, Any]
 
@@ -42,11 +46,59 @@ class Database:
         return [dict(raw or {}) for raw in raw]
 
 
+@dataclass
+class MongoDatabase:
+    connector: MongoConnector
+    database_name: str
+    collection_name: str
+
+    def collection(self, client: MongoClient[Any]) -> Collection[Any]:
+        return client[self.database_name][self.collection_name]
+
+    def __iter__(self) -> Iterator[Any]:
+        with self.connector.connect() as client:
+            for raw in self.collection(client).find():
+                yield raw
+
+    def __len__(self) -> int:
+        with self.connector.connect() as client:
+            return self.collection(client).count_documents({})
+
+    def create(self, item: Dict[str, Any]) -> InsertOneResult:
+        with self.connector.connect() as client:
+            return self.collection(client).insert_one(item)
+
+    def read(self, item_id: str) -> Dict[str, Any] | None:
+        with self.connector.connect() as client:
+            return self.collection(client).find_one({"id": item_id})
+
+    def update(self, item_id: str, item: Dict[str, Any]) -> Any:
+        with self.connector.connect() as client:
+            return self.collection(client).find_one_and_update(
+                {"id": item_id},
+                {"$set": item},
+                return_document=ReturnDocument.AFTER,
+            )
+
+    def delete(self, item_id: str) -> DeleteResult:
+        with self.connector.connect() as client:
+            return self.collection(client).delete_one({"id": item_id})
+
+    def delete_all(self) -> DeleteResult:
+        with self.connector.connect() as client:
+            return self.collection(client).delete_many({})
+
+
 class Connector(Protocol):  # pragma: no cover
     def connect(self) -> ContextManager[Connection]:
         pass
 
 
+class MongoConnector(Protocol):  # pragma: no cover
+    def connect(self) -> ContextManager[MongoClient[Any]]:
+        pass
+
+
 class Connection(Protocol):  # pragma: no cover
     def cursor(self) -> Cursor:
         pass

{apexdevkit-1.8.10 → apexdevkit-1.9.2}/apexdevkit/repository/in_memory.py

@@ -13,12 +13,13 @@ class _Item(Protocol):  # pragma: no cover
 
 
 ItemT = TypeVar("ItemT", bound=_Item)
+_Raw = dict[str, Any]
 
 
 @dataclass
 class InMemoryRepository(Generic[ItemT]):
-    formatter: Formatter[ItemT]
-    items: dict[str, dict[str, Any]] = field(default_factory=dict)
+    formatter: Formatter[_Raw, ItemT]
+    items: dict[str, _Raw] = field(default_factory=dict)
 
     _uniques: list[Criteria] = field(init=False, default_factory=list)
     _search_by: list[str] = field(init=False, default_factory=list)

apexdevkit-1.9.2/apexdevkit/repository/mongo.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Generic, Iterator, Protocol, TypeVar
+
+from apexdevkit.error import DoesNotExistError, ExistsError
+from apexdevkit.repository.database import MongoDatabase
+
+
+class _Item(Protocol):  # pragma: no cover
+    @property
+    def id(self) -> Any:
+        pass
+
+
+ItemT = TypeVar("ItemT", bound=_Item)
+
+
+@dataclass
+class MongoDBRepository(Generic[ItemT]):
+    database: MongoDatabase
+    table: MongoTable[ItemT]
+
+    def __iter__(self) -> Iterator[ItemT]:
+        for raw in self.database:
+            yield self.table.load(raw)
+
+    def __len__(self) -> int:
+        return len(self.database)
+
+    def create(self, item: ItemT) -> ItemT:
+        try:
+            self.read(item.id)
+            raise ExistsError(item).with_duplicate(
+                lambda i: f"_Item with id<{i.id}> already exists."
+            )
+        except DoesNotExistError:
+            self.database.create(self.table.to_dict(item))
+            return item
+
+    def create_many(self, items: list[ItemT]) -> list[ItemT]:
+        return [self.create(item) for item in items]
+
+    def read(self, item_id: str) -> ItemT:
+        raw = self.database.read(item_id)
+
+        if not raw:
+            raise DoesNotExistError(item_id)
+
+        return self.table.load(raw)
+
+    def update(self, item: ItemT) -> None:
+        self.database.update(
+            self.table.get_id(item),
+            self.table.to_dict(item),
+        )
+
+    def update_many(self, items: list[ItemT]) -> None:
+        for item in items:
+            self.update(item)
+
+    def delete(self, item_id: str) -> None:
+        result = self.database.delete(item_id)
+        if result.deleted_count == 0:
+            raise DoesNotExistError(item_id)
+
+    def delete_all(self) -> None:
+        self.database.delete_all()
+
+
+class MongoTable(Generic[ItemT]):
+    def to_dict(self, item: ItemT) -> Dict[str, Any]:
+        raise NotImplementedError("Not implemented")
+
+    def load(self, data: Dict[str, Any]) -> ItemT:
+        raise NotImplementedError("Not implemented")
+
+    def get_id(self, item: ItemT) -> str:
+        raise NotImplementedError("Not implemented")

{apexdevkit-1.8.10 → apexdevkit-1.9.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "apexdevkit"
-version = "1.8.10"
+version = "1.9.2"
 description = "Apex Development Tools for python."
 authors = ["Apex Dev <dev@apex.ge>"]
 readme = "README.md"
@@ -9,6 +9,7 @@ readme = "README.md"
 python = "^3.11"
 httpx = "*"
 fastapi = "*"
+pymongo = "*"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "*"

apexdevkit-1.8.10/apexdevkit/formatter.py

@@ -1,57 +0,0 @@
-from copy import deepcopy
-from dataclasses import asdict, dataclass, field
-from typing import Any, Generic, Protocol, Self, TypeVar
-
-ItemT = TypeVar("ItemT")
-
-
-class Formatter(Protocol[ItemT]):  # pragma: no cover
-    def load(self, raw: dict[str, Any]) -> ItemT:
-        pass
-
-    def dump(self, item: ItemT) -> dict[str, Any]:
-        pass
-
-
-@dataclass
-class ListFormatter(Generic[ItemT]):
-    inner: Formatter[ItemT]
-
-    def load(self, raw: list[dict[str, Any]]) -> list[ItemT]:
-        result = []
-        for item in raw:
-            result.append(self.inner.load(item))
-        return result
-
-    def dump(self, items: list[ItemT]) -> list[dict[str, Any]]:
-        result: list[dict[str, Any]] = []
-        for item in items:
-            result.append(self.inner.dump(item))
-        return result
-
-
-@dataclass
-class DataclassFormatter(Generic[ItemT]):
-    resource: type[ItemT]
-    sub_formatters: dict[str, Formatter[Any] | ListFormatter[Any]] = field(
-        default_factory=dict
-    )
-
-    def and_nested(self, **formatters: Formatter[Any] | ListFormatter[Any]) -> Self:
-        return self.with_nested(**formatters)
-
-    def with_nested(self, **formatters: Formatter[Any] | ListFormatter[Any]) -> Self:
-        self.sub_formatters.update(formatters)
-
-        return self
-
-    def load(self, raw: dict[str, Any]) -> ItemT:
-        raw = deepcopy(raw)
-
-        for key, formatter in self.sub_formatters.items():
-            raw[key] = formatter.load(raw.pop(key))
-
-        return self.resource(**raw)
-
-    def dump(self, item: ItemT) -> dict[str, Any]:
-        return asdict(item)  # type: ignore