muffin-rest 9.2.0__tar.gz → 9.4.0__tar.gz

{muffin_rest-9.2.0 → muffin_rest-9.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: muffin-rest
-Version: 9.2.0
+Version: 9.4.0
 Summary: The package provides enhanced support for writing REST APIs with Muffin framework
 Home-page: https://github.com/klen/muffin-rest
 License: MIT

{muffin_rest-9.2.0 → muffin_rest-9.4.0}/muffin_rest/filters.py

@@ -1,17 +1,20 @@
 """Support API filters."""
+
 from __future__ import annotations
 
 import operator
 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[]
+from asgi_tools._compat import json_loads
 
 from .utils import Mutate, Mutator
 
 if TYPE_CHECKING:
     from muffin import Request
 
+    from muffin_rest.types import TFilterOps, TFilterValue
+
     from .types import TVCollection
 
 FILTERS_PARAM = "where"
@@ -87,7 +90,7 @@ class Filter(Mutate):
 
         return ops, collection
 
-    async def filter(self, collection, *ops: tuple[Callable, Any], **_) -> Any:
+    async def filter(self, collection, *ops: TFilterValue) -> Any:
         """Apply the filter to collection."""
 
         def validator(obj):
@@ -95,12 +98,22 @@ class Filter(Mutate):
 
         return [item for item in collection if validator(item)]
 
-    def parse(self, data: Mapping):
+    def get_simple_value(self, ops: TFilterOps) -> Any:
+        """Get simple value from filter's data.
+
+        In case of simple filter, return the value.
+        """
+        if not ops:
+            return None
+
+        return ops[0][1]
+
+    def parse(self, data: Mapping) -> TFilterOps:
         """Parse operator and value from filter's data."""
         value = data.get(self.name, ma.missing)
         return tuple(self._parse(value))
 
-    def _parse(self, value):
+    def _parse(self, value) -> Iterable[TFilterValue]:
         deserialize = self.schema_field.deserialize
         if isinstance(value, dict):
             for op, val in value.items():

{muffin_rest-9.2.0 → muffin_rest-9.4.0}/muffin_rest/mongo/filters.py

@@ -1,8 +1,9 @@
 """Support filters for Mongo."""
 
-from typing import Any, Callable, ClassVar
+from typing import ClassVar
 
 from muffin_rest.filters import Filter, Filters
+from muffin_rest.types import TFilterValue
 
 
 class MongoFilter(Filter):
@@ -21,7 +22,7 @@ class MongoFilter(Filter):
         "$ends": lambda _, v: ("$regex", f"{ v }$"),
     }
 
-    async def filter(self, collection, *ops: tuple[Callable, Any], **_):
+    async def filter(self, collection, *ops: TFilterValue):
         """Apply the filter."""
         return collection.find({self.field: dict(op(self.name, v) for op, v in ops)})
 

{muffin_rest-9.2.0 → muffin_rest-9.4.0}/muffin_rest/peewee/filters.py

@@ -1,9 +1,10 @@
 """Support filters for Peewee ORM."""
+
 from __future__ import annotations
 
 import operator
 from functools import reduce
-from typing import Any, Callable, ClassVar, Union, cast
+from typing import TYPE_CHECKING, ClassVar, Union, cast
 
 from peewee import ColumnBase, Field, ModelSelect
 
@@ -11,6 +12,9 @@ from muffin_rest.filters import Filter, Filters
 
 from .utils import get_model_field_by_name
 
+if TYPE_CHECKING:
+    from muffin_rest.types import TFilterValue
+
 
 class PWFilter(Filter):
     """Support Peewee."""
@@ -33,9 +37,7 @@ class PWFilter(Filter):
 
     list_ops = (*Filter.list_ops, "$between")
 
-    async def filter(
-        self, collection: ModelSelect, *ops: tuple[Callable, Any], **kwargs
-    ) -> ModelSelect:
+    async def filter(self, collection: ModelSelect, *ops: TFilterValue) -> ModelSelect:
         """Apply the filters to Peewee QuerySet.."""
         column = self.field
         if isinstance(column, ColumnBase):

{muffin_rest-9.2.0 → muffin_rest-9.4.0}/muffin_rest/sqlalchemy/filters.py

@@ -2,13 +2,15 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Union, cast
 
 from sqlalchemy import Column
 
 from muffin_rest.filters import Filter, Filters
 
 if TYPE_CHECKING:
+    from muffin_rest.types import TFilterValue
+
     from .types import TVCollection
 
 
@@ -29,17 +31,15 @@ class SAFilter(Filter):
 
     list_ops = (*Filter.list_ops, "$between")
 
-    async def filter(
-        self, collection: TVCollection, *ops: tuple[Callable, Any], **kwargs
-    ) -> TVCollection:
+    async def filter(self, collection: TVCollection, *ops: TFilterValue) -> TVCollection:
         """Apply the filters to SQLAlchemy Select."""
         column = self.field
         if ops and column is not None:
-            return self.query(collection, column, *ops, **kwargs)
+            return self.query(collection, column, *ops)
 
         return collection
 
-    def query(self, select: TVCollection, column: Column, *ops, **_) -> TVCollection:
+    def query(self, select: TVCollection, column: Column, *ops: TFilterValue) -> TVCollection:
         """Filter a select."""
         return select.where(*[op(column, val) for op, val in ops])
 

{muffin_rest-9.2.0 → muffin_rest-9.4.0}/muffin_rest/types.py

@@ -19,3 +19,6 @@ TAuth = Callable[[Request], Awaitable]
 TVAuth = TypeVar("TVAuth", bound=TAuth)
 TVHandler = TypeVar("TVHandler", bound=type["RESTBase"])
 TSchemaRes = dict[str, Any]
+
+TFilterValue = tuple[Callable, Any]
+TFilterOps = tuple[TFilterValue, ...]

{muffin_rest-9.2.0 → muffin_rest-9.4.0}/pyproject.toml

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