Merge branch 'main' into feature/fix-output-type

mahenzon · web-flow · commit 9368829dea17 · 2022-12-20T16:59:14.000+03:00
diff --git a/examples/api_for_sqlalchemy/api/user.py b/examples/api_for_sqlalchemy/api/user.py
@@ -7,8 +7,8 @@
 from fastapi import Depends
 from sqlalchemy import select, desc
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.sql import Select
 from tortoise.exceptions import DoesNotExist
-from tortoise.queryset import QuerySet
 
 from examples.api_for_sqlalchemy.extensions.sqlalchemy import Connector
 from examples.api_for_sqlalchemy.helpers.factories.meta_base import FactoryUseMode
@@ -19,7 +19,6 @@
 from examples.api_for_sqlalchemy.models.pydantic.user import UserInSchema
 from examples.api_for_sqlalchemy.models.sqlalchemy import User
 from fastapi_rest_jsonapi import SqlalchemyEngine
-
 from fastapi_rest_jsonapi.exceptions import (
     BadRequest,
     HTTPException,
@@ -76,7 +75,7 @@ async def patch(cls, obj_id, data: UserPatchSchema, query_params: QueryStringMan
 
 class UserList:
     @classmethod
-    async def get(cls, query_params: QueryStringManager, session: AsyncSession = Depends(Connector.get_session)) -> Union[QuerySet, JSONAPIResultListSchema]:
+    async def get(cls, query_params: QueryStringManager, session: AsyncSession = Depends(Connector.get_session)) -> Union[Select, JSONAPIResultListSchema]:
         user_query = select(User).order_by(desc(User.id))
         dl = SqlalchemyEngine(query=user_query, schema=UserSchema, model=User, session=session)
         count, users_db = await dl.get_collection(qs=query_params)
diff --git a/fastapi_rest_jsonapi/api.py b/fastapi_rest_jsonapi/api.py
@@ -6,7 +6,7 @@
     List,
     Optional,
     Type,
-    Union,
+    Union, TypeVar,
 )
 
 import pydantic
@@ -21,28 +21,31 @@
     get_detail_jsonapi,
     get_list_jsonapi,
     patch_detail_jsonapi,
-    post_list_jsonapi,
+    post_list_jsonapi, delete_list_jsonapi,
 )
 from fastapi_rest_jsonapi.schema import BasePatchJSONAPISchema, BasePostJSONAPISchema, JSONAPIObjectSchema, \
     JSONAPIResultDetailSchema
 
 JSON_API_RESPONSE_TYPE = Optional[Dict[Union[int, str], Dict[str, Any]]]
 
+TypeAPIRouter = TypeVar("TypeAPIRouter", bound=APIRouter)
+TypeSchema = TypeVar("TypeSchema", bound=BaseModel)
+
 
 class RoutersJSONAPI:
     """API Router interface for JSON API endpoints in web-services."""
 
     def __init__(  # noqa: WPS211
         self,
-        routers: APIRouter,
+        routers: TypeAPIRouter,
         path: Union[str, List[str]],
         tags: List[str],
         class_detail: Any,
         class_list: Any,
-        schema: Type[BaseModel],
+        schema: Type[TypeSchema],
         type_resource: str,
-        schema_in_patch: Type[BaseModel],
-        schema_in_post: Type[BaseModel],
+        schema_in_patch: Type[TypeSchema],
+        schema_in_post: Type[TypeSchema],
         model: Type[TypeModel],
         engine: DBORMType = DBORMType.sqlalchemy,
     ) -> None:
@@ -166,6 +169,21 @@ def _add_routers(self, path: str):
                 )(self.class_list.post)
             )
 
