fastgenerateapi 1.1.19__tar.gz → 1.2.1__tar.gz

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastgenerateapi
-Version: 1.1.19
+Version: 1.2.1
 Summary: FastAPIView Class View
 Author: ShiLiang
 Author-email: 2509144896@qq.com
@@ -25,7 +25,7 @@ License-File: LICENSE
 
 #### 版本说明
 [pydantic-v2]
-稳定版本：v1.1.15+
+稳定版本：v1.1.29+
 建议python版本：3.9+
 推荐fastapi版本：0.103.2+
 推荐pydantic版本：2.11.5+
@@ -107,16 +107,6 @@ class XxxView(APIView):
     model_class = XxxModel
 ```
 
-#### 继承 APIView 使用，关闭其中部分路由示例
-```python
-from core.crud.api_view import APIView
-
-class XxxView(APIView):
-    create_route = False
-    get_one_route = False
-    update_route = False
-    delete_route = False
-```
 #### 查询/创建/修改字段限制及校验示例
 - 如果有唯一字段或者联合唯一字段自动校验是否为唯一值
 ```python

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/README.md

@@ -7,7 +7,7 @@
 
 #### 版本说明
 [pydantic-v2]
-稳定版本：v1.1.15+
+稳定版本：v1.1.29+
 建议python版本：3.9+
 推荐fastapi版本：0.103.2+
 推荐pydantic版本：2.11.5+
@@ -89,16 +89,6 @@ class XxxView(APIView):
     model_class = XxxModel
 ```
 
-#### 继承 APIView 使用，关闭其中部分路由示例
-```python
-from core.crud.api_view import APIView
-
-class XxxView(APIView):
-    create_route = False
-    get_one_route = False
-    update_route = False
-    delete_route = False
-```
 #### 查询/创建/修改字段限制及校验示例
 - 如果有唯一字段或者联合唯一字段自动校验是否为唯一值
 ```python

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/__init__.py

@@ -7,7 +7,7 @@
 #                                                      .88
 #                                                  d8888P
 
-
+author="石亮"
 from fastgenerateapi.api_view.api_view import APIView, CreateView, GetOneView, GetAllView, UpdateView, DeleteView, \
     SwitchView
 from fastgenerateapi.api_view.get_tree_view import GetTreeView

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/__version__.py

@@ -8,7 +8,7 @@
 #                                                  d8888P
 
 
-VERSION = (1, 1, 19)
+VERSION = (1, 2, 1)
 
 __version__ = '.'.join(map(str, VERSION))
 

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/base_view.py

@@ -15,6 +15,7 @@ from fastgenerateapi.api_view.mixin.base_mixin import BaseMixin
 from fastgenerateapi.api_view.mixin.dbmodel_mixin import DBModelMixin
 from fastgenerateapi.api_view.mixin.response_mixin import ResponseMixin
 from fastgenerateapi.api_view.mixin.tool_mixin import ToolMixin
+from fastgenerateapi.schemas_factory import get_one_schema_factory, response_factory
 from fastgenerateapi.settings.all_settings import settings
 from fastgenerateapi.utils.exception import NOT_FOUND
 
@@ -24,7 +25,8 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
     prefix: Optional[str] = None  # 路由追加后缀
     model_class: Optional[Type[Model]] = None  # 数据库模型
     prefetch_related_fields: Union[None, dict] = None
-    schema: Optional[Type[BaseModel]] = None  # 返回序列化
+    is_with_prefetch: Optional[bool] = False
+    schema: Optional[Type[BaseModel]] = None  # 返回序列化[未使用]
     dependencies: Optional[Sequence[params.Depends]] = None
     tags: Optional[List[str]] = None  # swagger标签
     router_args: Dict[str, any] = None
@@ -35,6 +37,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
           "avatar": None,           # 外键内容对应字典的形式
           "avatar": ["id", ("url", "avatar_url")]   # 增加 avatar_id,avatar_url2个字段
     }
