fastgenerateapi 1.2.5__tar.gz → 1.2.7__tar.gz

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/PKG-INFO

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

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/__version__.py

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

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/base_view.py

@@ -29,7 +29,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
     schema: Optional[Type[BaseModel]] = None  # 返回序列化[未使用]
     dependencies: Optional[Sequence[params.Depends]] = None
     tags: Optional[List[str]] = None  # swagger标签
-    router_args: Dict[str, any] = None
+    check_ignore_error_fields: List[str] = None # 检查唯一字段报错时，不展示这个字段
 
     """
     # 增加外键字段显示
@@ -38,20 +38,6 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
           "avatar": ["id", ("url", "avatar_url")]   # 增加 avatar_id,avatar_url2个字段
     }
     is_with_prefetch: 是否带有列表的prefetch_related_fields
-
-    # router_args: List[Union[str, tuple, BaseRouterSummary]] = None
-    # 给函数设置路由以及其他参数
-    # key为方法名，例如："get_one", "view_get_data"
-    router_args = {
-        "get_one": {
-            "response_model": CommonResponse;
-            "summary": "备注",
-            "dependencies": ["依赖函数"],
-        }
-        // 或者 "get_one": CommonResponse,
-        // 或者 "get_one": "备注",
-        // 或者 "get_one": ["依赖函数"],
-    }
     """
 
     @property
@@ -162,13 +148,15 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             cls,
             data_dict: dict,
             model_class: Type[Model],
-            model: Union[Model, None] = None
+            model: Union[Model, None] = None,
+            check_ignore_error_fields: List[str] = None,
     ):
         """
         校验模型中设置了 唯一索引和联合唯一索引 的字段
         :param data_dict: 修改或创建的数据字典
         :param model_class: 数据库模型
         :param model: 修改前的数据，用于判断是否修改了字段，当唯一字段与数据data_dict一致时，不会做校验
+        :param check_ignore_error_fields: 错误提示忽略字段，会合并类上的字段
         :return:
         """
         check_unique_fields = cls._get_unique_fields(model_class)
@@ -204,6 +192,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
                 continue
 
             if await model_class.filter(**filter_fields).first():