+        if hasattr(self.class_list, "delete"):
+            self._routers.delete(
+                path,
+                tags=self._tags,
+                summary=f"Delete list objects of type `{self._type}`"
+            )(
+                delete_list_jsonapi(
+                    schema=self._schema,
+                    model=self._model,
+                    engine=self._engine,
+                )(
+                    self.class_list.delete
+                )
+            )
+
         if hasattr(self.class_detail, "get"):
             self._routers.get(
                 path + "/{obj_id}",
diff --git a/fastapi_rest_jsonapi/data_layers/data_typing.py b/fastapi_rest_jsonapi/data_layers/data_typing.py
@@ -1,7 +1,6 @@
 from typing import TypeVar
 
-from pydantic import BaseModel
 
 TypeQuery = TypeVar("TypeQuery")
 TypeModel = TypeVar("TypeModel")
-TypeSchema = TypeVar("TypeSchema", bound=BaseModel)
+TypeSchema = TypeVar("TypeSchema")
diff --git a/fastapi_rest_jsonapi/data_layers/filtering/sqlalchemy.py b/fastapi_rest_jsonapi/data_layers/filtering/sqlalchemy.py
@@ -8,7 +8,7 @@
 from sqlalchemy.sql.elements import BinaryExpression
 
 from fastapi_rest_jsonapi.data_layers.shared import create_filters_or_sorts
-from fastapi_rest_jsonapi.exceptions import InvalidFilters
+from fastapi_rest_jsonapi.exceptions import InvalidFilters, InvalidType
 
 from fastapi_rest_jsonapi.data_layers.data_typing import TypeSchema, TypeModel
 from fastapi_rest_jsonapi.schema import get_relationships, get_model_field
@@ -78,8 +78,24 @@ def create_filter(self, schema_field: ModelField, model_column, operator, value)
             )
         # Here we have to deserialize and validate fields, that are used in filtering,
         # so the Enum fields are loaded correctly
-        value = schema_field.type_(value)
-        return getattr(model_column, self.operator)(value)
+
+        if schema_field.sub_fields:
+            # Для случаев когда в схеме тип Union
+            fields = [i for i in schema_field.sub_fields]
+        else:
+            fields = [schema_field]
+        types = [i.type_ for i in fields]
+        clear_value = None
+        errors: List[str] = []
+        for i_type in types:
+            try:
+                clear_value = i_type(value)
+            except (TypeError, ValueError) as ex:
+                errors.append(str(ex))
+        # Если None, при этом поле обязательное (среди типов в аннотации нет None, то кидаем ошибку)
+        if clear_value is None and not any([not i_f.required for i_f in fields]):
+            raise InvalidType(detail=", ".join(errors))
+        return getattr(model_column, self.operator)(clear_value)
 
     def resolve(self) -> FilterAndJoins:
         """Create filter for a particular node of the filter tree"""
@@ -105,13 +121,22 @@ def resolve(self) -> FilterAndJoins:
                 return self._relationship_filtering(value)
 
             schema_field: ModelField = self.schema.__fields__[self.name]
