apexdevkit 1.0.1__tar.gz → 1.1.1__tar.gz

{apexdevkit-1.0.1 → apexdevkit-1.1.1}/PKG-INFO

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

apexdevkit-1.1.1/apexdevkit/fastapi/router.py

@@ -0,0 +1,251 @@
+from dataclasses import dataclass, field
+from typing import Annotated, Any, Iterable, Self, TypeVar
+
+from fastapi import APIRouter, Depends
+from fastapi.responses import JSONResponse
+
+from apexdevkit.error import DoesNotExistError, ExistsError
+from apexdevkit.fastapi.schema import RestfulSchema
+from apexdevkit.fastapi.service import RestfulService, _RawCollection, _RawItem
+from apexdevkit.testing import RestfulName
+
+_Response = JSONResponse | dict[str, Any]
+
+
+@dataclass
+class RestfulResponse:
+    name: RestfulName
+
+    @classmethod
+    def from_dataclass(cls, value: type[Any]) -> "RestfulResponse":
+        return cls(name=RestfulName(value.__name__.lower()))
+
+    def _response(self, code: int, data: Any, error: str = "") -> dict[str, Any]:
+        content: dict[str, Any] = {"code": code, "status": "success"}
+
+        if error:
+            content["status"] = "fail"
+            content["error"] = {"message": error}
+
+        match data:
+            case None:
+                content["data"] = {}
+            case list():
+                content["data"] = {self.name.plural: data, "count": len(data)}
+            case _:
+                content["data"] = {self.name.singular: data}
+
+        return content
+
+    def ok(self) -> dict[str, Any]:
+        return self._response(200, data=None)
+
+    def not_found(self, e: DoesNotExistError) -> dict[str, Any]:
+        name = self.name.singular.capitalize()
+
+        return self._response(
+            404,
+            data={"id": str(e.id)},
+            error=f"An item<{name}> with id<{e.id}> does not exist.",
+        )
+
+    def exists(self, e: ExistsError) -> dict[str, Any]:
+        name = self.name.singular.capitalize()
+
+        return self._response(
+            409,
+            data={"id": str(e.id)},
+            error=f"An item<{name}> with the {e} already exists.",
+        )
+
+    def created_one(self, item: Any) -> dict[str, Any]:
+        return self._response(201, item)
+
+    def created_many(self, items: Iterable[Any]) -> dict[str, Any]:
+        return self._response(201, list(items))
+
+    def found_one(self, item: Any) -> dict[str, Any]:
+        return self._response(200, item)
+
+    def found_many(self, items: list[Any]) -> dict[str, Any]:
+        return self._response(200, items)
+
+
+T = TypeVar("T")
+
+
+@dataclass
+class RestfulRouter:
+    schema: RestfulSchema = field(init=False)
+    response: RestfulResponse = field(init=False)
+    service: RestfulService = field(init=False)
+
+    router: APIRouter = field(init=False, default_factory=APIRouter)
+
+    @classmethod
+    def from_dataclass(cls, value: Any) -> "RestfulRouter":
+        return (
+            cls()
+            .with_schema(RestfulSchema.from_dataclass(value))
+            .with_response(RestfulResponse.from_dataclass(value))
+        )
+
+    def with_schema(self, value: RestfulSchema) -> Self:
+        self.schema = value
+
+        return self
+
+    def with_response(self, value: RestfulResponse) -> Self:
+        self.response = value
+
+        return self
+
+    def with_service(self, value: RestfulService) -> Self:
+        self.service = value
+
+        return self
+
+    def with_create_one_endpoint(self, is_documented: bool = True) -> Self:
+        schema = self.schema.for_create_one()
+
+        @self.router.post(
+            "",
+            status_code=201,
+            responses={409: {}},
+            response_model=self.schema.for_item(),
+            include_in_schema=is_documented,
+        )
+        def create_one(item: Annotated[_RawItem, Depends(schema)]) -> _Response:
+            try:
+                item = self.service.create_one(item)
+            except ExistsError as e:
+                return JSONResponse(self.response.exists(e), 409)
+
+            return self.response.created_one(item)
+
+        return self
+
+    def with_create_many_endpoint(self, is_documented: bool = True) -> Self:
+        schema = self.schema.for_create_many()
+
+        @self.router.post(
+            "/batch",
+            status_code=201,
+            responses={409: {}},
+            response_model=self.schema.for_collection(),
+            include_in_schema=is_documented,
+        )
+        def create_many(items: Annotated[_RawCollection, Depends(schema)]) -> _Response:
+            try:
+                return self.response.created_many(self.service.create_many(items))
+            except ExistsError as e:
+                return JSONResponse(self.response.exists(e), 409)
+
+        return self
+
+    def with_read_one_endpoint(self, is_documented: bool = True) -> Self:
+        schema = self.schema.for_item()
+
+        @self.router.get(
+            "/{item_id}",
+            status_code=200,
+            responses={404: {}},
+            response_model=schema,
+            include_in_schema=is_documented,
+        )
+        def read_one(item_id: str) -> _Response:
+            try:
+                return self.response.found_one(self.service.read_one(item_id))
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+
+        return self
+
+    def with_read_all_endpoint(self, is_documented: bool = True) -> Self:
+        schema = self.schema.for_collection()
+
+        @self.router.get(
+            "",
+            status_code=200,
+            responses={},
+            response_model=schema,
+            include_in_schema=is_documented,
+        )
+        def read_all() -> _Response:
+            return self.response.found_many(list(self.service.read_all()))
+
+        return self
+
+    def with_update_one_endpoint(self, is_documented: bool = True) -> Self:
+        schema = self.schema.for_update_one()
+
+        @self.router.patch(
+            "/{item_id}",
+            status_code=200,
+            responses={404: {}},
+            response_model=self.schema.for_no_data(),
+            include_in_schema=is_documented,
+        )
+        def update_one(
+            item_id: str,
+            updates: Annotated[_RawItem, Depends(schema)],
+        ) -> _Response:
+            try:
+                self.service.update_one(item_id, **updates)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+
+            return self.response.ok()
+
+        return self
+
+    def with_update_many_endpoint(self, is_documented: bool = True) -> Self:
+        schema = self.schema.for_update_many()
+
+        @self.router.patch(
+            "",
+            status_code=200,
+            responses={},
+            response_model=self.schema.for_no_data(),
+            include_in_schema=is_documented,
+        )
+        def update_many(items: Annotated[_RawCollection, Depends(schema)]) -> _Response:
+            self.service.update_many(items)
+
+            return self.response.ok()
+
+        return self
+
+    def with_delete_one_endpoint(self, is_documented: bool = True) -> Self:
+        schema = self.schema.for_no_data()
+
+        @self.router.delete(
+            "/{item_id}",
+            status_code=200,
+            responses={404: {}},
+            response_model=schema,
+            include_in_schema=is_documented,
+        )
+        def delete_one(item_id: str) -> _Response:
+            try:
+                self.service.delete_one(item_id)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+
+            return self.response.ok()
+
+        return self
+
+    def default(self) -> Self:
+        return (
+            self.with_create_one_endpoint()
+            .with_create_many_endpoint()
+            .with_read_one_endpoint()
+            .with_read_all_endpoint()
+            .with_update_one_endpoint()
+            .with_update_many_endpoint()
+            .with_delete_one_endpoint()
+        )
+
+    def build(self) -> APIRouter:
+        return self.router