+                ignore_error_field_list = check_ignore_error_fields or []
                 if settings.app_settings.WHETHER_DELETE_FIELD in description_fields:
                     description_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
                 return cls.error(

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/create_view.py

@@ -20,7 +20,7 @@ from fastgenerateapi.settings.all_settings import settings
 
 
 class CreateView(BaseView, SaveMixin):
-
+    create_summary: Optional[str] = None
     create_route: Union[bool, DEPENDENCIES] = True
     create_schema: Optional[Type[BaseModel]] = None
     create_response_schema: Optional[Type[BaseModel]] = None
@@ -116,16 +116,16 @@ class CreateView(BaseView, SaveMixin):
         else:
             self.create_response_schema_factory = self.gen_get_one_response_schema_factory()
             self.create_response_schema = self.get_one_schema
-
-        doc = self.create.__doc__
-        summary = doc.strip().split("\n")[0] if doc else f"Create"
+        if not self.create_summary:
+            doc = self.create.__doc__
+            self.create_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 ""
         self._add_api_route(
             path=path,
             endpoint=self._create_decorator(),
             methods=["POST"],
             response_model=self.create_response_schema_factory,  # type: ignore
-            summary=summary,
+            summary=self.create_summary,
             dependencies=self.create_route,
         )
 

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/delete_filter_view.py

@@ -17,7 +17,7 @@ from fastgenerateapi.settings.all_settings import settings
 
 
 class DeleteFilterView(BaseView):
-
+    delete_filter_summary: Optional[str] = None
     delete_filter_route: Union[bool, DEPENDENCIES] = True
     delete_filter_response_schema: Optional[Type[BaseModel]] = None
     """
@@ -64,16 +64,16 @@ class DeleteFilterView(BaseView):
             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")
-
-        doc = self.destroy_filter.__doc__
-        summary = doc.strip().split("\n")[0] if doc else "Delete Filter"
+        if not self.delete_filter_summary:
+            doc = self.destroy_filter.__doc__
+            self.delete_filter_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 ""
         self._add_api_route(
             path=path,
             endpoint=self._delete_filter_decorator(),
             methods=["DELETE"],
             response_model=self.delete_filter_response_schema_factory,
-            summary=summary,
+            summary=self.delete_filter_summary,
             dependencies=self.delete_filter_route,
         )
 

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/delete_tree_view.py

@@ -18,7 +18,7 @@ from fastgenerateapi.settings.all_settings import settings
 
 
 class DeleteTreeView(BaseView):
-
+    delete_tree_summary: Optional[str] = None
     delete_tree_route: Union[bool, DEPENDENCIES] = True
     delete_tree_schema: Optional[Type[BaseModel]] = IdList
     delete_tree_response_schema: Optional[Type[BaseModel]] = None
@@ -89,16 +89,16 @@ class DeleteTreeView(BaseView):
             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")
-
-        doc = self.destroy_tree.__doc__
-        summary = doc.strip().split("\n")[0] if doc else "Delete Tree"
+        if not self.delete_tree_summary:
+            doc = self.destroy_tree.__doc__
+            self.delete_tree_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 ""
         self._add_api_route(
             path=path,
             endpoint=self._delete_tree_decorator(),
             methods=["DELETE"],
             response_model=self.delete_tree_response_schema_factory,
-            summary=summary,
+            summary=self.delete_tree_summary,
             dependencies=self.delete_tree_route,
         )
 

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/delete_view.py

@@ -18,7 +18,7 @@ from fastgenerateapi.settings.all_settings import settings
 
 
 class DeleteView(BaseView):
-
+    delete_summary: Optional[str] = None
     delete_route: Union[bool, DEPENDENCIES] = True
     delete_schema: Optional[Type[BaseModel]] = IdList
     delete_response_schema: Optional[Type[BaseModel]] = IdList
@@ -35,19 +35,6 @@ class DeleteView(BaseView):
 
         return
 
-    # 弃用思路：唯一字段加时间戳
-    # if unique_fields := self._get_unique_fields(self.model_class):
-    #     for model in await queryset:
-    #         model.is_active = False
-    #         for field in unique_fields:
-    #             try:
-    #                 setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
-    #             except Exception as e:
-    #                 setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
-    #         await model.save()
-    # else:
-    #     await queryset.update(is_active=False)
-
     async def get_del_queryset(self, request_data, *args, **kwargs):
         queryset = self.queryset.filter(id__in=request_data.id_list)
         return queryset
@@ -80,16 +67,16 @@ class DeleteView(BaseView):
             self.delete_response_schema = func_type
         if self.delete_response_schema:
             self.delete_response_schema_factory = response_factory(self.delete_response_schema, name="Delete")
-
-        doc = self.destroy.__doc__
-        summary = doc.strip().split("\n")[0] if doc else "Delete All"
+        if not self.delete_summary:
+            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 ""
         self._add_api_route(
             path=path,
             endpoint=self._delete_decorator(),
             methods=["DELETE"],
             response_model=self.delete_response_schema_factory,
-            summary=summary,
+            summary=self.delete_summary,
             dependencies=self.delete_route,
         )
 

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/get_all_view.py

@@ -20,7 +20,7 @@ from fastgenerateapi.cache.key_builder import generate_key_builder
 from fastgenerateapi.controller import SearchController, BaseFilter, FilterController
 from fastgenerateapi.data_type.data_type import DEPENDENCIES, PYDANTIC_SCHEMA
 from fastgenerateapi.deps import paginator_deps, filter_params_deps
-from fastgenerateapi.deps.filter_params_deps import search_params_deps
+from fastgenerateapi.deps.filter_params_deps import search_params_deps, extra_filter_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, hasattr_get_all_schema
@@ -28,11 +28,13 @@ from fastgenerateapi.settings.all_settings import settings
 
 
 class GetAllView(BaseView, GetMixin):
+    get_all_summary: Optional[str] = None
     get_all_route: Union[bool, DEPENDENCIES] = True
     get_all_schema: Optional[Type[PYDANTIC_SCHEMA]] = None
     search_fields: Union[None, list] = None
-    filter_schema: Optional[Type[PYDANTIC_SCHEMA]] = None
     filter_fields: Union[None, list] = None
+    filter_schema: Optional[Type[PYDANTIC_SCHEMA]] = None
+    extra_filter_schema: Optional[Type[PYDANTIC_SCHEMA]] = None
     order_by_fields: Union[None, list] = None
     auto_add_id_order: bool = True
     """
@@ -46,6 +48,9 @@ class GetAllView(BaseView, GetMixin):
         example：("name__contains", str, "name") 类型是str的时候可以省略，没有第三个值时，自动双下划线转单下划线
     filter_fields: 筛选对应字段
         example： name__contains or (create_at__gt, datetime) or (create_at__gt, datetime, create_time)
+    filter_schema: 筛选对应字段
+        与filter_fields结果合并，存在相同值时，filter_schema覆盖filter_fields
+    extra_filter_schema: 不用于筛选，可用于返回值判断
     order_by_fields: 排序对应字段
     auto_add_id_order: 是否自动在 order_by_fields 后面追加id排序
     """
@@ -78,7 +83,7 @@ class GetAllView(BaseView, GetMixin):
         """
         return queryset
 
-    async def set_get_all_model(self, model: Model) -> Model:
+    async def set_get_all_model(self, model: Model, *args, **kwargs) -> Model:
         """
         对于查询的model，展示数据处理
         """
@@ -110,8 +115,8 @@ class GetAllView(BaseView, GetMixin):
             await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields, *args, **kwargs)
 
             # await self.setattr_model_rpc(self.rpc_class, model, self.rpc_param)