+    is_with_prefetch: 是否带有列表的prefetch_related_fields
 
     # router_args: List[Union[str, tuple, BaseRouterSummary]] = None
     # 给函数设置路由以及其他参数
@@ -157,36 +160,46 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
     @classmethod
     async def check_unique_field(
             cls,
-            request_data: Union[BaseModel, Model],  # 创建或修改的参数数据
-            model_class: Type[Model],       # 数据库模型
+            data_dict: dict,
+            model_class: Type[Model],
             model: Union[Model, None] = None
     ):
-        check_unique_fields = cls._get_unique_fields(model_class) + cls._get_foreign_key_fields(model_class)
+        """
+        校验模型中设置了 唯一索引和联合唯一索引 的字段
+        :param data_dict: 修改或创建的数据字典
+        :param model_class: 数据库模型
+        :param model: 修改前的数据，用于判断是否修改了字段，当唯一字段与数据data_dict一致时，不会做校验
+        :return:
+        """
+        check_unique_fields = cls._get_unique_fields(model_class)
         check_unique_together_fields = cls._get_unique_together_fields(model_class)
         for unique_field in check_unique_fields:
-            if hasattr(request_data, unique_field):
-                if model and getattr(request_data, unique_field) == getattr(model, unique_field):
+            if unique_field in data_dict:
+                unique_field_value = data_dict.get(unique_field)
+                if model and unique_field_value == getattr(model, unique_field):
                     continue
-                if await model_class.filter(**{unique_field: getattr(request_data, unique_field)}).first():
-                    return cls.error(msg=f"{cls.get_field_description(model_class, unique_field)}已存在相同值：{getattr(request_data, unique_field)}")
+                if await model_class.filter(**{unique_field: unique_field_value}).first():
+                    return cls.error(msg=f"{cls.get_field_description(model_class, unique_field)}已存在相同值：{unique_field_value}")
         for unique_together_fields in check_unique_together_fields:
             filter_fields = {}
             is_equal = True
             description_fields = []
             for unique_together_field in unique_together_fields:
+                has_unique_together_field = unique_together_field in data_dict
+                unique_together_field_value = data_dict.get(unique_together_field)
                 if model:
-                    if hasattr(request_data, unique_together_field):
-                        filter_fields[unique_together_field] = getattr(request_data, unique_together_field)
-                        if getattr(request_data, unique_together_field, None) != getattr(model, unique_together_field):
+                    if has_unique_together_field:
+                        filter_fields[unique_together_field] = unique_together_field_value
+                        if unique_together_field_value != getattr(model, unique_together_field):
                             is_equal = False
                             description_fields.append(unique_together_field)
                     else:
                         filter_fields[unique_together_field] = getattr(model, unique_together_field)
                 else:
-                    if hasattr(request_data, unique_together_field):
+                    if has_unique_together_field:
                         is_equal = False
                         description_fields.append(unique_together_field)
-                        filter_fields[unique_together_field] = getattr(request_data, unique_together_field)
+                        filter_fields[unique_together_field] = unique_together_field_value
             if is_equal:
                 continue
 
@@ -225,5 +238,30 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             result[key] = val[0]
         return result
 
+    def gen_get_one_response_schema(self):
+        if not hasattr(self, "get_one_schema") or not self.get_one_schema:
+            get_one_schema_include = []
+            if hasattr(self, "is_with_prefetch") and self.is_with_prefetch and self.prefetch_related_fields:
+                for key, value in self.prefetch_related_fields.items():
+                    if value and type(value) in [list, tuple, set]:
+                        for val in value:
+                            val_str = val
+                            if type(val) in [list, tuple, set]:
+                                val_str = val[0]
+                            get_one_schema_include.append(key + "__" + val_str)
+            self.get_one_schema = get_one_schema_factory(model_class=self.model_class, include=get_one_schema_include)
+
+        return self.get_one_schema
+
+    def gen_get_one_response_schema_factory(self):
+        """
+        如果get_one_response_schema不存在，则生成
+        :return:
+        """
+        self.gen_get_one_response_schema()
+        self.get_one_response_schema_factory = response_factory(self.get_one_schema, name="GetOne")
+
+        return self.get_one_response_schema_factory
+
 
 

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/create_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Optional, Type, Union, Any
 
 from fastapi import Depends
