fastgenerateapi 1.1.20__tar.gz → 1.1.24__tar.gz

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastgenerateapi
-Version: 1.1.20
+Version: 1.1.24
 Summary: FastAPIView Class View
 Author: ShiLiang
 Author-email: 2509144896@qq.com

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/__version__.py

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

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/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,7 @@ 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  # 返回序列化
+    schema: Optional[Type[BaseModel]] = None  # 返回序列化[未使用]
     dependencies: Optional[Sequence[params.Depends]] = None
     tags: Optional[List[str]] = None  # swagger标签
     router_args: Dict[str, any] = None
@@ -161,7 +162,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             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)
+        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):
@@ -225,5 +226,31 @@ 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"):
+            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()
+        if not hasattr(self, "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.20 → fastgenerateapi-1.1.24}/fastgenerateapi/api_view/create_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Optional, Type, Union, Any
 
 from fastapi import Depends
@@ -18,16 +19,18 @@ 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()
@@ -91,10 +94,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 +110,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.20 → fastgenerateapi-1.1.24}/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.20 → fastgenerateapi-1.1.24}/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.20 → fastgenerateapi-1.1.24}/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.20 → fastgenerateapi-1.1.24}/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,21 +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:
-                        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 = 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 ""
@@ -191,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.20 → fastgenerateapi-1.1.24}/fastgenerateapi/api_view/get_one_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Any, Union, Optional, Type
 
 from fastapi import Depends
@@ -66,20 +67,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:
-                        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 = 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}"
@@ -87,7 +81,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.20 → fastgenerateapi-1.1.24}/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,
         )

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/api_view/get_tree_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Union, Optional, Type, cast, List, Any, Callable, Coroutine
 
 from fastapi import Depends, Query
@@ -56,7 +57,7 @@ class GetTreeView(BaseView):
             search: str,
             filters: dict,
             request, *args, **kwargs
-    ) -> Union[BaseModel, dict, None]:
+    ):
         if settings.app_settings.METHOD_TREE_CHOICE.upper() == "MAP":
             data_list = await self.map_method(
                 node_id=node_id, search=search, filters=filters, request=request, *args, **kwargs)
@@ -177,9 +178,13 @@ class GetTreeView(BaseView):
             return
         self.search_controller = SearchController(self.get_base_filter(self.search_fields))
         self.filter_controller = FilterController(self.get_base_filter(self.filter_fields))
+
+        func_type = inspect.signature(self.get_tree).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.get_tree_schema = func_type
         self.get_tree_schema = self.get_tree_schema or get_tree_schema_factory(self.model_class)
         self.get_tree_data_schema = get_list_schema_factory(self.get_tree_schema)
-        self.get_tree_response_schema = response_factory(self.get_tree_data_schema, name="GetTree")
+        self.get_tree_response_schema_factory = response_factory(self.get_tree_data_schema, name="GetTree")
         doc = self.get_tree.__doc__
         summary = doc.strip().split("\n")[0] if self.get_tree.__doc__ else "Get Tree"
         path = f"/{settings.app_settings.ROUTER_GET_TREE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
@@ -187,7 +192,7 @@ class GetTreeView(BaseView):
             path=path,
             endpoint=self._get_tree_decorator(),
             methods=["GET"],
-            response_model=self.get_tree_response_schema,
+            response_model=self.get_tree_response_schema_factory,
             summary=summary,
             dependencies=self.get_tree_route,
         )

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/api_view/switch_view.py

@@ -59,10 +59,7 @@ class SwitchView(BaseView):
     def _handler_switch_route_settings(self):
         if not self.switch_route_fields:
             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")
+
         for switch_route_field in self.switch_route_fields:
             if self.model_class._meta.fields_map.get(switch_route_field).field_type not in [bool, int]:
                 self.error(msg=f"{switch_route_field} is not bool or int")
@@ -72,7 +69,7 @@ class SwitchView(BaseView):
                 path="/%s/{pk}" % ("switch_"+switch_route_field),
                 endpoint=self._switch_decorator(switch_route_field),
                 methods=["PUT"],
-                response_model=self.get_one_response_schema,
+                response_model=self.gen_get_one_response_schema_factory(),
                 summary=summary,
                 dependencies=True,
                 error_responses=[NOT_FOUND],

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/api_view/update_relation_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Optional, Type, Union, Any
 
 from fastapi import Depends
