muffin-rest 11.0.1__py3-none-any.whl → 12.0.1__py3-none-any.whl

muffin_rest/__init__.py

@@ -17,24 +17,24 @@ Api = API
 
 __all__ = (
     "API",
-    "Api",
-    "RESTHandler",
     "APIError",
-    "PWRESTHandler",
+    "Api",
+    "MongoFilter",
+    "MongoFilters",
+    "MongoRESTHandler",
+    "MongoSort",
+    "MongoSorting",
     "PWFilter",
     "PWFilters",
+    "PWRESTHandler",
     "PWSort",
     "PWSorting",
-    "SARESTHandler",
+    "RESTHandler",
     "SAFilter",
     "SAFilters",
+    "SARESTHandler",
     "SASort",
     "SASorting",
-    "MongoRESTHandler",
-    "MongoFilter",
-    "MongoFilters",
-    "MongoSort",
-    "MongoSorting",
 )
 
 # Support Peewee ORM

muffin_rest/api.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import dataclasses as dc
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, overload
 
 from http_router import Router
 from muffin.utils import TV, to_awaitable
@@ -27,11 +27,11 @@ class API:
 
     def __init__(
         self,
-        app: Optional[muffin.Application] = None,
+        app: muffin.Application | None = None,
         prefix: str = "",
         *,
         openapi: bool = True,
-        servers: Optional[list] = None,
+        servers: list | None = None,
         **openapi_info,
     ):
         """Post initialize the API if we have an application already."""
@@ -66,8 +66,8 @@ class API:
         app: muffin.Application,
         *,
         prefix: str = "",
-        openapi: Optional[bool] = None,
-        servers: Optional[list] = None,
+        openapi: bool | None = None,
+        servers: list | None = None,
         **openapi_info,
     ):
         """Initialize the API."""
@@ -100,16 +100,12 @@ class API:
         self.router.route("/openapi.json")(openapi_json)
 
     @overload
-    def route(self, obj: str, *paths: str, **params) -> Callable[[TV], TV]:
-        ...
+    def route(self, obj: str, *paths: str, **params) -> Callable[[TV], TV]: ...
 
     @overload
-    def route(self, obj: TVHandler, *paths: str, **params) -> TVHandler:
-        ...
+    def route(self, obj: TVHandler, *paths: str, **params) -> TVHandler: ...
 
-    def route(
-        self, obj: Union[str, TVHandler], *paths: str, **params
-    ) -> Union[Callable[[TV], TV], TVHandler]:
+    def route(self, obj: str | TVHandler, *paths: str, **params) -> Callable[[TV], TV] | TVHandler:
         """Route an endpoint by the API."""
         from .handler import RESTBase
 

muffin_rest/errors.py

@@ -1,9 +1,10 @@
 """Helpers to raise API errors as JSON responses."""
+
 from __future__ import annotations
 
 import json
 from http import HTTPStatus
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from muffin import ResponseError
 