@@ -18,58 +19,67 @@ from fastgenerateapi.settings.all_settings import settings
 
 class CreateView(BaseView, SaveMixin):
 
-    create_schema: Optional[Type[BaseModel]] = None
     create_route: Union[bool, DEPENDENCIES] = True
+    create_schema: Optional[Type[BaseModel]] = None
+    create_response_schema: Optional[Type[BaseModel]] = None
     """
+    create_route: 创建路由开关，可以放依赖函数列表
     create_schema: 创建请求模型;
         优先级：  
             - create_schema：参数传入
             - create_schema_factory：数据库模型自动生成
                 - 优选模型层[include, exclude, create_include, create_exclude](同时存在交集)
                 - 无include和exclude默认模型层所有字段
-    create_route: 创建路由开关，可以放依赖函数列表
+    create_response_schema: 创建返回模型
     """
 
     @atomic()
     async def create(self, request_data, *args, **kwargs):
         try:
-            model = await self.set_create_fields(request_data=request_data, *args, **kwargs)
+            data_dict = await self.set_create_fields(request_data=request_data, *args, **kwargs)
+            data_dict = await self.set_save_fields(data_dict, request_data=request_data, *args, **kwargs)
+            model = await self.set_create_model(data_dict, request_data=request_data, *args, **kwargs)
         except ValueError as e:
             error_field = str(e).split(" ")[0]
             if getattr(request_data, error_field):
                 return self.error(msg=f"{self.get_field_description(self.model_class, error_field)}格式不正确")
             return self.error(msg=f"{self.get_field_description(self.model_class, error_field)}不能为空")
 
-        model = await self.set_save_model(model=model, request_data=request_data, *args, **kwargs)
-
-        model = await self.set_create_model(model=model, request_data=request_data, *args, **kwargs)
-
-        await self.check_unique_field(model, model_class=self.model_class)
-
+        await self.check_unique_field(data_dict, model_class=self.model_class)
         await model.save()
 
-        model = await self.model_class.filter(id=model.id).prefetch_related(
-            *self.prefetch_related_fields.keys()).first()
-
-        await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields)
+        if settings.app_settings.WHETHER_CREATE_RESPONSE_DATA:
+            if self.is_with_prefetch:
+                model = await self.get_object(model.id, self.model_class, self.is_with_prefetch)
+                await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields)
 
-        # await self.setattr_model_rpc(self.rpc_class, model, self.rpc_param)
+            return self.create_response_schema.model_validate(model)
 
-        return self.get_one_schema.from_orm(model)
+        return
 
-    async def set_create_fields(self, request_data, *args, **kwargs):
+    async def set_create_fields(self, request_data, *args, **kwargs) -> dict:
         """
-        添加属性: request_data.user_id = request.user.id
+        添加属性:
+            data_dict = request_data.dict(exclude_unset=True)
+            data_dict.update({
+                "user_id": request.user.id,
+            })
+            return data_dict
         """
 
-        return self.model_class(**request_data.dict(exclude_unset=True))
+        return request_data.dict(exclude_unset=True)
 
-    async def set_create_model(self, model: Model, request_data, *args, **kwargs) -> Model:
+    async def set_create_model(self, data_dict: dict, request_data, *args, **kwargs) -> Model:
         """
-        添加属性: model.user_id = request.user.id
+        在数据模型校验前后修改值
+        - 可用于全局修改
+        添加属性:
+        data_dict.update({
+            "user_id": request.user.id,
+        })
         """
 
