muffin-rest 12.0.2__tar.gz → 13.0.1__tar.gz

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: muffin-rest
-Version: 12.0.2
+Version: 13.0.1
 Summary: The package provides enhanced support for writing REST APIs with Muffin framework
 License: MIT
 Keywords: rest,api,muffin,asgi,asyncio,trio

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/muffin_rest/handler.py

@@ -82,7 +82,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
 
         else:
             router.bind(cls, f"/{ cls.meta.name }", methods=methods, **params)
-            router.bind(cls, f"/{ cls.meta.name }/{{pk}}", methods=methods, **params)
+            router.bind(cls, f"/{ cls.meta.name }/{{id}}", methods=methods, **params)
 
         for _, method in inspect.getmembers(cls, lambda m: hasattr(m, "__route__")):
             paths, methods = method.__route__
@@ -147,7 +147,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
 
     async def prepare_resource(self, request: Request) -> Any:
         """Load a resource."""
-        return request["path_params"].get("pk")
+        return request["path_params"].get("id")
 
     async def filter(self, request: Request, collection: TVCollection) -> tuple[TVCollection, Any]:
         """Filter the collection."""

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/muffin_rest/mongo/__init__.py

@@ -52,12 +52,12 @@ class MongoRESTHandler(RESTHandler[TVResource]):
     meta: MongoRESTOptions
     meta_class: type[MongoRESTOptions] = MongoRESTOptions
 
-    async def prepare_collection(self, _: Request) -> MongoChain:
+    async def prepare_collection(self, request: Request) -> MongoChain:
         """Initialize Peeewee QuerySet for a binded to the resource model."""
         return MongoChain(self.meta.collection)
 
     async def paginate(
-        self, _: Request, *, limit: int = 0, offset: int = 0
+        self, request: Request, *, limit: int = 0, offset: int = 0
     ) -> tuple[motor.AsyncIOMotorCursor, int | None]:
         """Paginate collection."""
         if self.meta.aggregate:
@@ -86,13 +86,13 @@ class MongoRESTHandler(RESTHandler[TVResource]):
 
     async def prepare_resource(self, request: Request) -> TVResource | None:
         """Load a resource."""
-        pk = request["path_params"].get("pk")
-        if not pk:
+        key = request["path_params"].get("id")
+        if not key:
             return None
 
         try:
             return await self.collection.find_one(
-                {self.meta.collection_id: bson.ObjectId(pk)},
+                {self.meta.collection_id: bson.ObjectId(key)},
             )
         except InvalidId as exc:
             raise APIError.NOT_FOUND() from exc
@@ -103,7 +103,7 @@ class MongoRESTHandler(RESTHandler[TVResource]):
         """Initialize marshmallow schema for serialization/deserialization."""
         return super().get_schema(request, instance=resource, **schema_options)
 
-    async def save(self, _: Request, resource: TVResource, *, update=False) -> TVResource:
+    async def save(self, request: Request, resource: TVResource, *, update=False) -> TVResource:
         """Save the given resource."""
         meta = self.meta
         collection_id = meta.collection_id

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/muffin_rest/openapi.py

@@ -199,7 +199,7 @@ class OpenAPIMixin:
         schema_ref = {"$ref": f"#/components/schemas/{ meta.Schema.__name__ }"}
         for method in route_to_methods(route):
             operations[method] = {"tags": [tags[cls]]}
-            is_resource_route = isinstance(route, DynamicRoute) and route.params.get("pk")
+            is_resource_route = isinstance(route, DynamicRoute) and route.params.get("id")
 
             if method == "get" and not is_resource_route:
                 operations[method]["parameters"] = []

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/muffin_rest/peewee/handler.py

@@ -42,31 +42,31 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
     @overload
     async def prepare_collection(
         self: PWRESTBase[TVAIOModel],
-        _: Request,
+        request: Request,
     ) -> AIOModelSelect[TVAIOModel]: ...
 
     @overload
     async def prepare_collection(
         self: PWRESTBase[pw.Model],
-        _: Request,
+        request: Request,
     ) -> pw.ModelSelect: ...
 
     # NOTE: there is not a default sorting for peewee (conflict with muffin-admin)
-    async def prepare_collection(self, _: Request):  # type: ignore[override]
+    async def prepare_collection(self, request: Request):
         """Initialize Peeewee QuerySet for a binded to the resource model."""
         return self.meta.model.select()
 
     async def prepare_resource(self, request: Request) -> TVModel | None:
         """Load a resource."""