-            model = await self.set_get_model(model)
-            model = await self.set_get_all_model(model)
+            model = await self.set_get_model(model, *args, **kwargs)
+            model = await self.set_get_all_model(model, *args, **kwargs)
 
             if schema:
                 data_list.append(schema.from_orm(model))
@@ -150,12 +155,14 @@ class GetAllView(BaseView, GetMixin):
                 paginator = Depends(paginator_deps()),
                 search: Optional[str] = Depends(search_params_deps(self.search_fields)),
                 filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields, schema=self.filter_schema)),
+                extra_filters: dict = Depends(extra_filter_params_deps(schema=self.extra_filter_schema)),
                 token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.get_all(
                 paginator=paginator,
                 search=search,
                 filters=filters,
+                extra_filters=extra_filters,
                 request=request,
                 token=token,
                 *args,
@@ -191,14 +198,15 @@ class GetAllView(BaseView, GetMixin):
         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_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"
+        if not self.get_all_summary:
+            doc = self.get_all.__doc__
+            self.get_all_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 ""
         self._add_api_route(
             path=path,
             endpoint=self._get_all_decorator(),
             methods=["GET"],
             response_model=self.get_all_response_schema_factory,
-            summary=summary,
+            summary=self.get_all_summary,
             dependencies=self.get_all_route,
         )

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/get_one_view.py

@@ -22,7 +22,7 @@ from fastgenerateapi.utils.exception import NOT_FOUND
 
 
 class GetOneView(BaseView, GetMixin):
-
+    get_one_summary: Optional[str] = None
     get_one_route: Union[bool, DEPENDENCIES] = True
     get_one_schema: Optional[Type[BaseModel]] = None
     """
@@ -45,7 +45,7 @@ class GetOneView(BaseView, GetMixin):
             await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields, *args, **kwargs)
 
         # await self.setattr_model_rpc(self.rpc_class, model, self.rpc_param)
-        model = await self.set_get_model(model)
+        model = await self.set_get_model(model, *args, **kwargs)
 
         return self.get_one_schema.from_orm(model)
 
@@ -77,15 +77,16 @@ class GetOneView(BaseView, GetMixin):
         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"
+        if not self.get_one_summary:
+            doc = self.get_one.__doc__
+            self.get_one_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}"
         self._add_api_route(
             path=path,
             endpoint=self._get_one_decorator(),
             methods=["GET"],
             response_model=self.get_one_response_schema_factory,
-            summary=summary,
+            summary=self.get_one_summary,
             dependencies=self.get_one_route,
             error_responses=[NOT_FOUND],
         )

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/get_relation_view.py

@@ -22,10 +22,10 @@ from fastgenerateapi.settings.all_settings import settings
 
 
 class GetRelationView(BaseView):
-
     path_id_name: str
     relation_id_name: str
     relation_model_class: Optional[Type[Model]]
+    get_relation_summary: Optional[str] = None
     get_relation_route: Union[bool, DEPENDENCIES] = True
     get_relation_schema: Optional[Type[BaseModel]] = None
     search_fields: Union[None, list] = None
@@ -194,15 +194,16 @@ class GetRelationView(BaseView):
         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_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()}"
+        if not self.get_relation_summary:
+            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 ""
         self._add_api_route(
             path=path,
             endpoint=self._get_relation_decorator(),
             methods=["GET"],
             response_model=self.get_relation_response_schema_factory,
-            summary=summary,
+            summary=self.get_relation_summary,
             dependencies=self.get_relation_route,
         )
 

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/get_tree_view.py

@@ -31,7 +31,7 @@ from fastgenerateapi.settings.all_settings import settings
 
 
 class GetTreeView(BaseView):
-
+    get_tree_summary: Optional[str] = None
     get_tree_route: Union[bool, DEPENDENCIES] = True
     get_tree_schema: Optional[Type[BaseModel]] = None
     search_fields: Union[None, list] = None
@@ -187,15 +187,16 @@ class GetTreeView(BaseView):
         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_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"
+        if not self.get_tree_summary:
+            doc = self.get_tree.__doc__
+            self.get_tree_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 ""
         self._add_api_route(
             path=path,
             endpoint=self._get_tree_decorator(),
             methods=["GET"],
             response_model=self.get_tree_response_schema_factory,
-            summary=summary,
+            summary=self.get_tree_summary,
             dependencies=self.get_tree_route,
         )
 

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/mixin/base_mixin.py

@@ -8,9 +8,7 @@ from fastgenerateapi.utils.exception import NOT_FOUND
 
 from fastgenerateapi.controller.filter_controller import BaseFilter
 from fastgenerateapi.controller import RouterController
-from fastgenerateapi.controller.ws_controller import WsController
 
-from fastgenerateapi.settings.all_settings import settings
 from starlette.exceptions import HTTPException
 
 from fastgenerateapi.data_type.data_type import DEPENDENCIES, T, PYDANTIC_SCHEMA
@@ -48,9 +46,6 @@ class BaseMixin(Generic[T], APIRouter, ABC):
                 route_field_func = f"_handler_{route_field.rsplit('_', 1)[0]}_settings"
                 if hasattr(self, route_field) and getattr(self, route_field) and hasattr(self, route_field_func):
                     getattr(self, route_field_func)()
-        # if self.table_name:
-        #     if hasattr(self, "_handler_sql_get_all_settings"):
-        #         getattr(self, "_handler_sql_get_all_settings")()
 
     @staticmethod
     def get_base_filter(fields: list, schema: Optional[PYDANTIC_SCHEMA] = None) -> list:

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/mixin/get_mixin.py

@@ -5,7 +5,7 @@ from fastgenerateapi.pydantic_utils.base_model import BaseModel
 
 class GetMixin:
 
-    async def set_get_model(self, model: Model) -> Model:
+    async def set_get_model(self, model: Model, *args, **kwargs) -> Model:
         """
         修改查询后的model数据
         """

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/update_relation_view.py

@@ -20,11 +20,11 @@ from fastgenerateapi.utils.exception import NOT_FOUND
 
 
 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_summary: Optional[str] = None
     update_relation_route: Union[bool, DEPENDENCIES] = True
     """
     path_id_name: 路径id在模型中对应的字段名
@@ -83,16 +83,16 @@ class UpdateRelationView(BaseView, SaveMixin):
             self.update_relation_response_schema = func_type
         if self.update_relation_response_schema:
             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()}"