-        return model
+        return self.model_class(**data_dict)
 
     def _create_decorator(self, *args: Any, **kwargs: Any) -> DecoratedCallable:
         async def route(
@@ -91,10 +101,15 @@ class CreateView(BaseView, SaveMixin):
         if not self.create_route:
             return
         self.create_schema = self.create_schema or create_schema_factory(self.model_class)
-        if not hasattr(self, "get_one_schema"):
-            self.get_one_schema = get_one_schema_factory(model_class=self.model_class)
-        if not hasattr(self, "get_one_response_schema"):
-            self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
+
+        func_type = inspect.signature(self.create).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.create_response_schema = func_type
+        if self.create_response_schema:
+            self.create_response_schema_factory = response_factory(self.create_response_schema, name="Create")
+        else:
+            self.create_response_schema_factory = self.gen_get_one_response_schema_factory()
+
         doc = self.create.__doc__
         summary = doc.strip().split("\n")[0] if doc else f"Create"
         path = f"/{settings.app_settings.ROUTER_CREATE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
@@ -102,7 +117,7 @@ class CreateView(BaseView, SaveMixin):
             path=path,
             endpoint=self._create_decorator(),
             methods=["POST"],
-            response_model=self.get_one_response_schema,  # type: ignore
+            response_model=self.create_response_schema_factory,  # type: ignore
             summary=summary,
             dependencies=self.create_route,
         )

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/delete_filter_view.py

@@ -1,8 +1,10 @@
+import inspect
 from typing import Optional, Type, Any, Union
 
 from fastapi import Query, Depends
 from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
+from pydantic import BaseModel
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 from tortoise.transactions import atomic
@@ -17,9 +19,12 @@ from fastgenerateapi.settings.all_settings import settings
 class DeleteFilterView(BaseView):
 
     delete_filter_route: Union[bool, DEPENDENCIES] = True
+    delete_filter_response_schema: Optional[Type[BaseModel]] = None
     """
     必须继承 GetAllView 才能使用
     与 GetAllView 同步的筛选条件
+    delete_filter_route: 删除路由开关，可以放依赖函数列表
+    delete_filter_response_schema: 删除返回模型
     """
 
     @atomic()
@@ -50,10 +55,15 @@ class DeleteFilterView(BaseView):
     def _handler_destroy_filter_settings(self):
         if self.delete_filter_route:
             return
-        if not hasattr(self, "get_one_schema"):
-            self.get_one_schema = get_one_schema_factory(model_class=self.model_class)
-        if not hasattr(self, "get_one_response_schema"):
-            self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
+
+        func_type = inspect.signature(self.destroy_filter).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.delete_filter_response_schema = func_type
+        if self.delete_filter_response_schema:
+            self.delete_filter_response_schema_factory = response_factory(self.delete_filter_response_schema, name="DeleteFilter")
+        else:
+            self.delete_filter_response_schema_factory = self.gen_get_one_response_schema_factory()
+
         doc = self.destroy_filter.__doc__
         summary = doc.strip().split("\n")[0] if doc else "Delete Filter"
         path = f"/{settings.app_settings.ROUTER_FILTER_DELETE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
@@ -61,7 +71,7 @@ class DeleteFilterView(BaseView):
             path=path,
             endpoint=self._delete_filter_decorator(),
             methods=["DELETE"],
-            response_model=Optional[self.get_one_response_schema],
+            response_model=Optional[self.delete_filter_response_schema_factory],
             summary=summary,
             dependencies=self.delete_filter_route,
         )

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/delete_tree_view.py

@@ -1,3 +1,4 @@
+import inspect
 import time
 from typing import Optional, Type, Any, Union
 
@@ -20,9 +21,11 @@ class DeleteTreeView(BaseView):
 
     delete_tree_route: Union[bool, DEPENDENCIES] = True
     delete_tree_schema: Optional[Type[BaseModel]] = IdList
