muffin-rest 7.3.5__py3-none-any.whl → 8.1.0__py3-none-any.whl

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, Dict, List, Optional, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, overload
 
 from http_router import Router
 from muffin.utils import TV, to_awaitable
@@ -31,7 +31,7 @@ class API:
         prefix: str = "",
         *,
         openapi: bool = True,
-        servers: Optional[List] = None,
+        servers: Optional[list] = None,
         **openapi_info,
     ):
         """Post initialize the API if we have an application already."""
@@ -39,7 +39,7 @@ class API:
         self.prefix = prefix
 
         self.openapi = openapi
-        self.openapi_options: Dict[str, Any] = {"info": openapi_info}
+        self.openapi_options: dict[str, Any] = {"info": openapi_info}
         if servers:
             self.openapi_options["servers"] = servers
 
@@ -67,7 +67,7 @@ class API:
         *,
         prefix: str = "",
         openapi: Optional[bool] = None,
-        servers: Optional[List] = None,
+        servers: Optional[list] = None,
         **openapi_info,
     ):
         """Initialize the API."""

muffin_rest/errors.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import json
 from http import HTTPStatus
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Optional
 
 from muffin import ResponseError
 
@@ -24,7 +24,7 @@ class APIError(ResponseError):
         """Create JSON with errors information."""
         response = {"error": True, "message": HTTPStatus(status_code).description}
 
-        if isinstance(content, Dict):
+        if isinstance(content, dict):
             response = content
 
         elif content is not None:

muffin_rest/filters.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import operator
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, Mapping, Optional, Tuple  # py38
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterable, Mapping, Optional  # py39
 
 import marshmallow as ma
 from asgi_tools._compat import json_loads  # type: ignore[]
@@ -20,7 +20,7 @@ FILTERS_PARAM = "where"
 class Filter(Mutate):
     """Base filter class."""
 
-    operators: Dict[str, Callable] = {
+    operators: ClassVar[dict[str, Callable]] = {
         "$lt": operator.lt,
         "$le": operator.le,
         "$gt": operator.gt,
@@ -87,7 +87,7 @@ class Filter(Mutate):
 
         return ops, collection
 
-    async def filter(self, collection, *ops: Tuple[Callable, Any], **_):
+    async def filter(self, collection, *ops: tuple[Callable, Any], **_) -> Any:
         """Apply the filter to collection."""
 
         def validator(obj):
@@ -129,7 +129,7 @@ class Filters(Mutator):
 
     async def apply(
         self, request: Request, collection: TVCollection
-    ) -> Tuple[TVCollection, Dict[str, Any]]:
+    ) -> tuple[TVCollection, dict[str, Any]]:
         """Filter the given collection."""
         raw_data = request.url.query.get(FILTERS_PARAM)
         filters = {}
@@ -161,7 +161,7 @@ class Filters(Mutator):
         return self.MUTATE_CLASS(obj, field=field, schema_field=schema_field, **meta)
 
     @property
-    def openapi(self) -> Dict:
+    def openapi(self) -> dict:
         """Prepare OpenAPI params."""
         return {
             "name": FILTERS_PARAM,

muffin_rest/handler.py

@@ -1,19 +1,14 @@
 """Base class for API REST Handlers."""
-
 import abc
 import inspect
 from typing import (
     Any,
-    Dict,
     Generator,
     Generic,
     Iterable,
-    List,
     Literal,
     Optional,
     Sequence,
-    Tuple,
-    Type,
     Union,
     cast,
     overload,
@@ -42,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:
@@ -60,22 +55,23 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
     resource: Any
 
     meta: RESTOptions
-    meta_class: Type[RESTOptions] = RESTOptions
+    meta_class: type[RESTOptions] = RESTOptions
     _api: Optional[API] = None
-    filters: Dict[str, Any] = {}
-    sorting: Dict[str, Any] = {}
+
+    filters: Optional[dict[str, Any]] = None
+    sorting: Optional[dict[str, Any]] = None
 
     class Meta:
         """Tune the handler."""
 
         # Resource filters
-        filters: Sequence[Union[str, Tuple[str, str], Filter]] = ()
+        filters: Sequence[Union[str, tuple[str, str], Filter]] = ()
 
         # Define allowed resource sorting params
-        sorting: Sequence[Union[str, Tuple[str, Dict], Sort]] = ()
+        sorting: Sequence[Union[str, tuple[str, dict], Sort]] = ()
 
         # Serialize/Deserialize Schema class
-        Schema: Optional[Type[ma.Schema]] = None
+        Schema: Optional[type[ma.Schema]] = None
 
     @classmethod
     def __route__(cls, router, *paths, **params):
@@ -87,10 +83,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,
+                cls, f"/{ cls.meta.name }/{{{ cls.meta.name_id }}}", methods=methods, **params
             )
 
         for _, method in inspect.getmembers(cls, lambda m: hasattr(m, "__route__")):
@@ -102,14 +95,17 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
     async def __call__(self, request: Request, *, method_name: Optional[str] = None, **_) -> Any:
         """Dispatch the given request by HTTP method."""
         method = getattr(self, method_name or request.method.lower())
+        meta = self.meta
         self.auth = await self.authorize(request)
+        if meta.rate_limit:
+            await self.rate_limit(request)
+
         self.collection = await self.prepare_collection(request)
         resource = await self.prepare_resource(request)
         if not (request.method == "GET" and resource is None):
             return await method(request, resource=resource)
 
         headers = None
-        meta = self.meta
 
         # Filter collection
         if meta.filters:
@@ -148,6 +144,11 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
             raise APIError.UNAUTHORIZED()
         return auth
 
+    async def rate_limit(self, request: Request):
+        """Default rate limit method. Proxy rate limit to self.api."""
+        if not await self.meta.rate_limiter.check(f"{self.auth}"):
+            raise APIError.TOO_MANY_REQUESTS()
+
     # Prepare data
     # ------------
     @abc.abstractmethod
@@ -168,7 +169,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
             headers["x-total"] = total
         return headers
 
-    def paginate_prepare_params(self, request: Request) -> Tuple[int, int]:
+    def paginate_prepare_params(self, request: Request) -> tuple[int, int]:
         """Prepare pagination params."""
         meta = self.meta
         query = request.url.query
@@ -181,7 +182,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, Optional[int]]:
         """Paginate the results."""
         raise NotImplementedError
 
@@ -193,8 +194,8 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
         return resource
 
     async def save_many(
-        self, request: Request, data: List[TVResource], *, update=False
-    ) -> List[TVResource]:
+        self, request: Request, data: list[TVResource], *, update=False
+    ) -> list[TVResource]:
         """Save many resources."""
         return [await self.save(request, item, update=update) for item in data]
 
