apexdevkit 1.9.4__tar.gz → 1.9.6__tar.gz

{apexdevkit-1.9.4 → apexdevkit-1.9.6}/PKG-INFO

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

{apexdevkit-1.9.4 → apexdevkit-1.9.6}/apexdevkit/fastapi/schema.py

@@ -5,22 +5,22 @@ from typing import Any, Callable, Iterable, List
 
 from pydantic import BaseModel, create_model
 
-from apexdevkit.http import JsonDict
+from apexdevkit.fluent import FluentDict
 from apexdevkit.testing import RestfulName
 
 
 class SchemaFields(ABC):
-    def id(self) -> JsonDict:
+    def id(self) -> FluentDict[type]:
         return self.readable().select("id")
 
-    def writable(self) -> JsonDict:
+    def writable(self) -> FluentDict[type]:
         return self.readable().drop("id")
 
-    def editable(self) -> JsonDict:
+    def editable(self) -> FluentDict[type]:
         return self.readable().drop("id")
 
     @abstractmethod
-    def readable(self) -> JsonDict:  # pragma: no cover
+    def readable(self) -> FluentDict[type]:  # pragma: no cover
         pass
 
 
@@ -38,26 +38,11 @@ class RestfulSchema:
             "UpdateManyItem", self.fields.editable().merge(self.fields.id())
         )
 
-        self._schema_for(
-            "Item",
-            JsonDict({self.name.singular: schema}),
-        )
-        self._schema_for(
-            "Collection",
-            JsonDict({self.name.plural: List[schema]}).with_a(count=int),
-        )
-
-        self._schema_for(
-            "CreateMany",
-            JsonDict({self.name.plural: List[create_schema]}),
-        )
-        self._schema_for(
-            "UpdateMany",
-            JsonDict({self.name.plural: List[update_many_item]}),
-        )
-        self._schema_for(
-            "ReplaceMany", JsonDict({self.name.plural: List[replace_schema]})
-        )
+        self._schema_for("Item", {self.name.singular: schema})
+        self._schema_for("Collection", {self.name.plural: List[schema], "count": int})
+        self._schema_for("CreateMany", {self.name.plural: List[create_schema]})
+        self._schema_for("UpdateMany", {self.name.plural: List[update_many_item]})
+        self._schema_for("ReplaceMany", {self.name.plural: List[replace_schema]})
 
     def _schema_for(self, action: str, fields: dict[str, Any]) -> type[BaseModel]:
         if action not in self.schemas:
