apexdevkit 2.1.4__tar.gz → 2.2.1__tar.gz

{apexdevkit-2.1.4 → apexdevkit-2.2.1}/PKG-INFO

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

apexdevkit-2.2.1/apexdevkit/fastapi/resource.py

@@ -0,0 +1,103 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from fastapi.responses import JSONResponse
+
+from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
+from apexdevkit.fastapi.response import RestfulResponse
+
+_Response = JSONResponse | dict[str, Any]
+_Endpoint = Callable[..., _Response]
+
+
+@dataclass(frozen=True)
+class RestfulResource:
+    response: RestfulResponse
+
+    def create_one_endpoint(self, Service, Item) -> _Endpoint:
+        def endpoint(service: Service, item: Item) -> _Response:
+            try:
+                result = service.create_one(item)
+            except ExistsError as e:
+                return JSONResponse(self.response.exists(e), 409)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.created_one(result)
+
+        return endpoint
+
+    def read_one_endpoint(self, Service, ItemId) -> _Endpoint:
+        def endpoint(service: Service, item_id: ItemId) -> _Response:
+            try:
+                result = service.read_one(item_id)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.found_one(result)
+
+        return endpoint
+
+    def read_many_endpoint(self, Service, QueryParams) -> _Endpoint:
+        def endpoint(service: Service, params: QueryParams) -> _Response:
+            try:
+                result = list(service.read_many(**dict(params)))
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.found_many(result)
+
+        return endpoint
+
+    def read_all_endpoint(self, Service) -> _Endpoint:
+        def endpoint(service: Service) -> _Response:
+            try:
+                result = list(service.read_all())
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.found_many(result)
+
+        return endpoint
+
+    def update_one_endpoint(self, Service, ItemId, Updates) -> _Endpoint:
+        def endpoint(service: Service, item_id: ItemId, updates: Updates) -> _Response:
+            try:
+                service.update_one(item_id, **updates)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint
+
+    def replace_one_endpoint(self, Service, Item) -> _Endpoint:
+        def endpoint(service: Service, item: Item) -> _Response:
+            try:
+                service.replace_one(item)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint
+
+    def delete_one_endpoint(self, Service, ItemId) -> _Endpoint:
+        def endpoint(service: Service, item_id: ItemId) -> _Response:
+            try:
+                service.delete_one(item_id)
+            except DoesNotExistError as e:
+                return JSONResponse(self.response.not_found(e), 404)
+            except ForbiddenError as e:
+                return JSONResponse(self.response.forbidden(e), 403)
+
+            return self.response.ok()
+
+        return endpoint

{apexdevkit-2.1.4 → apexdevkit-2.2.1}/apexdevkit/fastapi/router.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Annotated, Any, Protocol, Self, TypeVar
+from typing import Annotated, Any, Protocol, Self
 
 from fastapi import APIRouter, Depends, Path, Query
 from fastapi.responses import JSONResponse
@@ -47,8 +47,6 @@ class RouterWithHiddenUnderscoreRoutes(APIRouter):
 
 _Response = JSONResponse | dict[str, Any]
 
-T = TypeVar("T")
-
 
 class Dependency(Protocol):  # pragma: no cover
     def as_dependable(self) -> type[RestfulService]:
@@ -128,7 +126,7 @@ class RestfulRouter:
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.create_one(
+            self.resource.create_one_endpoint(
                 Service=self._resolve(dependency),
                 Item=Annotated[
                     RawItem,
@@ -153,7 +151,7 @@ class RestfulRouter:
     ) -> Self:
         self.router.add_api_route(
             self.item_path,
-            self.resource.read_one(
+            self.resource.read_one_endpoint(
                 Service=self._resolve(dependency),
                 ItemId=Annotated[
                     str,
@@ -179,10 +177,13 @@ class RestfulRouter:
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.read_many(
+            self.resource.read_many_endpoint(
                 Service=self._resolve(dependency),
                 QueryParams=Annotated[
-                    Schema(self.name.singular).optional_schema_for("ReadMany", query),
+                    Schema(self.name.singular).optional_schema_for(
+                        action="ReadMany",
+                        fields=query,
+                    ),
                     Query(),
                 ],
             ),
@@ -204,7 +205,9 @@ class RestfulRouter:
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.read_all(Service=self._resolve(dependency)),
+            self.resource.read_all_endpoint(
+                Service=self._resolve(dependency),
+            ),
             methods=["GET"],
             status_code=200,
             responses={},
@@ -223,7 +226,7 @@ class RestfulRouter:
     ) -> Self:
         self.router.add_api_route(
             self.item_path,
-            self.resource.update_one(
+            self.resource.update_one_endpoint(
                 Service=self._resolve(dependency),
                 ItemId=Annotated[
                     str,
@@ -252,7 +255,7 @@ class RestfulRouter:
     ) -> Self:
         self.router.add_api_route(
             "",
-            self.resource.replace_one(
+            self.resource.replace_one_endpoint(
                 Service=self._resolve(dependency),
                 Item=Annotated[
                     RawItem,
@@ -277,7 +280,7 @@ class RestfulRouter:
     ) -> Self:
         self.router.add_api_route(
             self.item_path,
-            self.resource.delete_one(
+            self.resource.delete_one_endpoint(
                 Service=self._resolve(dependency),
                 ItemId=Annotated[
                     str,

{apexdevkit-2.1.4 → apexdevkit-2.2.1}/apexdevkit/fastapi/schema.py

@@ -11,9 +11,6 @@ from apexdevkit.fastapi.name import RestfulName
 
 
 class SchemaFields(ABC):
-    def id(self) -> FluentDict[type]:
-        return self.readable().select("id")
-
     def writable(self) -> FluentDict[type]:
         return self.readable().drop("id")
 

{apexdevkit-2.1.4 → apexdevkit-2.2.1}/apexdevkit/fastapi/service.py

@@ -2,61 +2,36 @@ from __future__ import annotations
 
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
-from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
-from apexdevkit.repository import BruteForceBatch, Entity, Repository
+from apexdevkit.repository import Entity, Repository
 
 if TYPE_CHECKING:
     from apexdevkit.formatter import Formatter
-    from apexdevkit.repository.core.interface import BatchRepository
 
 RawItem = Mapping[str, Any]
 RawCollection = Iterable[RawItem]
 
 
-class _RawItemWithId(dict[str, Any]):
-    def __post_init__(self) -> None:
-        assert "id" in self
-
-
-RawCollectionWithId = Iterable[_RawItemWithId]
-
-
 class RestfulService:  # pragma: no cover
     def create_one(self, item: RawItem) -> RawItem:
         raise NotImplementedError(self.create_one.__name__)
 
-    def create_many(self, items: RawCollection) -> RawCollection:
-        raise NotImplementedError(self.create_many.__name__)
-
     def read_one(self, item_id: str) -> RawItem:
         raise NotImplementedError(self.read_one.__name__)
 
     def read_many(self, **params: Any) -> RawCollection:
         raise NotImplementedError(self.read_many.__name__)
 
-    def filter_with(self, options: RawItem) -> RawCollection:
-        raise NotImplementedError(self.filter_with.__name__)
-
-    def aggregation_with(self, options: RawItem) -> RawItem:
-        raise NotImplementedError(self.filter_with.__name__)
-
     def read_all(self) -> RawCollection:
         raise NotImplementedError(self.read_all.__name__)
 
     def update_one(self, item_id: str, **with_fields: Any) -> RawItem:
         raise NotImplementedError(self.update_one.__name__)
 
-    def update_many(self, items: RawCollectionWithId) -> RawCollection:
-        raise NotImplementedError(self.update_many.__name__)
-
     def replace_one(self, item: RawItem) -> RawItem:
         raise NotImplementedError(self.replace_one.__name__)
 
-    def replace_many(self, items: RawCollection) -> RawCollection:
-        raise NotImplementedError(self.replace_many.__name__)
-
     def delete_one(self, item_id: str) -> None:
         raise NotImplementedError(self.delete_one.__name__)
 
@@ -67,21 +42,9 @@ class RestfulRepository[ItemT: Entity](RestfulService):
 
     formatter: Formatter[Mapping[str, Any], ItemT]
 
-    @cached_property
-    def _batch(self) -> BatchRepository[ItemT]:
-        return BruteForceBatch(inner=self.repository)
-
     def create_one(self, item: RawItem) -> RawItem:
         return self.formatter.dump(self.repository.create(self.formatter.load(item)))
 
-    def create_many(self, items: RawCollection) -> RawCollection:
-        return [
-            self.formatter.dump(item)
-            for item in self._batch.load(
-                [self.formatter.load(fields) for fields in items]
-            )
-        ]
-
     def read_one(self, item_id: str) -> RawItem:
         return self.formatter.dump(self.repository.read(item_id))
 
@@ -96,25 +59,10 @@ class RestfulRepository[ItemT: Entity](RestfulService):
 
         return data
 
-    def update_many(self, items: RawCollectionWithId) -> RawCollection:
-        updates = []
-        for fields in items:
-            data = dict(self.formatter.dump(self.repository.read(fields["id"])))
-            data.update(**fields)
-
-            updates.append(self.formatter.load(data))
-
-        return [self.formatter.dump(item) for item in self._batch.renew(updates)]
-
     def replace_one(self, item: RawItem) -> RawItem:
         self.repository.update(self.formatter.load(item))
 
         return item
 
-    def replace_many(self, items: RawCollection) -> RawCollection:
-        updated = self._batch.renew([self.formatter.load(item) for item in items])
-
-        return [self.formatter.dump(item) for item in updated]
-
     def delete_one(self, item_id: str) -> None:
         self.repository.delete(item_id)

{apexdevkit-2.1.4 → apexdevkit-2.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "apexdevkit"
-version = "2.1.4"
+version = "2.2.1"
 description = "Apex Development Tools for python."
 readme = "README.md"
 authors = [
@@ -80,6 +80,7 @@ ignore = [
 [tool.mypy]
 exclude = [
     "apexdevkit/fastapi/dependable.py",
+    "apexdevkit/fastapi/resource.py",
     "apexdevkit/fastapi/schema.py",
 ]
 ignore_missing_imports = true

apexdevkit-2.1.4/apexdevkit/fastapi/docs.py

@@ -1,15 +0,0 @@
-from typing import TypeVar
-
-from pydantic import BaseModel
-
-PayloadT = TypeVar("PayloadT")
-
-
-class Response[PayloadT](BaseModel):
-    status: str
-    code: int
-    data: PayloadT
-
-
-class NoData(BaseModel):
-    pass

apexdevkit-2.1.4/apexdevkit/fastapi/resource.py

@@ -1,319 +0,0 @@
-import re
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any, Union
-
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-
-from apexdevkit.error import DoesNotExistError, ExistsError, ForbiddenError
-from apexdevkit.fastapi.response import RestfulResponse
-from apexdevkit.query.query import (
-    Aggregation,
-    AggregationOption,
-    DateValue,
-    Filter,
-    FooterOptions,
-    Leaf,
-    ListValue,
-    NullValue,
-    NumericValue,
-    Operation,
-    Operator,
-    Page,
-    QueryOptions,
-    Sort,
-    StringValue,
-)
-
-_Response = JSONResponse | dict[str, Any]
-_Endpoint = Callable[..., _Response]
-
-
-@dataclass(frozen=True)
-class RestfulResource:
-    response: RestfulResponse
-
-    def create_one(self, Service, Item) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, item: Item) -> _Response:
-            try:
-                item = service.create_one(item)
-            except ExistsError as e:
-                return JSONResponse(self.response.exists(e), 409)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.created_one(item)
-
-        return endpoint
-
-    def create_many(self, Service, Collection) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, items: Collection) -> _Response:
-            try:
-                return self.response.created_many(service.create_many(items))
-            except ExistsError as e:
-                return JSONResponse(self.response.exists(e), 409)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_one(self, Service, ItemId) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, item_id: ItemId) -> _Response:
-            try:
-                return self.response.found_one(service.read_one(item_id))
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_many(self, Service, QueryParams) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, params: QueryParams) -> _Response:
-            try:
-                return self.response.found_many(list(service.read_many(**dict(params))))
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def filter_with(self, Service, QueryOptions) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, options: QueryOptions) -> _Response:
-            try:
-                return self.response.found_many(list(service.filter_with(options)))
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def aggregation_with(self, Service, FilterOptions) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, options: FilterOptions) -> _Response:
-            try:
-                return {
-                    "status": "success",
-                    "code": 200,
-                    "aggregations": service.aggregation_with(options),
-                }
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def read_all(self, Service) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service) -> _Response:
-            try:
-                return self.response.found_many(list(service.read_all()))
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-        return endpoint
-
-    def update_one(self, Service, ItemId, Updates) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, item_id: ItemId, updates: Updates) -> _Response:
-            try:
-                service.update_one(item_id, **updates)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def update_many(self, Service, Collection) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, items: Collection) -> _Response:
-            try:
-                service.update_many(items)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def replace_one(self, Service, Item) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, item: Item) -> _Response:
-            try:
-                service.replace_one(item)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def replace_many(self, Service, Collection) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, items: Collection) -> _Response:
-            try:
-                service.replace_many(items)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-    def delete_one(self, Service, ItemId) -> _Endpoint:  # type: ignore
-        def endpoint(service: Service, item_id: ItemId) -> _Response:
-            try:
-                service.delete_one(item_id)
-            except DoesNotExistError as e:
-                return JSONResponse(self.response.not_found(e), 404)
-            except ForbiddenError as e:
-                return JSONResponse(self.response.forbidden(e), 403)
-
-            return self.response.ok()
-
-        return endpoint
-
-
-@dataclass
-class _ColumnName:
-    raw: str
-
-    def __str__(self) -> str:
-        return re.sub(r"(?<!^)(?=[A-Z])", "_", self.raw).lower()
-
-
-class _NumericItem(BaseModel):
-    value: int
-    exponent: int
-
-    def to_value(self) -> NumericValue:
-        return NumericValue(self.value, self.exponent)
-
-
-class _StringItem(BaseModel):
-    value: str
-
-    def to_value(self) -> StringValue:
-        return StringValue(self.value)
-
-
-class _DateItem(BaseModel):
-    date: str
-
-    def to_value(self) -> DateValue:
-        return DateValue(self.date)
-
-
-class _ListItem(BaseModel):
-    values: list[_NumericItem | _StringItem | _DateItem]
-
-    def to_value(self) -> ListValue:
-        return ListValue([item.to_value() for item in self.values])
-
-
-class _LeafItem(BaseModel):
-    name: str
-    values: list[_NumericItem | _StringItem | _DateItem]
-
-    def to_value(self) -> Leaf:
-        return Leaf(
-            name=str(_ColumnName(self.name)),
-            values=[item.to_value() for item in self.values],
-        )
-
-
-class _OperatorItem(BaseModel):
-    operation: Operation
-    operands: list[Union["_LeafItem", "_OperatorItem"]]
-
-    def to_value(self) -> Operator:
-        return Operator(self.operation, [item.to_value() for item in self.operands])
-
-
-class _SortItem(BaseModel):
-    name: str
-    is_descending: bool
-
-    def to_value(self) -> Sort:
-        return Sort(str(_ColumnName(self.name)), self.is_descending)
-
-
-class _PageItem(BaseModel):
-    page: int | None
-    length: int | None
-    offset: int | None
-
-    def to_value(self) -> Page:
-        return Page(self.page, self.length, self.offset)
-
-
-class _FilterItem(BaseModel):
-    args: list[_NumericItem | _StringItem | _DateItem | _ListItem | None]
-
-    def to_value(self) -> Filter:
-        return Filter(
-            [arg.to_value() if arg is not None else None for arg in self.args]
-        )
-
-
-class _AggregationOptionItem(BaseModel):
-    name: str | None
-    aggregation: Aggregation
-
-    def to_value(self) -> AggregationOption:
-        return AggregationOption(
-            str(_ColumnName(self.name)) if self.name else None,
-            self.aggregation,
-        )
-
-
-class _FooterOptions(BaseModel):
-    filter: _FilterItem | None
-    condition: _OperatorItem | None
-    aggregations: list[_AggregationOptionItem]
-
-    def to_footer_options(self) -> FooterOptions:
-        return FooterOptions(
-            filter=self.filter.to_value() if self.filter else None,
-            condition=self.condition.to_value() if self.condition else None,
-            aggregations=[item.to_value() for item in self.aggregations],
-        )
-
-
-class _QueryOptions(BaseModel):
-    filter: _FilterItem | None
-    condition: _OperatorItem | None
-    ordering: list[_SortItem]
-    paging: _PageItem
-
-    def to_query_options(self) -> QueryOptions:
-        return QueryOptions(
-            filter=self.filter.to_value() if self.filter else None,
-            condition=self.condition.to_value() if self.condition else None,
-            ordering=[item.to_value() for item in self.ordering],
-            paging=self.paging.to_value(),
-        )
-
-
-class _SummaryItem(BaseModel):
-    name: str | None
-    aggregation: Aggregation
-    result: NumericValue | StringValue | DateValue | NullValue
-
-
-class _SummaryListEnvelope(BaseModel):
-    count: int
-    summaries: list[_SummaryItem]
-
-
-class SummaryResponse(BaseModel):
-    status: str
-    code: int
-    data: _SummaryListEnvelope
-
-
-class SumResponse(BaseModel):
-    status: str
-    code: int
-    count: int