@@ -226,7 +227,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
     @overload
     async def dump(  # type: ignore[misc]
         self, request, data: TVData, *, many: Literal[True]
-    ) -> List[TSchemaRes]:
+    ) -> list[TSchemaRes]:
         ...
 
     @overload
@@ -239,7 +240,7 @@ class RESTBase(Generic[TVResource], Handler, metaclass=RESTHandlerMeta):
         data: Union[TVResource, Iterable[TVResource]],
         *,
         many: bool = False,
-    ) -> Union[TSchemaRes, List[TSchemaRes]]:
+    ) -> Union[TSchemaRes, list[TSchemaRes]]:
         """Serialize the given response."""
         schema = self.get_schema(request)
         return schema.dump(data, many=many)
@@ -293,7 +294,7 @@ class RESTHandler(RESTBase[TVResource], openapi.OpenAPIMixin):
     """Basic Handler Class."""
 
 
-def to_sort(sort_params: Sequence[str]) -> Generator[Tuple[str, bool], None, None]:
+def to_sort(sort_params: Sequence[str]) -> Generator[tuple[str, bool], None, None]:
     """Generate sort params."""
     for name in sort_params:
         n, desc = name.strip("-"), name.startswith("-")

muffin_rest/limits.py

@@ -0,0 +1,73 @@
+import abc
+from time import time
+
+
+class RateLimiter(abc.ABC):
+    """Rate limiter."""
+
+    def __init__(self, limit: int, period: int, **opts):
+        """Initialize the rate limiter.
+
+        Args:
+            limit (int): The limit of requests.
+            period (int): The period of time in seconds.
+        """
+        self.limit = limit
+        self.period = period
+
+    @abc.abstractmethod
+    async def check(self, key: str) -> bool:
+        """Check the request."""
+        raise NotImplementedError
+
+
+RATE_LIMITS = {}
+
+
+class MemoryRateLimiter(RateLimiter):
+    """Memory rate limiter. Do not use in production."""
+
+    async def check(self, key: str) -> bool:
+        """Check the request."""
+        now = time()
+        if key not in RATE_LIMITS:
+            RATE_LIMITS[key] = (now, 1)
+            return True
+
+        last, count = RATE_LIMITS[key]
+        if now - last > self.period:
+            RATE_LIMITS[key] = (now, 1)
+            return True
+
+        if count < self.limit:
+            RATE_LIMITS[key] = (last, count + 1)
+            return True
+
+        return False
+
+
+class RedisRateLimiter(RateLimiter):
+    """Redis rate limiter."""
+
+    # TODO: Asyncio lock
+
+    def __init__(self, limit: int, period: int, *, redis, **opts):
+        """Initialize the rate limiter.
+
+        Args:
+            limit (int): The limit of requests.
+            period (int): The period of time in seconds.
+            redis (aioredis.Redis): The Redis connection.
+        """
+        super().__init__(limit, period)
+        self.redis = redis
+
+    async def check(self, key: str) -> bool:
+        """Check the request."""
+        value = await self.redis.get(key)
+        if value is None:
+            await self.redis.setex(key, self.period, 1)
+            return True
+
+        await self.redis.incr(key)
+        return int(value) < self.limit

muffin_rest/marshmallow.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
+
 from collections.abc import Mapping
-from typing import Optional, Union, cast
+from typing import TYPE_CHECKING, Optional, Union, cast
 
-from asgi_tools import Request
 from marshmallow import Schema, ValidationError
 
 from muffin_rest.errors import APIError
 
+if TYPE_CHECKING:
+    from asgi_tools import Request
+
 
 async def load_data(request: Request, schema: Optional[Schema] = None, **params):
     try:

muffin_rest/mongo/__init__.py

@@ -1,7 +1,7 @@
 """Mongo DB support."""
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional, Tuple, Type, cast
+from typing import TYPE_CHECKING, Optional, cast
 
 import bson
 from bson.errors import InvalidId
@@ -24,17 +24,17 @@ if TYPE_CHECKING:
 class MongoRESTOptions(RESTOptions):
     """Support Mongo DB."""
 
-    filters_cls: Type[MongoFilters] = MongoFilters
-    sorting_cls: Type[MongoSorting] = MongoSorting
-    schema_base: Type[MongoSchema] = MongoSchema
+    filters_cls: type[MongoFilters] = MongoFilters
+    sorting_cls: type[MongoSorting] = MongoSorting
+    schema_base: type[MongoSchema] = MongoSchema
 
-    aggregate: Optional[List] = None  # Support aggregation. Set to pipeline.
+    aggregate: Optional[list] = None  # Support aggregation. Set to pipeline.
     collection_id: str = "_id"
     collection: motor.AsyncIOMotorCollection
 
     base_property: str = "collection"
 
-    Schema: Type[MongoSchema]
+    Schema: type[MongoSchema]
 
     def setup(self, cls):
         """Prepare meta options."""
@@ -49,7 +49,7 @@ class MongoRESTHandler(RESTHandler[TVResource]):
     """Support Mongo DB."""
 
     meta: MongoRESTOptions
-    meta_class: Type[MongoRESTOptions] = MongoRESTOptions
+    meta_class: type[MongoRESTOptions] = MongoRESTOptions
 
     async def prepare_collection(self, _: Request) -> MongoChain:
         """Initialize Peeewee QuerySet for a binded to the resource model."""