apexdevkit-1.1.1/apexdevkit/fastapi/schema.py

@@ -0,0 +1,116 @@
+from dataclasses import dataclass, field
+from typing import Any, Callable, Iterable, List
+
+from pydantic import BaseModel, create_model
+
+from apexdevkit.http import JsonDict
+from apexdevkit.testing import RestfulName
+
+
+@dataclass
+class RestfulSchema:
+    name: RestfulName
+    fields: JsonDict
+
+    schemas: dict[str, type[BaseModel]] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        schema = self._schema_for("", self.fields)
+        create_schema = self._schema_for("Create", self.fields.drop("id"))
+        self._schema_for("Update", self.fields.drop("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[schema]}),
+        )
+
+    @classmethod
+    def from_dataclass(cls, value: Any) -> "RestfulSchema":
+        return cls(
+            name=RestfulName(value.__name__.lower()),
+            fields=JsonDict(value.__annotations__),
+        )
+
+    def for_no_data(self) -> type[BaseModel]:
+        class NoData(BaseModel):
+            pass
+
+        return self._schema_for(
+            "NoDataResponse",
+            JsonDict().with_a(status=str).and_a(code=int).and_a(data=NoData),
+        )
+
+    def for_item(self) -> type[BaseModel]:
+        return self._schema_for(
+            "ItemResponse",
+            JsonDict()
+            .with_a(status=str)
+            .and_a(code=int)
+            .and_a(data=self.schemas["Item"]),
+        )
+
+    def for_collection(self) -> type[BaseModel]:
+        return self._schema_for(
+            "CollectionResponse",
+            JsonDict()
+            .with_a(status=str)
+            .and_a(code=int)
+            .and_a(data=self.schemas["Collection"]),
+        )
+
+    def for_create_one(self) -> Callable[[BaseModel], dict[str, Any]]:
+        schema = self.schemas["Create"]
+
+        def _(request: schema) -> dict[str, Any]:
+            return request.model_dump()
+
+        return _
+
+    def for_create_many(self) -> Callable[[BaseModel], Iterable[dict[str, Any]]]:
+        schema = self.schemas["CreateMany"]
+
+        def _(request: schema) -> Iterable[dict[str, Any]]:
+            return [dict(item) for item in request.model_dump()[self.name.plural]]
+
+        return _
+
+    def for_update_one(self) -> Callable[[BaseModel], dict[str, Any]]:
+        schema = self.schemas["Update"]
+
+        def _(request: schema):
+            return request.model_dump()
+
+        return _
+
+    def for_update_many(self) -> Callable[[BaseModel], Iterable[dict[str, Any]]]:
+        schema = self.schemas["UpdateMany"]
+
+        def _(request: schema) -> Iterable[dict[str, Any]]:
+            return [dict(item) for item in request.model_dump()[self.name.plural]]
+
+        return _
+
+    def _schema_for(self, action: str, fields: dict[str, Any]) -> type[BaseModel]:
+        if action not in self.schemas:
+            self.schemas[action] = create_model(
+                self.name.singular.capitalize() + action,
+                **{
+                    field_name: (field_type, ...)
+                    for field_name, field_type in fields.items()
+                },
+            )
+
+        return self.schemas[action]

apexdevkit-1.1.1/apexdevkit/fastapi/service.py

@@ -0,0 +1,85 @@
+from dataclasses import asdict, dataclass, replace
+from typing import Any, Iterable, Protocol
+
+from apexdevkit.repository import InMemoryRepository
+
+_RawItem = dict[str, Any]
+_RawCollection = Iterable[_RawItem]
+
+
+class RestfulService(Protocol):
+    def create_one(self, item: _RawItem) -> _RawItem:
+        pass
+
+    def create_many(self, items: _RawCollection) -> _RawCollection:
+        pass
+
+    def read_one(self, item_id: str) -> _RawItem:
+        pass
+
+    def read_all(self) -> _RawCollection:
+        pass
+
+    def update_one(self, item_id: str, **with_fields: Any) -> _RawItem:
+        pass
+
+    def update_many(self, items: _RawCollection) -> _RawCollection:
+        pass
+
+    def delete_one(self, item_id: str) -> None:
+        pass
+
+
+def _as_raw_collection(value: Iterable[Any]) -> _RawCollection:
+    return [_as_raw_item(item) for item in value]
+
+
+def _as_raw_item(value: Any) -> _RawItem:
+    return asdict(value)
+
+
+@dataclass
+class InMemoryRestfulService:
+    resource: type[Any]
+    repository: InMemoryRepository[Any]
+
+    def create_one(self, item: _RawItem) -> _RawItem:
+        result = self.resource(**item)
+
+        self.repository.create(result)
+
+        return _as_raw_item(result)
+
+    def create_many(self, items: _RawCollection) -> _RawCollection:
+        result = [self.resource(**fields) for fields in items]
+
+        self.repository.create_many(result)
+
+        return _as_raw_collection(result)
+
+    def read_one(self, item_id: str) -> _RawItem:
+        result = self.repository.read(item_id)
+
+        return _as_raw_item(result)
+
+    def read_all(self) -> _RawCollection:
+        result = self.repository
+
+        return _as_raw_collection(result)
+
+    def update_one(self, item_id: str, **with_fields: Any) -> _RawItem:
+        result = replace(self.repository.read(item_id), **with_fields)
+
+        self.repository.update(result)
+
+        return _as_raw_item(result)
+
+    def update_many(self, items: _RawCollection) -> _RawCollection:
+        result = [self.resource(**fields) for fields in items]
+
+        self.repository.update_many(result)
+
+        return _as_raw_collection(result)
+
+    def delete_one(self, item_id: str) -> None:
+        self.repository.delete(item_id)

{apexdevkit-1.0.1 → apexdevkit-1.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "apexdevkit"
-version = "1.0.1"
+version = "1.1.1"
 description = "Apex Development Tools for python."
 authors = ["Apex Dev <dev@apex.ge>"]
 readme = "README.md"
@@ -25,6 +25,7 @@ ruff = "*"
 python_version = "3.11"
 ignore_missing_imports = true
 strict = true
+exclude = ["apexdevkit/fastapi/schema.py"]
 
 [tool.ruff]
 target-version = "py311"