+    delete_tree_response_schema: Optional[Type[BaseModel]] = None
     """
     delete_route: 删除路由开关，可以放依赖函数列表
     delete_schema: 删除请求模型
+    delete_tree_response_schema: 删除返回模型
     """
 
     @atomic()
@@ -77,10 +80,15 @@ class DeleteTreeView(BaseView):
     def _handler_delete_tree_settings(self):
         if self.delete_tree_route:
             return
-        if not hasattr(self, "get_one_schema"):
-            self.get_one_schema = get_one_schema_factory(model_class=self.model_class)
-        if not hasattr(self, "get_one_response_schema"):
-            self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
+
+        func_type = inspect.signature(self.destroy_tree).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.delete_tree_response_schema = func_type
+        if self.delete_tree_response_schema:
+            self.delete_tree_response_schema_factory = response_factory(self.delete_tree_response_schema, name="DeleteTree")
+        else:
+            self.delete_tree_response_schema_factory = self.gen_get_one_response_schema_factory()
+
         doc = self.destroy_tree.__doc__
         summary = doc.strip().split("\n")[0] if doc else "Delete Tree"
         path = f"/{settings.app_settings.ROUTER_RECURSION_DELETE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
@@ -88,7 +96,7 @@ class DeleteTreeView(BaseView):
             path=path,
             endpoint=self._delete_tree_decorator(),
             methods=["DELETE"],
-            response_model=Optional[self.get_one_response_schema],
+            response_model=Optional[self.delete_tree_response_schema_factory],
             summary=summary,
             dependencies=self.delete_tree_route,
         )

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/delete_view.py

@@ -1,3 +1,4 @@
+import inspect
 import time
 from typing import Optional, Type, Any, Union
 
@@ -20,9 +21,11 @@ class DeleteView(BaseView):
 
     delete_route: Union[bool, DEPENDENCIES] = True
     delete_schema: Optional[Type[BaseModel]] = IdList
+    delete_response_schema: Optional[Type[BaseModel]] = IdList
     """
     delete_route: 删除路由开关，可以放依赖函数列表
     delete_schema: 删除请求模型
+    delete_response_schema: 删除返回模型
     """
 
     @atomic()
@@ -67,10 +70,15 @@ class DeleteView(BaseView):
     def _handler_delete_settings(self):
         if not self.delete_route:
             return
-        if not hasattr(self, "get_one_schema"):
-            self.get_one_schema = get_one_schema_factory(model_class=self.model_class)
-        if not hasattr(self, "get_one_response_schema"):
-            self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
+
+        func_type = inspect.signature(self.destroy).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.delete_response_schema = func_type
+        if self.delete_response_schema:
+            self.delete_response_schema_factory = response_factory(self.delete_response_schema, name="Delete")
+        else:
+            self.delete_response_schema_factory = self.gen_get_one_response_schema_factory()
+
         doc = self.destroy.__doc__
         summary = doc.strip().split("\n")[0] if doc else "Delete All"
         path = f"/{settings.app_settings.ROUTER_DELETE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
@@ -78,7 +86,7 @@ class DeleteView(BaseView):
             path=path,
             endpoint=self._delete_decorator(),
             methods=["DELETE"],
-            response_model=Optional[self.get_one_response_schema],
+            response_model=Optional[self.delete_response_schema_factory],
             summary=summary,
             dependencies=self.delete_route,
         )

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/get_all_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Union, Optional, Type, cast, List, Any, Callable, Coroutine
 
 from fastapi import Depends, Query
@@ -22,7 +23,7 @@ from fastgenerateapi.deps import paginator_deps, filter_params_deps
 from fastgenerateapi.deps.filter_params_deps import search_params_deps
 from fastgenerateapi.schemas_factory import get_all_schema_factory, get_page_schema_factory, get_one_schema_factory, \
     response_factory
-from fastgenerateapi.schemas_factory.get_all_schema_factory import get_list_schema_factory
+from fastgenerateapi.schemas_factory.get_all_schema_factory import get_list_schema_factory, hasattr_get_all_schema
 from fastgenerateapi.settings.all_settings import settings
 
 