@@ -57,7 +57,7 @@ class MongoRESTHandler(RESTHandler[TVResource]):
 
     async def paginate(
         self, _: Request, *, limit: int = 0, offset: int = 0
-    ) -> Tuple[motor.AsyncIOMotorCursor, Optional[int]]:
+    ) -> tuple[motor.AsyncIOMotorCursor, Optional[int]]:
         """Paginate collection."""
         if self.meta.aggregate:
             pipeline_all = [*self.meta.aggregate, {"$skip": offset}, {"$limit": limit}]
@@ -118,7 +118,7 @@ class MongoRESTHandler(RESTHandler[TVResource]):
     async def delete(self, request: Request, resource: Optional[TVResource] = 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/filters.py

@@ -1,6 +1,6 @@
 """Support filters for Mongo."""
 
-import typing as t
+from typing import Any, Callable, ClassVar
 
 from muffin_rest.filters import Filter, Filters
 
@@ -8,7 +8,7 @@ from muffin_rest.filters import Filter, Filters
 class MongoFilter(Filter):
     """Custom filter for sqlalchemy."""
 
-    operators = {
+    operators: ClassVar = {
         "$eq": lambda _, v: ("$eq", v),
         "$ge": lambda _, v: ("$ge", v),
         "$gt": lambda _, v: ("$gt", v),
@@ -21,7 +21,7 @@ class MongoFilter(Filter):
         "$ends": lambda _, v: ("$regex", f"{ v }$"),
     }
 
-    async def filter(self, collection, *ops: t.Tuple[t.Callable, t.Any], **_):
+    async def filter(self, collection, *ops: tuple[Callable, Any], **_):
         """Apply the filter."""
         return collection.find({self.field: dict(op(self.name, v) for op, v in ops)})
 

muffin_rest/mongo/types.py

@@ -1,7 +1,7 @@
-from typing import Any, Dict, TypeVar
+from typing import Any, TypeVar
 
 from .utils import MongoChain
 
+TResource = dict[str, Any]
 TVCollection = TypeVar("TVCollection", bound=MongoChain)
-TResource = Dict[str, Any]
 TVResource = TypeVar("TVResource", bound=TResource)

muffin_rest/mongo/utils.py

@@ -2,14 +2,13 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Awaitable, Dict, List, Tuple, Union
+from typing import TYPE_CHECKING, Awaitable, Union
 
 if TYPE_CHECKING:
     from motor import motor_asyncio as motor
 
 
 class MongoChain:
-
     """Support query chains.
 
     Only for `find` and `find_one` methods.
@@ -53,12 +52,14 @@ class MongoChain:
     def __init__(self, collection: motor.AsyncIOMotorCollection):
         """Initialize the resource."""
         self.collection = collection
-        self.query: List = []
+        self.query: list = []
         self.projection = None
-        self.sorting: List[Tuple[str, int]] = []
+        self.sorting: list[tuple[str, int]] = []
 
     def find(
-        self, query: Union[List, Dict, None] = None, projection=None,
+        self,
+        query: Union[list, dict, None] = None,
+        projection=None,
     ) -> MongoChain:
         """Store filters in self."""
         self.query = self.__update__(query)
@@ -66,7 +67,9 @@ class MongoChain:
         return self
 
     def find_one(
-        self, query: Union[List, Dict, None] = None, projection=None,
+        self,
+        query: Union[list, dict, None] = None,
+        projection=None,
     ) -> Awaitable:
         """Apply filters and return cursor."""
         query = self.__update__(query)

muffin_rest/openapi.py

@@ -6,7 +6,7 @@ import re
 from contextlib import suppress
 from functools import partial
 from http import HTTPStatus
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Tuple, cast
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 from apispec import utils
 from apispec.core import APISpec
@@ -81,9 +81,9 @@ def render_openapi(api, request=None):
     return spec.to_dict()
 
 
-def route_to_spec(route: Route, spec: APISpec, tags: Dict) -> Dict:
+def route_to_spec(route: Route, spec: APISpec, tags: dict) -> dict:
     """Convert the given router to openapi operations."""
-    results: Dict[str, Any] = {"parameters": [], "operations": {}}
+    results: dict[str, Any] = {"parameters": [], "operations": {}}
     if isinstance(route, DynamicRoute):
         for param in route.params:
             results["parameters"].append({"in": "path", "name": param})
@@ -109,7 +109,7 @@ def route_to_spec(route: Route, spec: APISpec, tags: Dict) -> Dict:
     return results
 
 
-def parse_docs(cb: Callable) -> Tuple[str, str, Dict]:
+def parse_docs(cb: Callable) -> tuple[str, str, dict]:
     """Parse docs from the given callback."""
     if yaml_utils is None:
         return "", "", {}
@@ -122,7 +122,7 @@ def parse_docs(cb: Callable) -> Tuple[str, str, Dict]:
     return summary, description.strip(), schema
 
 
-def merge_dicts(source: Dict, merge: Dict) -> Dict:
+def merge_dicts(source: dict, merge: dict) -> dict:
     """Merge dicts."""
     return dict(
         source,
@@ -145,15 +145,15 @@ def merge_dicts(source: Dict, merge: Dict) -> Dict:
     )
 
 
-def route_to_methods(route: Route) -> List[str]:
+def route_to_methods(route: Route) -> list[str]:
     """Get sorted methods from the route."""
     methods = [m for m in HTTP_METHODS if m in (route.methods or [])]
     return [m.lower() for m in methods or DEFAULT_METHODS]
 
 
-def return_type_to_response(fn: Callable) -> Dict:
+def return_type_to_response(fn: Callable) -> dict:
     """Generate reponses specs based on the given function's return type."""
-    responses: Dict[int, Dict] = {}
+    responses: dict[int, dict] = {}
     return_type = fn.__annotations__.get("return")
     if return_type is None:
         return responses
@@ -180,13 +180,13 @@ class OpenAPIMixin:
     meta: RESTOptions
 
     @classmethod
-    def openapi(cls, route: Route, spec: APISpec, tags: Dict) -> Dict:  # noqa: C901
+    def openapi(cls, route: Route, spec: APISpec, tags: dict) -> dict:  # noqa: C901
         """Get openapi specs for the endpoint."""
         meta = cls.meta
         if getattr(meta, meta.base_property, None) is None:
             return {}
 
-        operations: Dict = {}
+        operations: dict = {}
         summary, desc, schema = parse_docs(cls)
         if cls not in tags:
             tags[cls] = meta.name

muffin_rest/options.py

@@ -1,9 +1,11 @@
 """REST Options."""
 
-from typing import Dict, Type
+from typing import Any, ClassVar
 
 import marshmallow as ma
 
+from muffin_rest.limits import MemoryRateLimiter, RateLimiter
+
 from .filters import Filters
 from .sorting import Sorting
 
@@ -13,6 +15,10 @@ class RESTOptions:
 
     name: str = ""
     name_id: str = "id"
+    base_property: str = "name"
+
+    # Pagination
+    # ----------
 
     # limit: Paginate results (set to None for disable pagination)
     limit: int = 0
@@ -23,22 +29,37 @@ class RESTOptions:
     # limit_total: Return total count of results
     limit_total: bool = True
 
+    # Filters
+    # -------
+
     # Base class for filters
     filters: Filters
-    filters_cls: Type[Filters] = Filters
+    filters_cls: type[Filters] = Filters
+
+    # Sorting
+    # -------
 
     # Base class for sorting
     sorting: Sorting
-    sorting_cls: Type[Sorting] = Sorting
+    sorting_cls: type[Sorting] = Sorting
+
+    # Serialization/Deserialization
+    # -----------------------------
 
     # Auto generation for schemas
-    Schema: Type[ma.Schema]
-    schema_base: Type[ma.Schema] = ma.Schema
-    schema_fields: Dict = {}
-    schema_meta: Dict = {}
+    Schema: type[ma.Schema]
+    schema_base: type[ma.Schema] = ma.Schema
+    schema_fields: ClassVar[dict] = {}
+    schema_meta: ClassVar[dict] = {}
     schema_unknown: str = ma.EXCLUDE
 
-    base_property: str = "name"
+    # Rate Limiting
+    # -------------
+
+    rate_limit: int = 0
+    rate_limit_period: int = 60
+    rate_limit_cls: type[RateLimiter] = MemoryRateLimiter
+    rate_limit_cls_opts: ClassVar[dict[str, Any]] = {}
 
     def __init__(self, cls):
         """Inherit meta options."""
@@ -65,6 +86,11 @@ class RESTOptions:
         if not self.limit_max:
             self.limit_max = self.limit
 
+        if self.rate_limit:
+            self.rate_limiter = self.rate_limit_cls(
+                self.rate_limit, self.rate_limit_period, **self.rate_limit_cls_opts
+            )
+
     def setup_schema_meta(self, _):
         """Generate meta for schemas."""
         return type(

muffin_rest/peewee/filters.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import operator
 from functools import reduce
-from typing import Any, Callable, Tuple, Type, Union, cast
+from typing import Any, Callable, ClassVar, Union, cast
 
 from peewee import ColumnBase, Field, ModelSelect
 
@@ -15,7 +15,7 @@ from .utils import get_model_field_by_name
 class PWFilter(Filter):
     """Support Peewee."""
 
-    operators = dict(Filter.operators)
+    operators: ClassVar = dict(Filter.operators)
     operators["$in"] = operator.lshift
     operators["$none"] = operator.rshift
     operators["$like"] = operator.mod
@@ -34,7 +34,7 @@ class PWFilter(Filter):
     list_ops = (*Filter.list_ops, "$between")
 
     async def filter(
-        self, collection: ModelSelect, *ops: Tuple[Callable, Any], **kwargs
+        self, collection: ModelSelect, *ops: tuple[Callable, Any], **kwargs
     ) -> ModelSelect:
         """Apply the filters to Peewee QuerySet.."""
         column = self.field
@@ -46,7 +46,7 @@ class PWFilter(Filter):
 class PWFilters(Filters):
     """Bind Peewee filter class."""
 
-    MUTATE_CLASS: Type[PWFilter] = PWFilter
+    MUTATE_CLASS: type[PWFilter] = PWFilter
 
     def convert(self, obj: Union[str, Field, PWFilter], **meta):
         """Convert params to filters."""

muffin_rest/peewee/handler.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Type, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
 
 import marshmallow as ma
 import peewee as pw
@@ -23,7 +23,7 @@ if TYPE_CHECKING:
     from peewee_aio.types import TVAIOModel
 
 
-# XXX: Patch apispec.MarshmallowPlugin to support ForeignKeyField
+# TODO: Patch apispec.MarshmallowPlugin to support ForeignKeyField
 MarshmallowPlugin.Converter.field_mapping[ForeignKey] = ("integer", None)
 
 assert issubclass(EnumField, ma.fields.Field)  # just register EnumField
@@ -37,7 +37,7 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
         collection: Union[AIOModelSelect, pw.ModelSelect]
 
     meta: PWRESTOptions
-    meta_class: Type[PWRESTOptions] = PWRESTOptions
+    meta_class: type[PWRESTOptions] = PWRESTOptions
 
     @overload
     async def prepare_collection(
@@ -70,7 +70,7 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
             resource = await meta.manager.fetchone(
                 self.collection.where(meta.model_pk == pk),
             )
-        except Exception:  # noqa:
+        except Exception:  # noqa: BLE001
             resource = None
 
         if resource is None:
@@ -81,13 +81,13 @@ class PWRESTBase(RESTBase[TVModel], PeeweeOpenAPIMixin):
     @overload
     async def paginate(
         self: PWRESTBase[TVAIOModel], _: Request, *, limit: int = 0, offset: int = 0
-    ) -> Tuple[AIOModelSelect[TVAIOModel], int | None]:
+    ) -> tuple[AIOModelSelect[TVAIOModel], int | None]:
         ...
 
     @overload
     async def paginate(
         self: PWRESTBase[pw.Model], _: Request, *, limit: int = 0, offset: int = 0
-    ) -> Tuple[pw.ModelSelect, int | None]:
+    ) -> tuple[pw.ModelSelect, int | None]:
         ...
 
     async def paginate(self, _: Request, *, limit: int = 0, offset: int = 0):

muffin_rest/peewee/openapi.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING
 
 from muffin_rest.openapi import OpenAPIMixin
 
@@ -19,7 +19,7 @@ class PeeweeOpenAPIMixin(OpenAPIMixin):
     meta: PWRESTOptions
 
     @classmethod
-    def openapi(cls, route: Route, spec: APISpec, tags: Dict) -> Dict:
+    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)

muffin_rest/peewee/options.py

@@ -1,5 +1,3 @@
-from typing import Type
-
 import peewee as pw
 from marshmallow_peewee import ModelSchema
 from peewee_aio import Manager
@@ -14,19 +12,19 @@ class PWRESTOptions(RESTOptions):
     """Support Peewee."""
 
     # Base filters class
-    filters_cls: Type[PWFilters] = PWFilters
+    filters_cls: type[PWFilters] = PWFilters
 
     # Base sorting class
-    sorting_cls: Type[PWSorting] = PWSorting
+    sorting_cls: type[PWSorting] = PWSorting
 
-    Schema: Type[ModelSchema]
+    Schema: type[ModelSchema]
 
     # Schema auto generation params
-    schema_base: Type[ModelSchema] = ModelSchema
+    schema_base: type[ModelSchema] = ModelSchema
 
     base_property: str = "model"
 
-    model: Type[pw.Model]
+    model: type[pw.Model]
     model_pk: pw.Field
 
     manager: Manager

muffin_rest/peewee/sorting.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Type, Union, cast
+from typing import TYPE_CHECKING, Union, cast
 
 from peewee import Field
 
@@ -28,7 +28,7 @@ class PWSort(Sort):
 class PWSorting(Sorting):
     """Sort Peewee ORM Queries."""
 
-    MUTATE_CLASS: Type[PWSort] = PWSort
+    MUTATE_CLASS: type[PWSort] = PWSort
 
     def prepare(self, collection: TVCollection) -> TVCollection:
         """Prepare collection for sorting."""

muffin_rest/schemas.py

@@ -1,8 +1,10 @@
+from typing import ClassVar
+
 import marshmallow as ma
 
 
 class EnumField(ma.fields.Field):
-    default_error_messages = {
+    default_error_messages: ClassVar = {  # type: ignore[misc]
         "unknown": "Must be one of: {choices}.",
     }
 

muffin_rest/sorting.py

@@ -1,19 +1,7 @@
 """Implement sorting."""
 from __future__ import annotations
 
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Generator,
-    Iterable,
-    List,
-    Mapping,
-    Sequence,
-    Tuple,
-    Type,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Generator, Iterable, Mapping, Sequence, cast
 
 from .types import TVCollection
 from .utils import Mutate, Mutator
@@ -40,14 +28,14 @@ class Sorting(Mutator):
     MUTATE_CLASS = Sort
     mutations: Mapping[str, Sort]
 
-    def __init__(self, handler: Type[RESTBase], params: Iterable):
+    def __init__(self, handler: type[RESTBase], params: Iterable):
         """Initialize the sorting."""
-        self.default: List[Sort] = []
+        self.default: list[Sort] = []
         super(Sorting, self).__init__(handler, params)
 
     async def apply(
         self, request: Request, collection: TVCollection
-    ) -> Tuple[TVCollection, Dict[str, Any]]:
+    ) -> tuple[TVCollection, dict[str, Any]]:
         """Sort the given collection."""
         data = request.url.query.get(SORT_PARAM)
         sorting = {}
@@ -97,7 +85,7 @@ class Sorting(Mutator):
 
 def to_sort(
     sort_params: Sequence[str],
-) -> Generator[Tuple[str, bool], None, None]:
+) -> Generator[tuple[str, bool], None, None]:
     """Generate sort params."""
     for name in sort_params:
         n, desc = name.strip("-"), name.startswith("-")