-        pk = request["path_params"].get("pk")
-        if not pk:
+        key = request["path_params"].get("id")
+        if not key:
             return None
 
         meta = self.meta
 
         try:
             resource = await meta.manager.fetchone(
-                self.collection.where(meta.model_pk == pk),
+                self.collection.where(meta.model_pk == key),
             )
         except Exception:  # noqa: BLE001
             resource = None
@@ -78,15 +78,15 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
 
     @overload
     async def paginate(
-        self: PWRESTBase[TVAIOModel], _: Request, *, limit: int = 0, offset: int = 0
+        self: PWRESTBase[TVAIOModel], request: Request, *, limit: int = 0, offset: int = 0
     ) -> tuple[AIOModelSelect[TVAIOModel], int | None]: ...
 
     @overload
     async def paginate(
-        self: PWRESTBase[pw.Model], _: Request, *, limit: int = 0, offset: int = 0
+        self: PWRESTBase[pw.Model], request: Request, *, limit: int = 0, offset: int = 0
     ) -> tuple[pw.ModelSelect, int | None]: ...
 
-    async def paginate(self, _: Request, *, limit: int = 0, offset: int = 0):  # type: ignore[override]
+    async def paginate(self, request: Request, *, limit: int = 0, offset: int = 0):
         """Paginate the collection."""
         if self.meta.limit_total:
             cqs = cast("pw.ModelSelect", self.collection.order_by())

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/muffin_rest/peewee/openapi.py

@@ -22,7 +22,7 @@ class PeeweeOpenAPIMixin(OpenAPIMixin):
     def openapi(cls, route: Route, spec: APISpec, tags: dict) -> dict:
         """Get openapi specs for the endpoint."""
         operations = super(PeeweeOpenAPIMixin, cls).openapi(route, spec, tags)
-        is_resource_route = getattr(route, "params", {}).get("pk")
+        is_resource_route = getattr(route, "params", {}).get("id")
         if not is_resource_route and "delete" in operations:
             operations["delete"].setdefault("parameters", [])
             operations["delete"]["requestBody"] = {

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/muffin_rest/sqlalchemy/__init__.py

@@ -114,13 +114,13 @@ class SARESTHandler(RESTHandler[TVResource]):
     meta_class: type[SARESTOptions] = SARESTOptions
     collection: sa.sql.Select
 
-    async def prepare_collection(self, _: Request) -> sa.sql.Select:
+    async def prepare_collection(self, request: Request) -> sa.sql.Select:
         """Initialize Peeewee QuerySet for a binded to the resource model."""
         return self.meta.table.select()
 
     async def paginate(
         self,
-        _: Request,
+        request: Request,
         *,
         limit: int = 0,
         offset: int = 0,
@@ -143,11 +143,11 @@ class SARESTHandler(RESTHandler[TVResource]):
 
     async def prepare_resource(self, request: Request) -> TVResource | None:
         """Load a resource."""
-        pk = request["path_params"].get("pk")
-        if not pk:
+        key = request["path_params"].get("id")
+        if not key:
             return None
 
-        qs = self.collection.where(self.meta.table_pk == pk)
+        qs = self.collection.where(self.meta.table_pk == key)
         resource = await self.meta.database.fetch_one(qs)
         if resource is None:
             raise APIError.NOT_FOUND("Resource not found")
@@ -176,11 +176,11 @@ class SARESTHandler(RESTHandler[TVResource]):
     async def remove(self, request: Request, resource: TVResource | None = None):
         """Remove the given resource."""
         table_pk = cast("sa.Column", self.meta.table_pk)
-        pks = [resource[table_pk.name]] if resource else await request.data()
-        if not pks:
+        keys = [resource[table_pk.name]] if resource else await request.data()
+        if not keys:
             raise APIError.NOT_FOUND()
 
-        delete = self.meta.table.delete().where(table_pk.in_(cast("list[Any]", pks)))
+        delete = self.meta.table.delete().where(table_pk.in_(cast("list[Any]", keys)))
         await self.meta.database.execute(delete)
 
     delete = remove

{muffin_rest-12.0.2 → muffin_rest-13.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "muffin-rest"
-version = "12.0.2"
+version = "13.0.1"
 description = "The package provides enhanced support for writing REST APIs with Muffin framework"
 readme = "README.md"
 homepage = "https://github.com/klen/muffin-rest"