@@ -49,7 +50,7 @@ class GetAllView(BaseView, GetMixin):
     auto_add_id_order: 是否自动在 order_by_fields 后面追加id排序
     """
 
-    async def get_all(self, search: Optional[str], filters: dict, *args, **kwargs) -> Union[BaseModel, dict, None]:
+    async def get_all(self, search: Optional[str], filters: dict, *args, **kwargs):
         queryset = await self.get_queryset(search=search, filters=filters, *args, **kwargs)
 
         return await self.pagination_data(queryset=queryset, *args, **kwargs)
@@ -169,18 +170,25 @@ class GetAllView(BaseView, GetMixin):
             return
         self.search_controller = SearchController(self.get_base_filter(self.search_fields))
         self.filter_controller = FilterController(self.get_base_filter(self.filter_fields, self.filter_schema))
-        get_all_schema_include = []
-        if self.prefetch_related_fields:
-            for key, value in self.prefetch_related_fields.items():
-                if value and type(value) in [list, tuple, set]:
-                    for val in value:
-                        get_all_schema_include.append(key + "__" + val)
-        self.get_all_schema = self.get_all_schema or get_all_schema_factory(
-            self.model_class, include=get_all_schema_include
-        ) or self.get_one_schema if hasattr(self, "get_one_schema") else get_one_schema_factory(self.model_class)
+
+        func_type = inspect.signature(self.get_all).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.get_all_schema = func_type
+        if not self.get_all_schema:
+            get_all_schema_include = []
+            if self.prefetch_related_fields:
+                for key, value in self.prefetch_related_fields.items():
+                    if value and type(value) in [list, tuple, set]:
+                        for val in value:
+                            val_str = val
+                            if type(val) in [list, tuple, set]:
+                                val_str = val[0]
+                            get_all_schema_include.append(key + "__" + val_str)
+            self.get_all_schema = get_all_schema_factory(self.model_class, include=get_all_schema_include) \
+                if (get_all_schema_include or hasattr_get_all_schema(self.model_class)) else self.gen_get_one_response_schema()
         self.get_page_schema = get_page_schema_factory(self.get_all_schema)
         self.get_list_schema = get_list_schema_factory(self.get_all_schema)
-        self.get_all_response_schema = response_factory(self.get_page_schema, name="GetPage")
+        self.get_all_response_schema_factory = response_factory(self.get_page_schema, name="GetPage")
         doc = self.get_all.__doc__
         summary = doc.strip().split("\n")[0] if doc else "Get All"
         path = f"/{settings.app_settings.ROUTER_GET_ALL_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
@@ -188,7 +196,7 @@ class GetAllView(BaseView, GetMixin):
             path=path,
             endpoint=self._get_all_decorator(),
             methods=["GET"],
-            response_model=self.get_all_response_schema,
+            response_model=self.get_all_response_schema_factory,
             summary=summary,
             dependencies=self.get_all_route,
         )

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/get_one_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Any, Union, Optional, Type
 
 from fastapi import Depends
@@ -24,7 +25,6 @@ class GetOneView(BaseView, GetMixin):
 
     get_one_route: Union[bool, DEPENDENCIES] = True
     get_one_schema: Optional[Type[BaseModel]] = None
-    is_with_prefetch: Optional[bool] = False
     """
     get_one_route: 获取详情路由开关，可以放依赖函数列表
     get_one_schema: 返回序列化
@@ -34,6 +34,8 @@ class GetOneView(BaseView, GetMixin):
                 - 优选模型层get_one_include和get_one_exclude(同时存在交集)
                 - 合并模型层include和exclude(同时存在交集)
                 - 模型层所有字段