muffin_rest/sqlalchemy/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Type, cast
+from typing import TYPE_CHECKING, Any, Optional, cast
 
 import marshmallow as ma
 import sqlalchemy as sa
@@ -22,8 +22,7 @@ if TYPE_CHECKING:
 
 from .types import TVResource
 
-# XXX: Monkey patch ModelConverter
-ModelConverter._get_field_name = lambda _, prop_or_column: str(prop_or_column.key)  # type: ignore[assignment]  # noqa:
+ModelConverter._get_field_name = lambda _, prop_or_column: str(prop_or_column.key)  # type: ignore[method-assign]
 
 
 class SQLAlchemyAutoSchema(BaseSQLAlchemyAutoSchema):
@@ -69,12 +68,12 @@ class SQLAlchemyAutoSchema(BaseSQLAlchemyAutoSchema):
 class SARESTOptions(RESTOptions):
     """Support SQLAlchemy Core."""
 
-    filters_cls: Type[SAFilters] = SAFilters
-    sorting_cls: Type[SASorting] = SASorting
+    filters_cls: type[SAFilters] = SAFilters
+    sorting_cls: type[SASorting] = SASorting
 
     # Schema auto generation params
-    Schema: Type[SQLAlchemyAutoSchema]
-    schema_base: Type[SQLAlchemyAutoSchema] = SQLAlchemyAutoSchema
+    Schema: type[SQLAlchemyAutoSchema]
+    schema_base: type[SQLAlchemyAutoSchema] = SQLAlchemyAutoSchema
 
     table: sa.Table
     table_pk: sa.Column