@@ -16,7 +17,7 @@ class APIError(ResponseError):
 
     def __init__(
         self,
-        content: Optional[TJSON] = None,
+        content: TJSON | None = None,
         *,
         status_code: int = HTTPStatus.BAD_REQUEST.value,
         **json_data,

muffin_rest/filters.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import operator
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterable, Mapping, Optional  # py39
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterable, Mapping
 
 import marshmallow as ma
 from asgi_tools._compat import json_loads
@@ -59,8 +59,8 @@ class Filter(Mutate):
         name: str,
         *,
         field: Any = None,
-        schema_field: Optional[ma.fields.Field] = None,
-        operator: Optional[str] = None,
+        schema_field: ma.fields.Field | None = None,
+        operator: str | None = None,
         **meta,
     ):
         """Initialize filter.
@@ -75,7 +75,7 @@ class Filter(Mutate):
         self.schema_field = schema_field or self.schema_field
         self.default_operator = operator or self.default_operator
 
-    async def apply(self, collection: Any, data: Optional[Mapping] = None):
+    async def apply(self, collection: Any, data: Mapping | None = None):
         """Filter given collection."""
         if not data:
             return None, collection

muffin_rest/handler.py

@@ -9,9 +9,7 @@ from typing import (
     Iterable,
     Literal,
     Mapping,
-    Optional,
     Sequence,
-    Union,
     cast,
     overload,
 )
@@ -31,7 +29,7 @@ from muffin_rest.types import TSchemaRes
 
 from .errors import HandlerNotBindedError
 from .options import RESTOptions
-from .types import TVCollection, TVData, TVResource
+from .types import TVCollection, TVResource
 
 
 class RESTHandlerMeta(HandlerMeta):
@@ -39,7 +37,7 @@ class RESTHandlerMeta(HandlerMeta):
 
     def __new__(mcs, name, bases, params):
         """Prepare options for the handler."""
-        kls = cast(type["RESTBase"], super().__new__(mcs, name, bases, params))
+        kls = cast("type[RESTBase]", super().__new__(mcs, name, bases, params))
         kls.meta = kls.meta_class(kls)
 
         if getattr(kls.meta, kls.meta_class.base_property, None) is not None:
@@ -58,22 +56,22 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
 
     meta: RESTOptions
     meta_class: type[RESTOptions] = RESTOptions
-    _api: Optional[API] = None
+    _api: API | None = None
 
-    filters: Optional[dict[str, Any]] = None
-    sorting: Optional[dict[str, Any]] = None
+    filters: dict[str, Any] | None = None
+    sorting: dict[str, Any] | None = None
 
     class Meta:
         """Tune the handler."""
 
         # Resource filters
-        filters: Sequence[Union[str, tuple[str, str], Filter]] = ()
+        filters: Sequence[str | tuple[str, str] | Filter] = ()
 
         # Define allowed resource sorting params
-        sorting: Sequence[Union[str, tuple[str, dict], Sort]] = ()
+        sorting: Sequence[str | tuple[str, dict] | Sort] = ()
 
         # Serialize/Deserialize Schema class
-        Schema: Optional[type[ma.Schema]] = None
+        Schema: type[ma.Schema] | None = None
 
     @classmethod
     def __route__(cls, router, *paths, **params):
@@ -84,9 +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 }/{{{ cls.meta.name_id }}}", methods=methods, **params
-            )
+            router.bind(cls, f"/{ cls.meta.name }/{{pk}}", methods=methods, **params)
 
         for _, method in inspect.getmembers(cls, lambda m: hasattr(m, "__route__")):
             paths, methods = method.__route__
@@ -94,7 +90,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
 
         return cls
 
-    async def __call__(self, request: Request, *, method_name: Optional[str] = None, **_) -> Any:
+    async def __call__(self, request: Request, *, method_name: str | None = None, **_) -> Any:
         """Dispatch the given request by HTTP method."""
         self.auth = await self.authorize(request)
 
@@ -151,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(self.meta.name_id)
+        return request["path_params"].get("pk")
 
     async def filter(self, request: Request, collection: TVCollection) -> tuple[TVCollection, Any]:
         """Filter the collection."""
@@ -190,7 +186,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
     @abc.abstractmethod
     async def paginate(
         self, request: Request, *, limit: int = 0, offset: int = 0
-    ) -> tuple[Any, Optional[int]]:
+    ) -> tuple[Any, int | None]:
         """Paginate the results."""
         raise NotImplementedError
 
@@ -215,7 +211,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
     # Parse data
     # -----------
     def get_schema(
-        self, request: Request, *, resource: Optional[TVResource] = None, **schema_options
+        self, request: Request, *, resource: TVResource | None = None, **schema_options
     ) -> ma.Schema:
         """Initialize marshmallow schema for serialization/deserialization."""
         query = request.url.query
@@ -232,34 +228,37 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
 
         return data
 
-    async def load(
-        self, request: Request, resource: Optional[TVResource] = None, **schema_options
-    ) -> TVData[TVResource]:
+    async def load(self, request: Request, resource: TVResource | None = None, **schema_options):
         """Load data from request and create/update a resource."""
         schema = self.get_schema(request, resource=resource, **schema_options)
-        data = cast(Union[Mapping, list], await self.load_data(request))
-        return cast(TVData[TVResource], await load_data(data, schema, partial=resource is not None))
+        data = cast("Mapping | list", await self.load_data(request))
+        return cast(
+            "TVResource | list[TVResource]",
+            await load_data(data, schema, partial=resource is not None),
+        )
 
     @overload
     async def dump(  # type: ignore[misc]
-        self, request, data: TVData, *, many: Literal[True]
+        self, request, data: TVResource | Iterable[TVResource], *, many: Literal[True]
     ) -> list[TSchemaRes]: ...
 
     @overload
-    async def dump(self, request, data: TVData, *, many: bool = False) -> TSchemaRes: ...
+    async def dump(
+        self, request, data: TVResource | Iterable[TVResource], *, many: bool = False
+    ) -> TSchemaRes: ...
 
     async def dump(
         self,
         request: Request,
-        data: Union[TVResource, Iterable[TVResource]],
+        data: TVResource | Iterable[TVResource],
         *,
         many: bool = False,
-    ) -> Union[TSchemaRes, list[TSchemaRes]]:
+    ) -> TSchemaRes | list[TSchemaRes]:
         """Serialize the given response."""
         schema = self.get_schema(request)
         return schema.dump(data, many=many)
 
-    async def get(self, request: Request, *, resource: Optional[TVResource] = None) -> ResponseJSON:
+    async def get(self, request: Request, *, resource: TVResource | None = None) -> ResponseJSON:
         """Get a resource or a collection of resources.
 
         Specify a path param to load a resource.