@@ -23,6 +24,7 @@ class UpdateRelationView(BaseView, SaveMixin):
     path_id_name: str
     relation_id_name: str
     update_relation_schema: Optional[Type[BaseModel]] = IdList
+    update_relation_response_schema: Optional[Type[BaseModel]] = None
     update_relation_route: Union[bool, DEPENDENCIES] = True
     """
     path_id_name: 路径id在模型中对应的字段名
@@ -72,7 +74,12 @@ class UpdateRelationView(BaseView, SaveMixin):
     def _handler_update_relation_settings(self):
         if not self.update_relation_route:
             return
-        self.update_relation_response_schema = response_factory(name="UpdateRelation")
+
+        func_type = inspect.signature(self.create).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.update_relation_response_schema = func_type
+        self.update_relation_response_schema_factory = response_factory(self.update_relation_response_schema, name="UpdateRelation")
+
         doc = self.update_relation.__doc__
         summary = doc.strip().split("\n")[0] if doc else f"Update {self.model_class.__name__.title()}"
         path = f"/update-{self.relation_id_name.removesuffix('_id')}-by-{self.path_id_name.removesuffix('_id')}/{'{pk}'}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else "/{pk}"
@@ -80,7 +87,7 @@ class UpdateRelationView(BaseView, SaveMixin):
             path=path,
             endpoint=self._update_relation_decorator(),
             methods=["PUT"],
-            response_model=self.update_relation_response_schema,
+            response_model=self.update_relation_response_schema_factory,
             summary=summary,
             dependencies=self.update_relation_route,
             error_responses=[NOT_FOUND],

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/api_view/update_view.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import Optional, Type, Union, Any
 
 from fastapi import Depends
@@ -21,6 +22,7 @@ from fastgenerateapi.utils.exception import NOT_FOUND
 class UpdateView(BaseView, SaveMixin):
 
     update_schema: Optional[Type[BaseModel]] = None
+    update_response_schema: Optional[Type[BaseModel]] = None
     update_route: Union[bool, DEPENDENCIES] = True
     """
     update_schema: 修改请求模型
@@ -81,10 +83,15 @@ class UpdateView(BaseView, SaveMixin):
         if not self.update_route:
             return
         self.update_schema = self.update_schema or update_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.update).return_annotation
+        if func_type != inspect._empty and func_type is not None:
+            self.update_response_schema = func_type
+        if self.update_response_schema:
+            self.update_response_schema_factory = response_factory(self.update_response_schema, name="Update")
+        else:
+            self.update_response_schema_factory = self.gen_get_one_response_schema_factory()
+
         doc = self.update.__doc__
         summary = doc.strip().split("\n")[0] if doc else f"Update"
         path = f"/{settings.app_settings.ROUTER_UPDATE_SUFFIX_FIELD}/{'{pk}'}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else "/{pk}"
@@ -92,7 +99,7 @@ class UpdateView(BaseView, SaveMixin):
             path=path,
             endpoint=self._update_decorator(),
             methods=["PUT"],
-            response_model=self.get_one_response_schema,
+            response_model=self.update_response_schema_factory,
             summary=summary,
             dependencies=self.update_route,
             error_responses=[NOT_FOUND],

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/schemas_factory/get_all_schema_factory.py

@@ -11,6 +11,13 @@ from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_
 from fastgenerateapi.settings.all_settings import settings
 
 