@@ -113,7 +112,7 @@ class SARESTHandler(RESTHandler[TVResource]):
     """Support SQLAlchemy Core."""
 
     meta: SARESTOptions
-    meta_class: Type[SARESTOptions] = SARESTOptions
+    meta_class: type[SARESTOptions] = SARESTOptions
     collection: sa.sql.Select
 
     async def prepare_collection(self, _: Request) -> sa.sql.Select:
@@ -126,10 +125,10 @@ class SARESTHandler(RESTHandler[TVResource]):
         *,
         limit: int = 0,
         offset: int = 0,
-    ) -> Tuple[sa.sql.Select, Optional[int]]:
+    ) -> tuple[sa.sql.Select, Optional[int]]:
         """Paginate the collection."""
         sqs = self.collection.order_by(None).subquery()
-        qs = sa.select([sa.func.count()]).select_from(sqs)
+        qs = sa.select(sa.func.count()).select_from(sqs)
         total = None
         if self.meta.limit_total:
             total = await self.meta.database.fetch_val(qs)
@@ -167,11 +166,11 @@ class SARESTHandler(RESTHandler[TVResource]):
         insert_query = meta.table.insert()
         table_pk = cast(sa.Column, meta.table_pk)
         if update:
-            update_query = self.meta.table.update().where(table_pk == resource[table_pk.name])
+            update_query = self.meta.table.update().where(table_pk == resource[table_pk.name])  # type: ignore[call-overload]
             await meta.database.execute(update_query, resource)
 
         else:
-            resource[table_pk.name] = await meta.database.execute(insert_query, resource)
+            resource[table_pk.name] = await meta.database.execute(insert_query, resource)  # type: ignore[call-overload]
 
         return resource
 
@@ -182,7 +181,7 @@ class SARESTHandler(RESTHandler[TVResource]):
         if not pks:
             raise APIError.NOT_FOUND()
 
-        delete = self.meta.table.delete(table_pk.in_(pks))
+        delete = self.meta.table.delete().where(table_pk.in_(cast(list[Any], pks)))
         await self.meta.database.execute(delete)
 
     delete = remove

muffin_rest/sqlalchemy/filters.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Union, cast
 
 from sqlalchemy import Column
 
@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 class SAFilter(Filter):
     """Custom filter for sqlalchemy."""
 
-    operators = dict(Filter.operators)
+    operators: ClassVar = dict(Filter.operators)
     operators["$between"] = lambda c, v: c.between(*v)
     operators["$ends"] = lambda c, v: c.endswith(v)
     operators["$ilike"] = lambda c, v: c.ilike(v)
@@ -27,10 +27,10 @@ class SAFilter(Filter):
     operators["$notlike"] = lambda c, v: c.notlike(v)
     operators["$starts"] = lambda c, v: c.startswith(v)
 
-    list_ops = [*Filter.list_ops, "$between"]
+    list_ops = (*Filter.list_ops, "$between")
 
     async def filter(
-        self, collection: TVCollection, *ops: Tuple[Callable, Any], **kwargs
+        self, collection: TVCollection, *ops: tuple[Callable, Any], **kwargs
     ) -> TVCollection:
         """Apply the filters to SQLAlchemy Select."""
         column = self.field
@@ -62,7 +62,7 @@ class SAFilters(Filters):
 
         if isinstance(obj, Column):
             name = obj.name
-            field = obj
+            field: Any = obj
 
         else:
             name = obj

muffin_rest/sqlalchemy/types.py

@@ -1,8 +1,8 @@
-from typing import Any, Dict, TypeVar
+from typing import Any, TypeVar
 
 from sqlalchemy import sql
 
 TVCollection = TypeVar("TVCollection", bound=sql.Select)
 
-TResource = Dict[str, Any]
+TResource = dict[str, Any]
 TVResource = TypeVar("TVResource", bound=TResource)

muffin_rest/types.py

@@ -3,9 +3,6 @@ from typing import (
     Any,
     Awaitable,
     Callable,
-    Dict,
-    List,
-    Type,
     TypeVar,
     Union,
 )
@@ -17,8 +14,8 @@ from muffin import Request
 
 TVCollection = TypeVar("TVCollection", bound=Any)
 TVResource = TypeVar("TVResource", bound=Any)
-TVData = Union[TVResource, List[TVResource]]
+TVData = Union[TVResource, list[TVResource]]
 TAuth = Callable[[Request], Awaitable]
 TVAuth = TypeVar("TVAuth", bound=TAuth)
-TVHandler = TypeVar("TVHandler", bound=Type["RESTBase"])
-TSchemaRes = Dict[str, Any]
+TVHandler = TypeVar("TVHandler", bound=type["RESTBase"])
+TSchemaRes = dict[str, Any]

muffin_rest/utils.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 import abc
-from typing import TYPE_CHECKING, Any, Dict, Iterable, Mapping, Tuple, Type
+from typing import TYPE_CHECKING, Any, Iterable, Mapping
 
 if TYPE_CHECKING:
     from muffin import Request
@@ -36,7 +36,7 @@ class Mutate(abc.ABC):
 class Mutator(abc.ABC):
     """Mutate collections."""
 
-    MUTATE_CLASS: Type[Mutate]
+    MUTATE_CLASS: type[Mutate]
     mutations: Mapping[str, Mutate]
 
     def __init__(self, handler, params: Iterable):
@@ -73,6 +73,6 @@ class Mutator(abc.ABC):
     @abc.abstractmethod
     async def apply(
         self, request: Request, collection: TVCollection
-    ) -> Tuple[TVCollection, Dict[str, Any]]:
+    ) -> tuple[TVCollection, dict[str, Any]]:
         """Mutate a collection."""
         raise NotImplementedError