-            if issubclass(schema_field.type_, BaseModel):
-                value = {
-                    'name': self.name,
-                    'op': self.filter_['op'],
-                    'val': value,
-                }
-                return self._relationship_filtering(value)
+            if schema_field.sub_fields:
+                # Для случаев когда в схеме тип Union
+                types = [i.type_ for i in schema_field.sub_fields]
+            else:
+                types = [schema_field.type_]
+            for i_type in types:
+                try:
+                    if issubclass(i_type, BaseModel):
+                        value = {
+                            'name': self.name,
+                            'op': self.filter_['op'],
+                            'val': value,
+                        }
+                        return self._relationship_filtering(value)
+                except (TypeError, ValueError):
+                    pass
 
             return self.create_filter(
                 schema_field=schema_field,
diff --git a/fastapi_rest_jsonapi/data_layers/sqlalchemy_engine.py b/fastapi_rest_jsonapi/data_layers/sqlalchemy_engine.py
@@ -339,7 +339,7 @@ def paginate_query(self, query: Select, paginate_info: PaginationQueryStringMana
         :params paginate_info: pagination information.
         :return: the paginated query
         """
-        if paginate_info.size == 0:
+        if paginate_info.size == 0 or paginate_info.size is None:
             return query
 
         query = query.limit(paginate_info.size)
diff --git a/fastapi_rest_jsonapi/methods.py b/fastapi_rest_jsonapi/methods.py
@@ -23,10 +23,7 @@
 from fastapi_rest_jsonapi.data_layers.tortoise_orm_engine import TortoiseORMEngine
 from fastapi_rest_jsonapi.exceptions.json_api import UnsupportedFeatureORM
 from fastapi_rest_jsonapi.querystring import QueryStringManager
-from fastapi_rest_jsonapi.signature import (
-    is_necessary_request,
-    update_signature,
-)
+from fastapi_rest_jsonapi.signature import update_signature
 
 
 def get_detail_jsonapi(
@@ -41,12 +38,16 @@ def get_detail_jsonapi(
     def inner(func: Callable) -> Callable:
         async def wrapper(request: Request, obj_id: int, **kwargs):
             query_params = QueryStringManager(request=request, schema=schema)
-            data_dict: dict = dict(query_params=query_params, obj_id=obj_id)
-            if is_necessary_request(func):
-                data_dict["request"] = request
-
-            params_function = OrderedDict(signature(func).parameters)
-            data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {"obj_id": obj_id}
+            func_signature = signature(func).parameters
+            for i_name, i_type in OrderedDict(func_signature).items():
+                if i_type.annotation is Request:
+                    data_dict[i_name] = request
+                elif i_type.annotation is QueryStringManager:
+                    data_dict[i_name] = query_params
+
+            data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in func_signature})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in func_signature}
             data_schema: Any = await func(**data_dict)
             return schema_resp(
                 data={
@@ -85,12 +86,18 @@ def patch_detail_jsonapi(
     def inner(func: Callable) -> Callable:
         async def wrapper(request: Request, obj_id: int, data: schema_in, **kwargs):  # type: ignore
             query_params = QueryStringManager(request=request, schema=schema)
-            data_dict: dict = dict(query_params=query_params, obj_id=obj_id, data=getattr(data, "attributes", data))
-            if is_necessary_request(func):
-                data_dict["request"] = request
-
-            params_function = OrderedDict(signature(func).parameters)
-            data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {"obj_id": obj_id}
+            func_signature = signature(func).parameters
+            for i_name, i_type in OrderedDict(func_signature).items():
+                if i_type.annotation is schema_in.__fields__["attributes"].type_:
+                    data_dict[i_name] = getattr(data, 'attributes', data)
+                elif i_type.annotation is Request:
+                    data_dict[i_name] = request
+                elif i_type.annotation is QueryStringManager:
+                    data_dict[i_name] = query_params
+
+            data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in func_signature})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in func_signature}
             data_schema: Any = await func(**data_dict)
             return schema_resp(
                 data={
@@ -120,18 +127,68 @@ def delete_detail_jsonapi(
     def inner(func: Callable) -> Callable:
         async def wrapper(request: Request, obj_id: int, **kwargs):  # type: ignore
             query_params = QueryStringManager(request=request, schema=schema)
-            data_dict: dict = dict(query_params=query_params, obj_id=obj_id)
-            if is_necessary_request(func):
-                data_dict["request"] = request
+            data_dict = {"obj_id": obj_id}
+            func_signature = signature(func).parameters
+            for i_name, i_type in OrderedDict(func_signature).items():
+                if i_type.annotation is Request:
+                    data_dict[i_name] = request
+                elif i_type.annotation is QueryStringManager:
+                    data_dict[i_name] = query_params
+
+            data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in func_signature})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in func_signature}
+            await func(**data_dict)
+            return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+        # mypy ругается что нет метода __signature__, как это обойти красиво- не знаю
+        wrapper.__signature__ = update_signature(  # type: ignore
+            sig=signature(wrapper),
+            other=OrderedDict(signature(func).parameters),
+        )
+        return wrapper
+
+    return inner
+
+
+def delete_list_jsonapi(
+    schema: Type[BaseModel],
+    model: Type[TypeModel],
+    engine: DBORMType,
+) -> Callable:
+    """DELETE method router (Decorator for JSON API)."""
+
+    def inner(func: Callable) -> Callable:
+        async def wrapper(
+            request: Request,
+            filters_list: Optional[str] = Query(
+                None,
+                alias="filter",
+                description="[Filtering docs](https://flask-combo-jsonapi.readthedocs.io/en/latest/filtering.html)"
+                            "\nExamples:\n* filter for timestamp interval: "
+                            '`[{"name": "timestamp", "op": "ge", "val": "2020-07-16T11:35:33.383"},'
+                            '{"name": "timestamp", "op": "le", "val": "2020-07-21T11:35:33.383"}]`',
+            ),
+            **kwargs,
+        ):
+            query_params = QueryStringManager(request=request, schema=schema)
+            data_dict = {}
+            func_signature = signature(func).parameters
+            for i_name, i_type in OrderedDict(func_signature).items():
+                if i_type.annotation is Request:
+                    data_dict[i_name] = request
+                elif i_type.annotation is QueryStringManager:
+                    data_dict[i_name] = query_params
 
             params_function = OrderedDict(signature(func).parameters)
             data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in params_function}
             await func(**data_dict)
             return Response(status_code=status.HTTP_204_NO_CONTENT)
 
         # mypy ругается что нет метода __signature__, как это обойти красиво- не знаю
         wrapper.__signature__ = update_signature(  # type: ignore
             sig=signature(wrapper),
+            schema=schema,
             other=OrderedDict(signature(func).parameters),
         )
         return wrapper
@@ -193,21 +250,21 @@ async def wrapper(
             **kwargs,
         ):
             query_params = QueryStringManager(request=request, schema=schema)
-            data = {
-                i_name: query_params
-                for i_name, i_param in OrderedDict(signature(func).parameters).items()
-                if i_param.annotation is QueryStringManager
-            }
-            if is_necessary_request(func):
-                data["request"] = request
-
-            params_function = OrderedDict(signature(func).parameters)
-            data.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
-            query = await func(**data)
+            data_dict = {}
+            func_signature = signature(func).parameters
+            for i_name, i_type in OrderedDict(func_signature).items():
+                if i_type.annotation is Request:
+                    data_dict[i_name] = request
+                elif i_type.annotation is QueryStringManager:
+                    data_dict[i_name] = query_params
+
+            data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in func_signature})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in func_signature}
+            query = await func(**data_dict)
 
             if engine is DBORMType.sqlalchemy:
                 # Для SQLAlchemy нужно указывать session, для Tortoise достаточно модели
-                session_list = [i_v for i_k, i_v in params_function.items() if isinstance(i_v, AsyncSession)]
+                session_list = [i_v for i_k, i_v in func_signature.items() if isinstance(i_v, AsyncSession)]
                 session: Optional[AsyncSession] = session_list and session_list[0] or None
             else:
                 session = None
@@ -257,12 +314,19 @@ def post_list_jsonapi(
     def inner(func: Callable) -> Callable:
         async def wrapper(request: Request, data: schema_in, **kwargs):  # type: ignore
             query_params = QueryStringManager(request=request, schema=schema)
-            data_dict: dict = dict(query_params=query_params, data=getattr(data, 'attributes', data))
-            if is_necessary_request(func):
-                data_dict["request"] = request
-
-            params_function = OrderedDict(signature(func).parameters)
+            data_dict = {}
+            func_signature = signature(func).parameters
+            for i_name, i_type in OrderedDict(func_signature).items():
+                if i_type.annotation is schema_in.__fields__["attributes"].type_:
+                    data_dict[i_name] = getattr(data, 'attributes', data)
+                elif i_type.annotation is Request:
+                    data_dict[i_name] = request
+                elif i_type.annotation is QueryStringManager:
+                    data_dict[i_name] = query_params
+
+            params_function = OrderedDict(func_signature)
             data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in params_function}
             data_pydantic: Any = await func(**data_dict)
             return schema_resp(
                 data={
diff --git a/fastapi_rest_jsonapi/schema.py b/fastapi_rest_jsonapi/schema.py
@@ -1,10 +1,11 @@
 """Helpers to deal with marshmallow schemas. Base JSON:API schemas."""
+import uuid
 from typing import (
     Dict,
     Type,
     List,
     Optional,
-    Sequence, TYPE_CHECKING,
+    Sequence, TYPE_CHECKING, Union,
 )
 
 from fastapi import FastAPI
@@ -179,7 +180,13 @@ def get_relationships(schema: Type["TypeSchema"], model_field: bool = False) ->
     :param schema: a pydantic schema
     :param model_field: list of relationship fields of a schema
     """
-    relationships = [i_name for i_name, i_type in schema.__fields__.items() if issubclass(i_type.type_, BaseModel)]
+    relationships: List[str] = []
+    for i_name, i_type in schema.__fields__.items():
+        try:
+            if issubclass(i_type.type_, BaseModel):
+                relationships.append(i_name)
+        except TypeError:
+            pass
 
     if model_field is True:
         relationships = [get_model_field(schema, key) for key in relationships]
diff --git a/fastapi_rest_jsonapi/signature.py b/fastapi_rest_jsonapi/signature.py
diff --git a/requirements.txt b/requirements.txt