+def hasattr_get_all_schema(model_class: Type[Model],):
+    if not hasattr(model_class, "PydanticMeta"):
+        return False
+    if hasattr(model_class.PydanticMeta, "get_all_include") or hasattr(model_class.PydanticMeta, "get_all_exclude"):
+        return True
+    return False
+
 def get_all_schema_factory(
         model_class: Type[Model],
         include: Union[list, tuple, set] = None,
@@ -21,40 +28,37 @@ def get_all_schema_factory(
     """
     Is used to create a GetAllSchema
     """
-    if not hasattr(model_class, "PydanticMeta"):
-        return None
-    if not include and not extra_include and not exclude and not hasattr(model_class.PydanticMeta, "get_all_include") and not hasattr(model_class.PydanticMeta, "get_all_exclude"):
-        return None
-
     all_fields_info = get_dict_from_model_fields(model_class)
 
     include_fields = set()
     exclude_fields = set()
-
-    if hasattr(model_class.PydanticMeta, "include"):
-        include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.include)
-        all_fields_info.update(include_fields_dict)
-        include_fields.update(include_fields_dict.keys())
+    if hasattr(model_class, "PydanticMeta"):
+        if hasattr(model_class.PydanticMeta, "include"):
+            include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.include)
+            all_fields_info.update(include_fields_dict)
+            include_fields.update(include_fields_dict.keys())
+        else:
+            include_fields.update(all_fields_info.keys())
+        if hasattr(model_class.PydanticMeta, "exclude"):
+            exclude_fields.update(model_class.PydanticMeta.exclude)
+
+        if hasattr(model_class.PydanticMeta, "get_include"):
+            get_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_include)
+            all_fields_info.update(get_include_fields_dict)
+            include_fields.update(get_include_fields_dict.keys())
+        if hasattr(model_class.PydanticMeta, "get_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.get_exclude)
+
+        # get_all_include
+        if hasattr(model_class.PydanticMeta, "get_all_include"):
+            get_all_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_all_include)
+            all_fields_info.update(get_all_include_fields_dict)
+            include_fields.update(get_all_include_fields_dict.keys())
+        # get_all_exclude
+        if hasattr(model_class.PydanticMeta, "get_all_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.get_all_exclude)
     else:
         include_fields.update(all_fields_info.keys())
-    if hasattr(model_class.PydanticMeta, "exclude"):
-        exclude_fields.update(model_class.PydanticMeta.exclude)
-
-    if hasattr(model_class.PydanticMeta, "get_include"):
-        get_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_include)
-        all_fields_info.update(get_include_fields_dict)
-        include_fields.update(get_include_fields_dict.keys())
-    if hasattr(model_class.PydanticMeta, "get_exclude"):
-        exclude_fields.update(model_class.PydanticMeta.get_exclude)
-
-    # get_all_include
-    if hasattr(model_class.PydanticMeta, "get_all_include"):
-        get_all_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_all_include)
-        all_fields_info.update(get_all_include_fields_dict)
-        include_fields.update(get_all_include_fields_dict.keys())
-    # get_all_exclude
-    if hasattr(model_class.PydanticMeta, "get_all_exclude"):
-        exclude_fields.update(model_class.PydanticMeta.get_all_exclude)
 
     # 参数处理
     if include:

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/settings/__init__.py

@@ -4,4 +4,5 @@ from .db_settings import *
 from .file_settings import *
 from .jwt_settings import *
 from .sms_settings import *
+from .etcd_settings import *
 

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/settings/all_settings.py

@@ -1,7 +1,7 @@
 import os
 from functools import lru_cache
 from pathlib import Path
-from typing import Union, Optional, Type
+from typing import Union, Optional
 
 import yaml
 from fastapi.exceptions import ValidationException
@@ -66,10 +66,7 @@ class SettingsModel(BaseModel):
                             content += f"  # {v.description}\n"
                     content += "\n"
         if etcd_settings and etcd_settings.ETCD_SETTING_KEY:
-            import etcd3
-            etcd_dict = etcd_settings.model_dump(exclude_unset=True, by_alias=True, exclude={"ETCD_SETTING_KEY", })
-            etcd = etcd3.client(**{key.removeprefix("ETCD_").lower(): value for key, value in etcd_dict.items()})
-            etcd.put(etcd_settings.ETCD_SETTING_KEY, content)
+            etcd_settings.client.put(etcd_settings.ETCD_SETTING_KEY, content)
         else:
             with open(file=path, mode='w', encoding='utf-8') as f:
                 f.writelines(content)
@@ -78,42 +75,47 @@ class SettingsModel(BaseModel):
     @lru_cache
     def get_global_settings(
             cls,
-            path: Union[Path, str, None] = '.env',
-            etcd_settings: Optional[EtcdSettings] = None,
+            path: Union[Path, str, None] = None,
     ):
         """
         get global settings and set into cache
-        :param path: 可选 .env / application.yaml / etcd.yaml
-        :param etcd_settings: 当储配置 存在etcd 时
+        :param path:
+            None时，自动检测本地文件，优先级 application.yaml，.env
+            推荐参数 .env / application.yaml / etcd.yaml
         :return:
         """
-        setting_models = cls.model_fields.copy()
+        is_yaml = False
+        if path and str(path).__contains__('.yaml'):
+            is_yaml = True
+        elif os.path.isfile("application.yaml"):
+            is_yaml = True
 