@@ -269,11 +268,9 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
             if resource
             else self.dump(request, data=self.collection, many=True)
         )
-        return ResponseJSON(res)
+        return ResponseJSON(res)  # type: ignore[type-var]
 
-    async def post(
-        self, request: Request, *, resource: Optional[TVResource] = None
-    ) -> ResponseJSON:
+    async def post(self, request: Request, *, resource: TVResource | None = None) -> ResponseJSON:
         """Create a resource.
 
         The method accepts a single resource's data or a list of resources to create.
@@ -283,19 +280,19 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
         if many:
             data = await self.save_many(request, data, update=resource is not None)
         else:
-            data = await self.save(request, cast(TVResource, data), update=resource is not None)
+            data = await self.save(request, cast("TVResource", data), update=resource is not None)
 
         res = await self.dump(request, data, many=many)
         return ResponseJSON(res)
 
-    async def put(self, request: Request, *, resource: Optional[TVResource] = None) -> ResponseJSON:
+    async def put(self, request: Request, *, resource: TVResource | None = None) -> ResponseJSON:
         """Update a resource."""
         if resource is None:
             raise APIError.NOT_FOUND()
 
         return await self.post(request, resource=resource)
 
-    async def delete(self, request: Request, resource: Optional[TVResource] = None):
+    async def delete(self, request: Request, resource: TVResource | None = None):
         """Delete a resource."""
         if resource is None:
             raise APIError.NOT_FOUND()

muffin_rest/marshmallow.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from marshmallow import Schema, ValidationError
 
@@ -10,7 +10,7 @@ if TYPE_CHECKING:
     from collections.abc import Mapping
 
 
-async def load_data(data: Union[Mapping, list], schema: Optional[Schema] = None, **params):
+async def load_data(data: Mapping | list, schema: Schema | None = None, **params):
     if schema is None:
         return data
 

muffin_rest/mongo/__init__.py

@@ -1,7 +1,8 @@
 """Mongo DB support."""
+
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional, cast
+from typing import TYPE_CHECKING, cast
 
 import bson
 from bson.errors import InvalidId
@@ -28,7 +29,7 @@ class MongoRESTOptions(RESTOptions):
     sorting_cls: type[MongoSorting] = MongoSorting
     schema_base: type[MongoSchema] = MongoSchema
 
-    aggregate: Optional[list] = None  # Support aggregation. Set to pipeline.
+    aggregate: list | None = None  # Support aggregation. Set to pipeline.
     collection_id: str = "_id"
     collection: motor.AsyncIOMotorCollection
 
@@ -57,7 +58,7 @@ class MongoRESTHandler(RESTHandler[TVResource]):
 
     async def paginate(
         self, _: Request, *, limit: int = 0, offset: int = 0
-    ) -> tuple[motor.AsyncIOMotorCursor, Optional[int]]:
+    ) -> tuple[motor.AsyncIOMotorCursor, int | None]:
         """Paginate collection."""
         if self.meta.aggregate:
             pipeline_all = [*self.meta.aggregate, {"$skip": offset}, {"$limit": limit}]
@@ -68,14 +69,14 @@ class MongoRESTHandler(RESTHandler[TVResource]):
             counts = list(self.collection.aggregate(pipeline_num))
             return (
                 self.collection.aggregate(pipeline_all),
-                counts and counts[0]["total"] or 0,  # type: ignore[]
+                (counts and counts[0]["total"]) or 0,  # type: ignore[]
             )
         total = None
         if self.meta.limit_total:
             total = await self.collection.count()
         return self.collection.skip(offset).limit(limit), total
 
-    async def get(self, request, *, resource: Optional[TVResource] = None):
+    async def get(self, request, *, resource: TVResource | None = None):
         """Get resource or collection of resources."""
         if resource:
             return await self.dump(request, resource)
@@ -83,9 +84,9 @@ class MongoRESTHandler(RESTHandler[TVResource]):
         docs = await self.collection.to_list(None)
         return await self.dump(request, docs, many=True)
 
-    async def prepare_resource(self, request: Request) -> Optional[TVResource]:
+    async def prepare_resource(self, request: Request) -> TVResource | None:
         """Load a resource."""
-        pk = request["path_params"].get(self.meta.name_id)
+        pk = request["path_params"].get("pk")
         if not pk:
             return None
 
@@ -97,7 +98,7 @@ class MongoRESTHandler(RESTHandler[TVResource]):
             raise APIError.NOT_FOUND() from exc
 
     def get_schema(
-        self, request: Request, resource: Optional[TVResource] = None, **schema_options
+        self, request: Request, resource: TVResource | None = None, **schema_options
     ) -> ma.Schema:
         """Initialize marshmallow schema for serialization/deserialization."""
         return super().get_schema(request, instance=resource, **schema_options)
@@ -115,10 +116,12 @@ class MongoRESTHandler(RESTHandler[TVResource]):
 
         return resource
 
-    async def delete(self, request: Request, resource: Optional[TVResource] = None):
+    async def delete(self, request: Request, resource: TVResource | None = None):
         """Remove the given resource(s)."""
         meta = self.meta
-        oids = [resource[meta.collection_id]] if resource else cast(list[str], await request.data())
+        oids = (
+            [resource[meta.collection_id]] if resource else cast("list[str]", await request.data())
+        )
         if not oids:
             raise APIError.NOT_FOUND()
 

muffin_rest/mongo/utils.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Awaitable, Union
+from typing import TYPE_CHECKING, Awaitable
 
 if TYPE_CHECKING:
     from motor import motor_asyncio as motor
@@ -58,7 +58,7 @@ class MongoChain:
 
     def find(
         self,
-        query: Union[list, dict, None] = None,
+        query: list | dict | None = None,
         projection=None,
     ) -> MongoChain:
         """Store filters in self."""
@@ -68,17 +68,17 @@ class MongoChain:
 
     def find_one(
         self,
-        query: Union[list, dict, None] = None,
+        query: list | dict | None = None,
         projection=None,
     ) -> Awaitable:
         """Apply filters and return cursor."""
         query = self.__update__(query)
-        query = query and {"$and": query} or {}
+        query = (query and {"$and": query}) or {}
         return self.collection.find_one(query, projection=projection)
 
     def count(self) -> Awaitable[int]:
         """Count documents."""
-        query = self.query and {"$and": self.query} or {}
+        query = (self.query and {"$and": self.query}) or {}
         return self.collection.count_documents(query)
 
     def aggregate(self, pipeline, **kwargs):
@@ -121,7 +121,7 @@ class MongoChain:
 
     def __iter__(self):
         """Iterate by self collection."""
-        query = self.query and {"$and": self.query} or {}
+        query = (self.query and {"$and": self.query}) or {}
         if self.sorting:
             return self.collection.find(query, self.projection).sort(self.sorting)
 
@@ -130,7 +130,7 @@ class MongoChain:
     def __getattr__(self, name):
         """Proxy any attributes except find to self.collection."""
         if name in self.CURSOR_METHODS:
-            query = self.query and {"$and": self.query} or {}
+            query = (self.query and {"$and": self.query}) or {}
             cursor = self.collection.find(query, self.projection)
             if self.sorting:
                 cursor = cursor.sort(self.sorting)

muffin_rest/openapi.py

@@ -1,4 +1,5 @@
 """Create openapi schema from the given API."""
+
 from __future__ import annotations
 
 import inspect
@@ -88,7 +89,7 @@ def route_to_spec(route: Route, spec: APISpec, tags: dict) -> dict:
         for param in route.params:
             results["parameters"].append({"in": "path", "name": param})
 
-    target = cast(Callable, route.target)
+    target = cast("Callable", route.target)
     if isinstance(target, partial):
         target = target.func
 
@@ -198,9 +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(
-                meta.name_id,
-            )
+            is_resource_route = isinstance(route, DynamicRoute) and route.params.get("pk")
 
             if method == "get" and not is_resource_route:
                 operations[method]["parameters"] = []

muffin_rest/options.py

@@ -12,7 +12,7 @@ class RESTOptions:
     """Handler Options."""
 
     name: str = ""
-    name_id: str = "id"
+    pk: str = "id"
     base_property: str = "name"
 
     # Pagination

muffin_rest/peewee/filters.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import operator
 from functools import reduce
-from typing import TYPE_CHECKING, ClassVar, Union, cast
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from peewee import ColumnBase, Field, ModelSelect
 
@@ -15,6 +15,8 @@ from .utils import get_model_field_by_name
 if TYPE_CHECKING:
     from muffin_rest.types import TFilterValue
 
+    from . import PWRESTHandler
+
 
 class PWFilter(Filter):
     """Support Peewee."""
@@ -41,7 +43,9 @@ class PWFilter(Filter):
         """Apply the filters to Peewee QuerySet.."""
         column = self.field
         if isinstance(column, ColumnBase):
-            collection = cast(ModelSelect, collection.where(*[op(column, val) for op, val in ops]))
+            collection = cast(
+                "ModelSelect", collection.where(*[op(column, val) for op, val in ops])
+            )
         return collection
 
 
@@ -50,11 +54,10 @@ class PWFilters(Filters):
 
     MUTATE_CLASS: type[PWFilter] = PWFilter
 
-    def convert(self, obj: Union[str, Field, PWFilter], **meta):
+    def convert(self, obj: str | Field | PWFilter, **meta):
         """Convert params to filters."""
-        from . import PWRESTHandler
 
-        handler = cast(PWRESTHandler, self.handler)
+        handler = cast("PWRESTHandler", self.handler)
         if isinstance(obj, PWFilter):
             return obj
 

muffin_rest/peewee/handler.py

@@ -2,10 +2,9 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, cast, overload
 
 import marshmallow as ma
-import peewee as pw
 from apispec.ext.marshmallow import MarshmallowPlugin
 from marshmallow_peewee import ForeignKey
 from peewee_aio.model import AIOModel, AIOModelSelect
@@ -19,6 +18,7 @@ from .schemas import EnumField
 from .types import TVModel
 
 if TYPE_CHECKING:
+    import peewee as pw
     from muffin import Request
     from peewee_aio.types import TVAIOModel
 
@@ -34,7 +34,7 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
 
     if TYPE_CHECKING:
         resource: TVModel
-        collection: Union[AIOModelSelect, pw.ModelSelect]
+        collection: AIOModelSelect | pw.ModelSelect
 
     meta: PWRESTOptions
     meta_class: type[PWRESTOptions] = PWRESTOptions
@@ -56,9 +56,9 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
         """Initialize Peeewee QuerySet for a binded to the resource model."""
         return self.meta.model.select()
 
-    async def prepare_resource(self, request: Request) -> Optional[TVModel]:
+    async def prepare_resource(self, request: Request) -> TVModel | None:
         """Load a resource."""
-        pk = request["path_params"].get(self.meta.name_id)
+        pk = request["path_params"].get("pk")
         if not pk:
             return None
 
@@ -89,7 +89,7 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
     async def paginate(self, _: Request, *, limit: int = 0, offset: int = 0):  # type: ignore[override]
         """Paginate the collection."""
         if self.meta.limit_total:
-            cqs = cast(pw.ModelSelect, self.collection.order_by())
+            cqs = cast("pw.ModelSelect", self.collection.order_by())
             if cqs._group_by:  # type: ignore[misc]
                 cqs._returning = cqs._group_by  # type: ignore[misc]
                 cqs._having = None  # type: ignore[misc]
@@ -101,7 +101,7 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
 
         return self.collection.offset(offset).limit(limit), count
 
-    async def get(self, request, *, resource: Optional[TVModel] = None) -> Any:
+    async def get(self, request, *, resource: TVModel | None = None) -> Any:
         """Get resource or collection of resources."""
         if resource:
             return await self.dump(request, resource)
@@ -120,7 +120,7 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
 
         return resource
 
-    async def remove(self, request: Request, resource: Optional[TVModel] = None):
+    async def remove(self, request: Request, resource: TVModel | None = None):
         """Remove the given resource."""
         meta = self.meta
         if resource:
@@ -131,7 +131,7 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
             if not data:
                 return
 
-            model_pk = cast(pw.Field, meta.model_pk)
+            model_pk = cast("pw.Field", meta.model_pk)
             resources = await meta.manager.fetchall(self.collection.where(model_pk << data))  # type: ignore[]
 
         if not resources:
@@ -147,11 +147,11 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
 
         return resource.get_id() if resource else [r.get_id() for r in resources]
 
-    async def delete(self, request: Request, resource: Optional[TVModel] = None):  # type: ignore[override]
+    async def delete(self, request: Request, resource: TVModel | None = None):  # type: ignore[override]
         return await self.remove(request, resource)
 
     def get_schema(
-        self, request: Request, *, resource: Optional[TVModel] = None, **schema_options
+        self, request: Request, *, resource: TVModel | None = None, **schema_options
     ) -> ma.Schema:
         """Initialize marshmallow schema for serialization/deserialization."""
         return super().get_schema(request, instance=resource, **schema_options)

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(cls.meta.name_id)
+        is_resource_route = getattr(route, "params", {}).get("pk")
         if not is_resource_route and "delete" in operations:
             operations["delete"].setdefault("parameters", [])
             operations["delete"]["requestBody"] = {

muffin_rest/peewee/schemas.py

@@ -13,5 +13,3 @@ def build_field(field, opts, **params):
 
 
 DefaultConverter.register(URLField, ma.fields.Url)
-
-# ruff: noqa: ARG001, ARG002