+
+    prefetch_related_fields：额外展示字段
     is_with_prefetch: 是否带有列表的prefetch_related_fields
     """
 
@@ -66,17 +68,13 @@ class GetOneView(BaseView, GetMixin):
     def _handler_get_one_settings(self):
         if not self.get_one_route:
             return
-        get_one_schema_include = []
-        if self.is_with_prefetch and self.prefetch_related_fields:
-            for key, value in self.prefetch_related_fields.items():
-                if value and type(value) in [list, tuple, set]:
-                    for val in value:
-                        get_one_schema_include.append(key + "__" + val)
-        self.get_one_schema = self.schema or self.get_one_schema or get_one_schema_factory(
-            model_class=self.model_class,
-            include=get_one_schema_include,
-        )
-        self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
+
+        func_type = inspect.signature(self.get_one).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.get_one_schema = func_type
+        if not self.get_one_schema:
+            self.get_one_schema = self.gen_get_one_response_schema()
+        self.get_one_response_schema_factory = response_factory(self.get_one_schema, name="GetOne")
         doc = self.get_one.__doc__
         summary = doc.strip().split("\n")[0] if self.get_one.__doc__ else "Get One"
         path = f"/{settings.app_settings.ROUTER_GET_ONE_SUFFIX_FIELD}/{'{pk}'}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else "/{pk}"
@@ -84,7 +82,7 @@ class GetOneView(BaseView, GetMixin):
             path=path,
             endpoint=self._get_one_decorator(),
             methods=["GET"],
-            response_model=self.get_one_response_schema,
+            response_model=self.get_one_response_schema_factory,
             summary=summary,
             dependencies=self.get_one_route,
             error_responses=[NOT_FOUND],

{fastgenerateapi-1.1.19 → fastgenerateapi-1.2.1}/fastgenerateapi/api_view/get_relation_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Union, Optional, Type, cast, List, Any
 
 from fastapi import Depends, Query
@@ -53,7 +54,7 @@ class GetRelationView(BaseView):
     relation_order_by_fields: 多对多关联表排序对应字段
     """
 
-    async def get_relation(self, pk: str, search: str, filters: dict, relation_filters: dict, *args, **kwargs) -> Union[BaseModel, dict, None]:
+    async def get_relation(self, pk: str, search: str, filters: dict, relation_filters: dict, *args, **kwargs):
         relation_queryset = await self.get_relation_queryset(filters=relation_filters, *args, **kwargs)
         id_list = relation_queryset.filter(eval(f"Q({self.path_id_name}='{pk}')")).values_list(self.relation_id_name, flat=True)
 
@@ -183,10 +184,14 @@ class GetRelationView(BaseView):
         self.search_controller = SearchController(self.get_base_filter(self.search_fields))
         self.filter_controller = FilterController(self.get_base_filter(self.filter_fields))
         self.filter_relation_controller = FilterController(self.get_base_filter(self.relation_filter_fields))
+
+        func_type = inspect.signature(self.get_relation).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.get_relation_schema = func_type
         self.get_relation_schema = self.get_relation_schema or get_relation_schema_factory(self.model_class)
         self.get_relation_page_schema = get_page_schema_factory(self.get_relation_schema)
         self.get_relation_list_schema = get_list_schema_factory(self.get_relation_schema)
-        self.get_relation_response_schema = response_factory(self.get_relation_page_schema, name="GetPage")
+        self.get_relation_response_schema_factory = response_factory(self.get_relation_page_schema, name="GetPage")
         doc = self.get_relation.__doc__
         summary = doc.strip().split("\n")[0] if doc else f"Get {self.model_class.__name__.title()}"
         path = f"/get-{self.relation_id_name.removesuffix('_id')}-by-{self.path_id_name.removesuffix('_id')}/{'{pk}'}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
@@ -194,7 +199,7 @@ class GetRelationView(BaseView):
             path=path,
             endpoint=self._get_relation_decorator(),
             methods=["GET"],
-            response_model=self.get_relation_response_schema,
+            response_model=self.get_relation_response_schema_factory,
             summary=summary,
             dependencies=self.get_relation_route,
         )