@@ -81,13 +66,13 @@ class RestfulSchema:
 
         return self._schema_for(
             "NoDataResponse",
-            JsonDict().with_a(status=str).and_a(code=int).and_a(data=NoData),
+            FluentDict[type]().with_a(status=str).and_a(code=int).and_a(data=NoData),
         )
 
     def for_item(self) -> type[BaseModel]:
         return self._schema_for(
             "ItemResponse",
-            JsonDict()
+            FluentDict[type]()
             .with_a(status=str)
             .and_a(code=int)
             .and_a(data=self.schemas["Item"]),
@@ -96,7 +81,7 @@ class RestfulSchema:
     def for_collection(self) -> type[BaseModel]:
         return self._schema_for(
             "CollectionResponse",
-            JsonDict()
+            FluentDict[type]()
             .with_a(status=str)
             .and_a(code=int)
             .and_a(data=self.schemas["Collection"]),

apexdevkit-1.9.6/apexdevkit/fluent.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Generic, TypeVar
+
+ItemT = TypeVar("ItemT")
+
+
+class FluentDict(dict[str, ItemT]):
+    def value_of(self, key: str) -> FluentElement[ItemT]:
+        return FluentElement(self[key])
+
+    def and_a(self, **fields: ItemT) -> FluentDict[ItemT]:
+        return self.with_a(**fields)
+
+    def with_a(self, **fields: ItemT) -> FluentDict[ItemT]:
+        return self.merge(FluentDict[ItemT](fields))
+
+    def merge(self, other: FluentDict[ItemT]) -> FluentDict[ItemT]:
+        return FluentDict[ItemT]({**self, **other})
+
+    def drop(self, *keys: str) -> FluentDict[ItemT]:
+        return self.select(*set(self.keys()).difference(keys))
+
+    def select(self, *keys: str) -> FluentDict[ItemT]:
+        return FluentDict[ItemT]({k: v for k, v in self.items() if k in keys})
+
+
+@dataclass
+class FluentElement(Generic[ItemT]):
+    value: ItemT
+
+    def to(self, a_type: Callable[[ItemT], ConvertedT]) -> ConvertedT:
+        return a_type(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+
+ConvertedT = TypeVar("ConvertedT")

apexdevkit-1.9.6/apexdevkit/http/json.py

@@ -0,0 +1,5 @@
+from typing import Any
+
+from apexdevkit.fluent import FluentDict
+
+JsonDict = FluentDict[Any]

{apexdevkit-1.9.4 → apexdevkit-1.9.6}/apexdevkit/repository/connector.py

@@ -35,10 +35,8 @@ class SqliteInMemoryConnector:
 
 
 @dataclass
-class MongoDBConnector:
+class PyMongoConnector:
     dsn: str
 
     def connect(self) -> ContextManager[MongoClient[Any]]:
-        connection: MongoClient[Any] = MongoClient(self.dsn)
-
-        return connection
+        return MongoClient(self.dsn)

{apexdevkit-1.9.4 → apexdevkit-1.9.6}/apexdevkit/repository/database.py

@@ -1,11 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-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
+from typing import Any, ContextManager, Iterable, Protocol, Self
 
 _RawData = dict[str, Any]
 
@@ -46,59 +42,11 @@ 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.9.6/apexdevkit/repository/mongo.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ContextManager, Dict, Generic, Iterator, Protocol, TypeVar
+
+from pymongo import MongoClient, ReturnDocument
+from pymongo.collection import Collection
+from pymongo.results import DeleteResult, InsertOneResult
+
+from apexdevkit.error import DoesNotExistError, ExistsError
+from apexdevkit.formatter import Formatter
+
+
+class _Item(Protocol):  # pragma: no cover
+    @property
+    def id(self) -> Any:
+        pass
+
+
+ItemT = TypeVar("ItemT", bound=_Item)
+
+
+@dataclass
+class MongoRepository(Generic[ItemT]):
+    database: MongoDatabase
+    formatter: Formatter[dict[str, Any], ItemT]
+
+    def __iter__(self) -> Iterator[ItemT]:
+        for raw in self.database:
+            yield self.formatter.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.formatter.dump(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.formatter.load(raw)
+
+    def update(self, item: ItemT) -> None:
+        self.database.update(item.id, self.formatter.dump(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)
+
+
+@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})
+
+
+class MongoConnector(Protocol):  # pragma: no cover
+    def connect(self) -> ContextManager[MongoClient[Any]]:
+        pass

{apexdevkit-1.9.4 → apexdevkit-1.9.6}/apexdevkit/testing/rest.py

@@ -260,27 +260,13 @@ class RestResponse:
         return self.with_item(value)
 
     def with_item(self, value: Any) -> Self:
-        return self.with_data(
-            **{
-                self.resource.singular: dict(value)
-                if isinstance(value, JsonDict)
-                else value
-            }
-        )
+        return self.with_data(**{self.resource.singular: value})
 
     def and_collection(self, value: list[Any]) -> Self:
         return self.with_collection(value)
 
     def with_collection(self, values: list[Any]) -> Self:
-        return self.with_data(
-            **{
-                self.resource.plural: [
-                    dict(value) if isinstance(value, JsonDict) else value
-                    for value in values
-                ],
-            },
-            count=len(values),
-        )
+        return self.with_data(**{self.resource.plural: values}, count=len(values))
 
     def and_no_data(self) -> Self:
         return self.no_data()

{apexdevkit-1.9.4 → apexdevkit-1.9.6}/pyproject.toml

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

apexdevkit-1.9.4/apexdevkit/http/json.py

@@ -1,38 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Callable, TypeVar
-
-
-class JsonDict(dict[str, Any]):
-    def value_of(self, key: str) -> FluentElement:
-        return FluentElement(self[key])
-
-    def and_a(self, **fields: Any) -> JsonDict:
-        return self.with_a(**fields)
-
-    def with_a(self, **fields: Any) -> JsonDict:
-        return self.merge(JsonDict(fields))
-
-    def merge(self, other: JsonDict) -> JsonDict:
-        return JsonDict({**self, **other})
-
-    def drop(self, *keys: str) -> JsonDict:
-        return self.select(*set(self.keys()).difference(keys))
-
-    def select(self, *keys: str) -> JsonDict:
-        return JsonDict({k: v for k, v in self.items() if k in keys})
-
-
-@dataclass
-class FluentElement:
-    value: Any
-
-    def to(self, a_type: Callable[[Any], ConvertedT]) -> ConvertedT:
-        return a_type(self.value)
-
-    def __str__(self) -> str:
-        return str(self.value)
-
-
-ConvertedT = TypeVar("ConvertedT")

apexdevkit-1.9.4/apexdevkit/repository/mongo.py

@@ -1,79 +0,0 @@
-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")