+        setting_models = cls.model_fields.copy()
         setting_dict = {}
-        if str(path).__contains__('.env'):
+        if not is_yaml:
             for k, v in setting_models.items():
                 if isinstance(v, FieldInfo):
                     setting_dict[k] = v.annotation(_env_file=str(path))
-        elif str(path).__contains__('.yaml'):
-            data_dict = None
+        else:
+            data_dict = {}
             if os.path.isfile(path):
                 with open(path, 'r', encoding='utf-8') as file:
-                    data_dict = yaml.safe_load(file)
-            else:
-                if not etcd_settings:
-                    etcd_settings = EtcdSettings()
-                if etcd_settings.ETCD_SETTING_KEY:
-                    import etcd3
-                    etcd_dict = etcd_settings.model_dump(exclude_unset=True, by_alias=True, exclude={"ETCD_SETTING_KEY",})
-                    etcd = etcd3.client(**{key.removeprefix("ETCD_").lower(): value for key, value in etcd_dict.items()})
-                    res, metadata = etcd.get(etcd_settings.ETCD_SETTING_KEY)
-                    data_dict = yaml.safe_load(res)
+                    data_dict = yaml.safe_load(file) or {}
+            etcd_settings = EtcdSettings(**data_dict.get("EtcdSettings", {}))
+            if etcd_settings.ETCD_SETTING_KEY:
+                res, metadata = etcd_settings.client.get(etcd_settings.ETCD_SETTING_KEY)
+                data_dict.update(yaml.safe_load(res))
             if not data_dict:
                 raise ValidationException(errors="配置错误")
             for k, v in setting_models.items():
                 if isinstance(v, FieldInfo):
+                    env_prefix = None
                     if hasattr(v.annotation, "Config") and v.annotation.Config.env_prefix:
-                        annotation_dict = {k_i.removeprefix(v.annotation.Config.env_prefix): v_i for k_i, v_i in data_dict.get(v.annotation.__name__, {}).items()}
+                        env_prefix = v.annotation.Config.env_prefix
+                    if not env_prefix and hasattr(v.annotation, "model_config"):
+                        env_prefix = v.annotation.model_config.get("env_prefix")
+                    if env_prefix:
+                        annotation_dict = {k_i.removeprefix(env_prefix): v_i for k_i, v_i in data_dict.get(v.annotation.__name__, {}).items()}
                     else:
                         annotation_dict = data_dict.get(v.annotation.__name__, {})
                     setting_dict[k] = v.annotation(**annotation_dict)
@@ -125,6 +127,14 @@ class SettingsModel(BaseModel):
         settings.redis_settings = setting_data.redis_settings
         return setting_data
 
+    def watch(self):
+        """
+        监听文件或这etcd变化，待完善
+        借用 etcd.watch(target)
+        :return:
+        """
+        ...
+
 
 settings = SettingsModel()
 

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/settings/db_settings.py

@@ -11,7 +11,7 @@ class DBSettings(BaseSettings):
 
     DB_TYPE: Optional[str] = Field(default='mysql', description="数据库类型")
     DB_HOST: Optional[str] = Field(default='127.0.0.1', description="数据库域名")
-    DB_PORT: Optional[str] = Field(default='3306', description="数据库端口")
+    DB_PORT: Optional[int] = Field(default='3306', description="数据库端口")
     DB_DATABASE: Optional[str] = Field(default='admin', description="数据库名")
     DB_USERNAME: Optional[str] = Field(default='root', description="数据库用户名")
     DB_PASSWORD: Optional[str] = Field(default='', description="数据库密码")

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi/settings/etcd_settings.py

@@ -27,6 +27,13 @@ class EtcdSettings(BaseSettings):
         frozen=True,
     )
 
+    @property
+    def client(self):
+        import etcd3
+        etcd_dict = self.model_dump(exclude_unset=True, by_alias=True, exclude={"ETCD_SETTING_KEY", })
+        etcd = etcd3.client(**{key.removeprefix("ETCD_").lower(): value for key, value in etcd_dict.items()})
+
+        return etcd
 
 
 

{fastgenerateapi-1.1.20 → fastgenerateapi-1.1.24}/fastgenerateapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastgenerateapi
-Version: 1.1.20
+Version: 1.1.24
 Summary: FastAPIView Class View
 Author: ShiLiang
 Author-email: 2509144896@qq.com