+        if not self.update_relation_summary:
+            doc = self.update_relation.__doc__
+            self.update_relation_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}"
         self._add_api_route(
             path=path,
             endpoint=self._update_relation_decorator(),
             methods=["PUT"],
             response_model=self.update_relation_response_schema_factory,
-            summary=summary,
+            summary=self.update_relation_summary,
             dependencies=self.update_relation_route,
             error_responses=[NOT_FOUND],
         )

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/api_view/update_view.py

@@ -25,6 +25,7 @@ class UpdateView(BaseView, SaveMixin):
 
     update_schema: Optional[Type[BaseModel]] = None
     update_response_schema: Optional[Type[BaseModel]] = None
+    update_summary: Optional[str] = None
     update_route: Union[bool, DEPENDENCIES] = True
     """
     update_schema: 修改请求模型
@@ -108,16 +109,16 @@ class UpdateView(BaseView, SaveMixin):
         else:
             self.update_response_schema_factory = self.gen_get_one_response_schema_factory()
             self.update_response_schema = self.get_one_schema
-
-        doc = self.update.__doc__
-        summary = doc.strip().split("\n")[0] if doc else f"Update"
+        if not self.update_summary:
+            doc = self.update.__doc__
+            self.update_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}"
         self._add_api_route(
             path=path,
             endpoint=self._update_decorator(),
             methods=["PUT"],
             response_model=self.update_response_schema_factory,
-            summary=summary,
+            summary=self.update_summary,
             dependencies=self.update_route,
             error_responses=[NOT_FOUND],
         )

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/controller/router_controller.py

@@ -1,5 +1,4 @@
 import inspect
-from typing import Union
 
 from fastgenerateapi.settings.all_settings import settings
 from pydantic import BaseModel
@@ -26,41 +25,19 @@ class BaseRouter(ResponseMixin):
         else:
             self.error(msg=f"方法 {func_name} 中 {method} 不符合规范")
 
-        # 此方案放弃
-        # if self.method == "GET" and not prefix.endswith("/") and not prefix.endswith("{pk}"):
-        #     prefix += "/"
         self.prefix = prefix
-
-        # if function in ["get_one", "get_all", "create", "update", "update_optional", "destroy", "switch"]:
-        #     self.is_new = False
-        # else:
-        #     self.is_new = True
-        router_args = router_class.router_args.get(func_name, {}) if router_class.router_args else {}
-        if router_args:
-            if type(router_args).__name__ == 'ModelMetaclass' and issubclass(router_args, BaseModel):
-                router_args = {"response_model": router_args}
-            if isinstance(router_args, list):
-                router_args = {"dependencies": router_args}
-            if isinstance(router_args, str):
-                router_args = {"summary": router_args}
-
-        self.dependencies = router_args.get("dependencies") if router_args and router_args.get("dependencies") else []
-        self.dependencies += dependencies if dependencies else []
-
-        if router_args and router_args.get("summary"):
-            summary = router_args.get("summary")
-        if summary is None:
+        if not summary:
             doc = getattr(router_class, func_name).__doc__
-            summary = doc.strip().split("\n")[0] if doc else func_name.lstrip("view_").rstrip("_pk").replace("_",
-                                                                                                             " ").title()
+            summary = doc.strip().split("\n")[0] if doc else func_name.lstrip("view_").rstrip("_pk").replace(
+                "_"," ").title()
         self.summary = summary
 
         if func_type != inspect._empty and func_type is not None:
             self.response_model = response_factory(func_type)
-        elif router_args and router_args.get("response_model"):
-            self.response_model = response_factory(router_args.get("response_model"))
         else:
             self.response_model = None
+        self.dependencies = dependencies
+
 
 
 class RouterController:
@@ -101,13 +78,3 @@ class RouterController:
             prefix = prefix_field + middle_field + suffix_field
 
             self.router_data.append(BaseRouter(router_class, func_name, func_type, method, prefix))
-            # self.router_data.setdefault(func_name, BaseRouter(router_class, func_name, method, prefix))
-
-    # def get_summary(self, func_name):
-    #
-    #     return self.router_data.get(func_name).summary
-    #
-    # def get_dependencies(self, func_name, default: Union[bool, DEPENDENCIES] = None):
-    #     dependencies = [] if default is None or isinstance(default, bool) else default
-    #
-    #     return dependencies | self.router_data.get(func_name).dependencies

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/controller/ws_controller.py

@@ -4,22 +4,12 @@ from fastgenerateapi.settings.all_settings import settings
 class WsRouter:
 
     def __init__(self, router_class, path, func_name):
-        router_args = router_class.router_args.get(func_name, {}) if router_class.router_args else {}
-        if router_args and isinstance(router_args, list):
-            router_args = {"dependencies": router_args}
-
-        self.dependencies = router_args.get("dependencies") if router_args and router_args.get("dependencies") else []
+        self.dependencies = []
         self.path = path
         self.func_name = func_name
 
-        name = None
-        if router_args and router_args.get("name"):
-            name = router_args.get("name")
-        if name is None:
-            doc = getattr(router_class, func_name).__doc__
-            if doc:
-                name = doc.strip().split("\n")[0]
-        self.name = name or None
+        doc = getattr(router_class, func_name).__doc__
+        self.name = doc.strip().split("\n")[0] if doc else None
 
 
 class WsController:

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/deps/filter_params_deps.py

@@ -53,3 +53,27 @@ def filter_params_deps(
         return result
 
     return filter_query
+
+
+def extra_filter_params_deps(
+        schema: Optional[PYDANTIC_SCHEMA] = None
+):
+    """
+        生成filter依赖
+    """
+    filter_schema_dep = schema or EmptyPydantic
+
+    def extra_filter_query(
+            filter_schema: filter_schema_dep = Depends(),
+    ) -> dict[str, Any]:
+        """
+            filter 筛选字段依赖
+        :param filter_schema:
+        :return:
+        """
+        result = filter_schema.dict(exclude_none=True)
+        return result
+
+    return extra_filter_query
+
+

{fastgenerateapi-1.2.5 → fastgenerateapi-1.2.7}/fastgenerateapi/example/views.py

@@ -26,10 +26,6 @@ class StaffView(APIView):
         self.model_class = StaffInfo
         self.order_by_fields = ["-created_at"]
         self.prefetch_related_fields = {"company": ["name"]}
-        # self.router_args = {
-        #     # "view_get_staff_list": ListTestSchema
-        #     "view_get_staff_list": TestSchema
-        # }
         self.get_all_schema = StaffReadSchema
         # self.dependencies = [Depends(ADG.authenticate_user_deps), ]
         super().__init__()