{muffin_rest-7.3.5.dist-info → muffin_rest-8.1.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: muffin-rest
-Version: 7.3.5
+Version: 8.1.0
 Summary: The package provides enhanced support for writing REST APIs with Muffin framework
 Home-page: https://github.com/klen/muffin-rest
 License: MIT
 Keywords: rest,api,muffin,asgi,asyncio,trio
 Author: Kirill Klenov
 Author-email: horneds@gmail.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: Trio
@@ -15,7 +15,6 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -27,7 +26,7 @@ Provides-Extra: yaml
 Requires-Dist: apispec (>=6,<7)
 Requires-Dist: marshmallow (>=3,<4)
 Requires-Dist: marshmallow-peewee (>=4,<5) ; extra == "peewee"
-Requires-Dist: marshmallow-sqlalchemy (>=0,<1) ; extra == "sqlalchemy"
+Requires-Dist: marshmallow-sqlalchemy ; extra == "sqlalchemy"
 Requires-Dist: muffin (>=0,<1)
 Requires-Dist: muffin-databases (>=0.5.0,<0.6.0) ; extra == "sqlalchemy"
 Requires-Dist: muffin-peewee-aio (>=0,<1) ; extra == "peewee"
@@ -79,7 +78,7 @@ Features
 Requirements
 =============
 
-- python >= 3.7
+- python >= 3.9
 
 .. note:: Trio is only supported with Peewee ORM
 

muffin_rest-8.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+muffin_rest/__init__.py,sha256=NBZeOEJgQHtFFhVgd9d0fpApFRgU405sbm0cu1y1MOU,1242
+muffin_rest/api.py,sha256=zssoHjqTsa8UCAyxj6TxQVluYPX9Sigyiph6SRxBY6I,3870
+muffin_rest/errors.py,sha256=mxEBhNPo3pwpG2em6zaQonbfRgHFBJ3I8WunVYWDjvM,1163
+muffin_rest/filters.py,sha256=MARP_WsJslncahlgZLTImigl0RTxBtb0jmZbXfJ0c6Y,5637
+muffin_rest/handler.py,sha256=7DjPEtWmq7laWELKLJ6yZUwSdtxFIOps-699N_5_viQ,10277
+muffin_rest/limits.py,sha256=pA5hnDQgrP-euDGjAoczlT_b7Dxzw5btQ-3okkHYKSA,1855
+muffin_rest/marshmallow.py,sha256=jWsZeMj3KslbGGgzEMo8-e5eeuGhmqFolL0mIEquylc,789
+muffin_rest/mongo/__init__.py,sha256=SiYSbX6ySJl43fw9aGREIs8ZsS8Qk_ieizoPOj4DjJc,4656
+muffin_rest/mongo/filters.py,sha256=4TgExaUhJiHkogiZLqjtT13A0O-Uvwfd5AesVfTY2Io,949
+muffin_rest/mongo/schema.py,sha256=y4OEPQnlV_COTIIQ3cKmpqDpD2r18eAWn0rijQldWm0,1205
+muffin_rest/mongo/sorting.py,sha256=iJBnaFwE7g_JMwpGpQkoqSqbQK9XULx1K3skiRRgLgY,870
+muffin_rest/mongo/types.py,sha256=jaODScgwwYbzHis3DY4bPzU1ahiMJMSwquH5_Thi-Gg,200
+muffin_rest/mongo/utils.py,sha256=mNkLM-D6gqOA9YW2Qdw0DvE2N4LRmxLAiPMKH9WLttM,3958
+muffin_rest/openapi.py,sha256=0QU7qrfBjGl0vl378SJC5boZZI2ogddl45fS9WL4Axw,8751
+muffin_rest/options.py,sha256=reHbd2o-F6bKEKc8bznzj0TMY2vzjK6Yt1qOny7kt_w,2691
+muffin_rest/peewee/__init__.py,sha256=94DSj_ftT6fbPksHlBv40AH2HWaiZommUFOMN2jd9a4,129
+muffin_rest/peewee/filters.py,sha256=oghjKwurNCyFUYT0r2TVu2Nd1SIalRsmbU4_RbaoXLs,2440
+muffin_rest/peewee/handler.py,sha256=tfmRzCWCV41x_k9Ysma735MPsNOx-o4Bnp5hFIbSxu0,5354
+muffin_rest/peewee/openapi.py,sha256=lDnLnoXi33p0YeFVwRgaVrndyrG2XL93RH-BzbxinOY,1105
+muffin_rest/peewee/options.py,sha256=TimJtErC9e8B7BRiEkHiBZd71_bZbYr-FE2PIlQvfH0,1455
+muffin_rest/peewee/schemas.py,sha256=w6jBziUp40mOOjkz_4RCXuY0x5ZDIe9Ob25k1FnZSfc,469
+muffin_rest/peewee/sorting.py,sha256=aTLL2zYeNfkamfbGuKkIClOsJktdZZZlzZKafccWxyQ,1977
+muffin_rest/peewee/types.py,sha256=cgCXhpGHkImKwudA1lulZHz5oJswHH168AiW5MhZRCM,155
+muffin_rest/peewee/utils.py,sha256=wXeneVE1IZl1ROnY28re73H62Y1_tEmoEQYzPhuOyBI,702
+muffin_rest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+muffin_rest/redoc.html,sha256=GtuHIMvTuSi8Ro6bgI-G8VB94AljMyfjcZseqtBmGCY,559
+muffin_rest/schemas.py,sha256=BW3dF82C6Q6STs4tZjej1x8Ii1rI3EZUJZR4mNNKmu4,875
+muffin_rest/sorting.py,sha256=7k7dxElnEGiwvdfDivzcoLnAOXqpQoK52H-ss79Gw0g,2813
+muffin_rest/sqlalchemy/__init__.py,sha256=9MSvOXWP6665LiA5O1Icl2V05bpz6Ex5sUHB9YWKLvE,6393
+muffin_rest/sqlalchemy/filters.py,sha256=oVz3he9P_KiYE4fM3Wjka2IUmhkf4gHDOVRzKlz0SA0,2484
+muffin_rest/sqlalchemy/sorting.py,sha256=YlFKpIet4TUy7fJ2UBLC8b9lAOwY66QBpPDDApbyh8M,1643
+muffin_rest/sqlalchemy/types.py,sha256=Exm-zAQCtPAwXvYcCTtPRqSa-wTEWRcH_v2YSsJkB6s,198
+muffin_rest/swagger.html,sha256=2uGLu_KpkYf925KnDKHBJmV9pm6OHn5C3BWScESsUS8,1736
+muffin_rest/types.py,sha256=lU0tAaDu9sKm-30RM1_qOx-hOYEkNRaA72LdWDvg72g,491
+muffin_rest/utils.py,sha256=c08E4HJ4SLYC-91GKPEbsyKTZ4sZbTN4qDqJbNg_HTE,2076
+muffin_rest-8.1.0.dist-info/LICENSE,sha256=xHPkOZhjyKBMOwXpWn9IB_BVLjrrMxv2M9slKkHj2hM,1082
+muffin_rest-8.1.0.dist-info/METADATA,sha256=nsCP8WeRU29Tdlfno68igQTZNIaZin39bWIfY2spMZI,4118
+muffin_rest-8.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+muffin_rest-8.1.0.dist-info/RECORD,,

muffin_rest-7.3.5.dist-info/RECORD

@@ -1,38 +0,0 @@
-muffin_rest/__init__.py,sha256=NBZeOEJgQHtFFhVgd9d0fpApFRgU405sbm0cu1y1MOU,1242
-muffin_rest/api.py,sha256=gCqRb5PgKEMkE84Y0ZnJw_laVRmVWZRxzBqBv0ns6w8,3882
-muffin_rest/errors.py,sha256=TIXSADZYSwx70dOVPRAzuNwGLfpLuzZZ1ugMZMwIGDo,1169
-muffin_rest/filters.py,sha256=lMnPMdy7h0nB9bH-Nf5Hv_qenAGzG0V3ULpizTK3OnM,5623
-muffin_rest/handler.py,sha256=LcPFFH01nwe2tYKYbq-KVDX5UBVMlaRmeisJ_s4jsCo,10035
-muffin_rest/marshmallow.py,sha256=hHPLTLdaSz5jTLWBqyHeOwo2xfBv7aMIuJFD_trHRuE,715
-muffin_rest/mongo/__init__.py,sha256=unoEAKCU9H3EKhQqKGosn02tTS3H5nPOcTd3THM4Qs8,4675
-muffin_rest/mongo/filters.py,sha256=y2FleM_BqkICKGq3PmM_StOgKlE7RoSxt2NdQfCvnOE,921
-muffin_rest/mongo/schema.py,sha256=y4OEPQnlV_COTIIQ3cKmpqDpD2r18eAWn0rijQldWm0,1205
-muffin_rest/mongo/sorting.py,sha256=iJBnaFwE7g_JMwpGpQkoqSqbQK9XULx1K3skiRRgLgY,870
-muffin_rest/mongo/types.py,sha256=Otqu_FyIVnDAUGcwtzY_B77CKNBYApQPO_LlS2aLAQk,206
-muffin_rest/mongo/utils.py,sha256=RZdAiKaTsgaFz8WbIPI_sjjVDsF_VmPu5Agzp5mpbvY,3946
-muffin_rest/openapi.py,sha256=XNhU4EffbKvFKr1HMCqFM-ZrukPqLyZwm3aJe2dNs40,8770
-muffin_rest/options.py,sha256=6K8YD3U-FdItFVjILQxH9h_Hwi68kgzWs97zrtSN_m4,2049
-muffin_rest/peewee/__init__.py,sha256=94DSj_ftT6fbPksHlBv40AH2HWaiZommUFOMN2jd9a4,129
-muffin_rest/peewee/filters.py,sha256=dgbvTBm_V2Iu3penv5y--OWSysQ0ZnUfgGCuHcQKfhU,2433
-muffin_rest/peewee/handler.py,sha256=O84-TmiyNyEhEamTh-DY93ds0hZJzVG8_yekRpF9p3k,5359
-muffin_rest/peewee/openapi.py,sha256=ZZuh7nJVuK9cTJqtOJ_XASe9iJgter-xIjj9YJ8xszI,1111
-muffin_rest/peewee/options.py,sha256=F-UjCbz5rAIXt-D_MtmriiYkOL7wsri6FRt7WCNZzyo,1480
-muffin_rest/peewee/schemas.py,sha256=w6jBziUp40mOOjkz_4RCXuY0x5ZDIe9Ob25k1FnZSfc,469
-muffin_rest/peewee/sorting.py,sha256=jLU9d9h8uCV61NbsjkdhDLvh0lCK_6Os-0kIOI-pKwc,1983
-muffin_rest/peewee/types.py,sha256=cgCXhpGHkImKwudA1lulZHz5oJswHH168AiW5MhZRCM,155
-muffin_rest/peewee/utils.py,sha256=wXeneVE1IZl1ROnY28re73H62Y1_tEmoEQYzPhuOyBI,702
-muffin_rest/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-muffin_rest/redoc.html,sha256=GtuHIMvTuSi8Ro6bgI-G8VB94AljMyfjcZseqtBmGCY,559
-muffin_rest/schemas.py,sha256=FiNUuI7b70zgbg0F0p-CLUSpGmij9uBZDq9fUn9I_q4,814
-muffin_rest/sorting.py,sha256=Z3echqt8ve-p1f7iOVYlFFVsA3ShCXVaXDkVMFTC6tQ,2887
-muffin_rest/sqlalchemy/__init__.py,sha256=WYxb5d4eQqXeT8MwpgdiItAjrOdFm-_5GaG-xtWQ4lk,6362
-muffin_rest/sqlalchemy/filters.py,sha256=bTT7ndx_d0YaDSviDfpzwN9T46dQrV9WbeG8YH9KVBg,2466
-muffin_rest/sqlalchemy/sorting.py,sha256=YlFKpIet4TUy7fJ2UBLC8b9lAOwY66QBpPDDApbyh8M,1643
-muffin_rest/sqlalchemy/types.py,sha256=JnIw44XJ2ClWzOv-mTUrvFw1JPxAlvdX_jf7r4zau-s,204
-muffin_rest/swagger.html,sha256=2uGLu_KpkYf925KnDKHBJmV9pm6OHn5C3BWScESsUS8,1736
-muffin_rest/types.py,sha256=vy55ShzMcvs9zXjFpdjWlagv09dMrcmxb2-U4hTL3NM,521
-muffin_rest/utils.py,sha256=WT87AHXvBFBzBVTkwsYmDXgG3ZX1wNKFo4SOUJ9JiQY,2095
-muffin_rest-7.3.5.dist-info/LICENSE,sha256=xHPkOZhjyKBMOwXpWn9IB_BVLjrrMxv2M9slKkHj2hM,1082
-muffin_rest-7.3.5.dist-info/METADATA,sha256=3S9RVEQb7kpUDE8b1IWRZg6Q27bzmlIS0J7u5SpsRcI,4177
-muffin_rest-7.3.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-muffin_rest-7.3.5.dist-info/RECORD,,