fastgenerateapi 1.1.13__tar.gz → 1.1.16__tar.gz

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastgenerateapi
-Version: 1.1.13
+Version: 1.1.16
 Summary: FastAPIView Class View
 Author: ShiLiang
 Author-email: 2509144896@qq.com
@@ -24,15 +24,17 @@ License-File: LICENSE
 [Github](https://github.com/ShiLiangAPI)
 
 #### 版本说明
-最新版本：v1.1.7+
+[pydantic-v2]
+稳定版本：v1.1.15+
 建议python版本：3.9+
 推荐fastapi版本：0.103.2+
 推荐pydantic版本：2.11.5+
 
+[pydantic-v1]
 稳定版本：v0.0.21
 建议python版本：3.9+
 推荐fastapi版本：0.97.0
-
+推荐pydantic版本：1.10.9+
 
 
 ###### FastGenerateApi 使用说明

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/README.md

@@ -6,15 +6,17 @@
 [Github](https://github.com/ShiLiangAPI)
 
 #### 版本说明
-最新版本：v1.1.7+
+[pydantic-v2]
+稳定版本：v1.1.15+
 建议python版本：3.9+
 推荐fastapi版本：0.103.2+
 推荐pydantic版本：2.11.5+
 
+[pydantic-v1]
 稳定版本：v0.0.21
 建议python版本：3.9+
 推荐fastapi版本：0.97.0
-
+推荐pydantic版本：1.10.9+
 
 
 ###### FastGenerateApi 使用说明

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/__version__.py

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

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/base_view.py

@@ -58,11 +58,10 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
 
         return self.get_active_queryset(self.model_class)
 
-    def get_active_queryset(self, model_class: Union[Type[Model], QuerySet, None] = None) -> QuerySet:
+    @staticmethod
+    def get_active_queryset(model_class: Union[Type[Model], QuerySet, None] = None) -> QuerySet:
         if not model_class:
-            if not self.model_class:
-                return self.error(msg="model_class not allow None")
-            model_class = self.model_class
+            raise ResponseMixin.error(f"model_class not allow None")
         delete_filter_dict = {settings.app_settings.WHETHER_DELETE_FIELD: True}
         if settings.app_settings.DELETE_FIELD_TYPE == "time":
             delete_filter_dict = {settings.app_settings.WHETHER_DELETE_FIELD: 0}
@@ -76,26 +75,26 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             return self.error(msg="relation_model_class not allow None")
         return self.get_active_queryset(self.relation_model_class)
 
-    async def get_object(self, pk, model_class=None, is_with_prefetch=False):
-        if model_class:
-            queryset = self.get_active_queryset(model_class).filter(id=pk)
-        else:
-            queryset = self.queryset.filter(id=pk)
+    @classmethod
+    async def get_object(cls, pk, model_class, is_with_prefetch=False):
+        queryset = cls.get_active_queryset(model_class).filter(id=pk)
         if is_with_prefetch:
-            queryset = queryset.prefetch_related(*self.prefetch_related_fields.keys())
+            queryset = queryset.prefetch_related(*cls.prefetch_related_fields.keys())
         model = await queryset.first()
         if model:
             return model
         else:
             raise NOT_FOUND
 
-    def _delete_value(self):
+    @staticmethod
+    def _delete_value():
         result = False
         if settings.app_settings.DELETE_FIELD_TYPE == "time":
             result = int(time.time() * 1000)
         return result
 
-    async def delete_queryset(self, queryset: QuerySet):
+    @staticmethod
+    async def delete_queryset(queryset: QuerySet):
         """
         考虑到不一定会集成已有的模型，删除根据是否存在字段来判断
         :param queryset:
@@ -103,7 +102,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
         """
         if settings.app_settings.WHETHER_DELETE_FIELD in queryset.fields:
             await queryset.update(**{
-                settings.app_settings.WHETHER_DELETE_FIELD: self._delete_value()
+                settings.app_settings.WHETHER_DELETE_FIELD: BaseView._delete_value()
             })
         else:
             await queryset.delete()
@@ -155,20 +154,21 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
         )
         return schema.model_validate(model_dict)
 
+    @classmethod
     async def check_unique_field(
-            self,
+            cls,
             request_data: Union[BaseModel, Model],  # 创建或修改的参数数据
             model_class: Type[Model],       # 数据库模型
             model: Union[Model, None] = None
     ):
-        check_unique_fields = self._get_unique_fields(model_class) + self._get_foreign_key_fields(model_class)
-        check_unique_together_fields = self._get_unique_together_fields(model_class)
+        check_unique_fields = cls._get_unique_fields(model_class) + cls._get_foreign_key_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):
                     continue
                 if await model_class.filter(**{unique_field: getattr(request_data, unique_field)}).first():
-                    self.fail(msg=f"{self.get_field_description(model_class, unique_field)}已存在相同值：{getattr(request_data, unique_field)}")
+                    return cls.error(msg=f"{cls.get_field_description(model_class, unique_field)}已存在相同值：{getattr(request_data, unique_field)}")
         for unique_together_fields in check_unique_together_fields:
             filter_fields = {}
             is_equal = True
@@ -193,8 +193,8 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             if await model_class.filter(**filter_fields).first():
                 if settings.app_settings.WHETHER_DELETE_FIELD in description_fields:
                     description_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
-                return self.error(
-                    msg=f"{self.get_field_description(model_class, description_fields)}已存在相同值：{[filter_fields.get(field) for field in description_fields]}"
+                return cls.error(
+                    msg=f"{cls.get_field_description(model_class, description_fields)}已存在相同值：{[filter_fields.get(field) for field in description_fields]}"
                 )
 
     # @staticmethod

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/get_all_view.py

@@ -33,6 +33,7 @@ class GetAllView(BaseView, GetMixin):
     filter_schema: Optional[Type[PYDANTIC_SCHEMA]] = None
     filter_fields: Union[None, list] = None
     order_by_fields: Union[None, list] = None
+    auto_add_id_order: bool = True
     """
     get_all_route: 获取详情路由开关，可以放依赖函数列表
     get_all_schema: 返回序列化
@@ -45,6 +46,7 @@ class GetAllView(BaseView, GetMixin):
     filter_fields: 筛选对应字段
         example： name__contains or (create_at__gt, datetime) or (create_at__gt, datetime, create_time)
     order_by_fields: 排序对应字段
+    auto_add_id_order: 是否自动在 order_by_fields 后面追加id排序
     """
 
     async def get_all(self, search: Optional[str], filters: dict, *args, **kwargs) -> Union[BaseModel, dict, None]:
@@ -60,10 +62,11 @@ class GetAllView(BaseView, GetMixin):
         queryset = await self.filter_queryset(queryset, filters, *args, **kwargs)
         queryset = self.filter_controller.query(queryset=queryset, values=filters)
         queryset = queryset.prefetch_related(*self.prefetch_related_fields.keys())
+        if self.auto_add_id_order:
+            self.order_by_fields = self.order_by_fields or []
+            self.order_by_fields.append("id")
         if self.order_by_fields:
-            queryset = queryset.order_by(*self.order_by_fields, "id")
-        else:
-            queryset = queryset.order_by("id")
+            queryset = queryset.order_by(*self.order_by_fields)
 
         return queryset
 
@@ -143,7 +146,7 @@ class GetAllView(BaseView, GetMixin):
                                        key_builder=generate_key_builder))
         async def route(
                 request: Request,
-                paginator=Depends(paginator_deps()),
+                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)),
                 token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
@@ -166,9 +169,15 @@ 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) or self.get_one_schema if hasattr(self, "get_one_schema") else get_one_schema_factory(
-            self.model_class)
+            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)
         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")

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/get_one_view.py

@@ -38,7 +38,7 @@ class GetOneView(BaseView, GetMixin):
     """
 
     async def get_one(self, pk: str, *args, **kwargs):
-        model = await self.get_object(pk, is_with_prefetch=self.is_with_prefetch)
+        model = await self.get_object(pk, self.model_class, is_with_prefetch=self.is_with_prefetch)
         if self.is_with_prefetch:
             await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields, *args, **kwargs)
 
@@ -66,7 +66,16 @@ class GetOneView(BaseView, GetMixin):
     def _handler_get_one_settings(self):
         if not self.get_one_route:
             return
-        self.get_one_schema = self.schema or self.get_one_schema or get_one_schema_factory(model_class=self.model_class)
+        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")
         doc = self.get_one.__doc__
         summary = doc.strip().split("\n")[0] if self.get_one.__doc__ else "Get One"

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/get_relation_view.py

@@ -189,7 +189,7 @@ class GetRelationView(BaseView):
         self.get_relation_response_schema = 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.strip('_id')}-by-{self.path_id_name.strip('_id')}/{'{pk}'}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""
+        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(),

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/mixin/base_mixin.py

@@ -52,7 +52,8 @@ class BaseMixin(Generic[T], APIRouter, ABC):
         #     if hasattr(self, "_handler_sql_get_all_settings"):
         #         getattr(self, "_handler_sql_get_all_settings")()
 
-    def get_base_filter(self, fields: list, schema: Optional[PYDANTIC_SCHEMA] = None) -> list:
+    @staticmethod
+    def get_base_filter(fields: list, schema: Optional[PYDANTIC_SCHEMA] = None) -> list:
         bast_filter_list = []
         if fields:
             bast_filter_list += [BaseFilter(field) if not isinstance(field, BaseFilter) else field for field in fields]

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/mixin/dbmodel_mixin.py

@@ -29,7 +29,7 @@ class DBModelMixin:
         if type(fields) == str:
             try:
                 field_info = model_class._meta.fields_map.get(fields)
-                field_info_fk = model_class._meta.fields_map.get(fields.rstrip("_id"))
+                field_info_fk = model_class._meta.fields_map.get(fields.removesuffix("_id"))
                 if field_info:
                     return field_info.description or ""
                 elif fields.endswith("_id") and field_info_fk:

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/update_relation_view.py

@@ -75,7 +75,7 @@ class UpdateRelationView(BaseView, SaveMixin):
         self.update_relation_response_schema = response_factory(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.strip('_id')}-by-{self.path_id_name.strip('_id')}/{'{pk}'}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else "/{pk}"
+        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(),

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/api_view/update_view.py

@@ -29,7 +29,7 @@ class UpdateView(BaseView, SaveMixin):
 
     @atomic()
     async def update(self, pk: str, request_data, *args, **kwargs):
-        model = await self.get_object(pk)
+        model = await self.get_object(pk, self.model_class)
 
         request_data = await self.set_update_fields(request_data=request_data, *args, **kwargs)
 

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/controller/filter_controller.py

@@ -69,17 +69,14 @@ class BaseFilter:
             for f in filter_str[1:]:
                 if type(f) == type:
                     field_type = f
-                    continue
-                if type(f) == str:
+                elif type(f) == str:
                     filter_field = f
-                    continue
-                if callable(f):
+                elif callable(f):
                     filter_func = f
         if not filter_field:
-            if settings.app_settings.FILTER_UNDERLINE_WHETHER_DOUBLE_TO_SINGLE:
-                filter_field = model_field.replace("__", "_")
-            else:
-                filter_field = model_field
+            filter_field = model_field
+        if settings.app_settings.FILTER_UNDERLINE_WHETHER_DOUBLE_TO_SINGLE:
+            filter_field = filter_field.replace("__", "_")
 
         self.field_type = field_type
         self.model_field = model_field

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/controller/rpc_controller.py

@@ -37,7 +37,7 @@ class RPCController(ResponseMixin):
                     for response_param_value in request_param_value_list:
                         if type(response_param_value) == str:
                             response_field_name = response_param_value
-                            response_field_alias_name = model_field.rstrip("_id") + "_" + response_param_value
+                            response_field_alias_name = model_field.removesuffix("_id") + "_" + response_param_value
                         elif type(response_param_value) == tuple and len(response_param_value) > 1:
                             response_field_name = response_param_value[0]
                             response_field_alias_name = response_param_value[1]

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/deps/paginator_deps.py

@@ -5,6 +5,7 @@ from pydantic import create_model
 from pydantic.fields import FieldInfo
 
 from fastgenerateapi.pydantic_utils.base_model import BaseModel, model_config
+from fastgenerateapi.schemas_factory.common_function import get_validate_dict
 from fastgenerateapi.settings.all_settings import settings
 from fastgenerateapi.utils.str_util import parse_str_to_int, parse_str_to_bool
 
@@ -42,7 +43,12 @@ def paginator_deps():
             FieldInfo(default=Query(settings.app_settings.DEFAULT_WHETHER_PAGE), title="是否分页", description="是否分页")
         ),
     }
-    pagination_model: Type[BaseModel] = create_model("paginator", **fields, __config__=model_config)
+    pagination_model: Type[BaseModel] = create_model(
+        "paginator",
+        **fields,
+        __config__=model_config,
+        __validators__=get_validate_dict(),
+    )
 
     def pagination_deps(paginator: pagination_model = Depends(pagination_model)) -> pagination_model:
         current_page_value = parse_str_to_int(getattr(paginator, settings.app_settings.CURRENT_PAGE_FIELD))

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/deps/tree_params_deps.py

@@ -5,6 +5,7 @@ from pydantic.fields import FieldInfo
 
 from fastgenerateapi.pydantic_utils.base_model import model_config
 from fastgenerateapi.pydantic_utils.base_model import ModelConfig
+from fastgenerateapi.schemas_factory.common_function import get_validate_dict
 from fastgenerateapi.settings.all_settings import settings
 
 from pydantic import BaseModel, create_model
@@ -26,7 +27,12 @@ def tree_params_deps():
         )
     }
 
-    filter_tree_params_model: Type[BaseModel] = create_model("TreeFilterParams", __config__=model_config, **model_fields)
+    filter_tree_params_model: Type[BaseModel] = create_model(
+        "TreeFilterParams",
+        **model_fields,
+        __config__=model_config,
+        __validators__=get_validate_dict(),
+    )
 
     def filter_query(filter_params: filter_tree_params_model = Depends(filter_tree_params_model)) -> Optional[str]:
         """

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/fastapi_utils/param_utils.py

@@ -6,6 +6,7 @@ import fastapi
 from fastapi import params
 from fastapi.dependencies.models import Dependant
 from fastapi.dependencies.utils import get_sub_dependant
+from pydantic.alias_generators import to_snake, to_camel
 
 
 def get_param_sub_dependant(
@@ -25,6 +26,14 @@ def get_param_sub_dependant(
     )
     for query_param in dependant.query_params:
         query_param_field = depends.dependency.model_fields.get(query_param.name)
+        if not query_param_field:
+            snake_name = to_snake(query_param.name)
+            if query_param.name != snake_name:
+                query_param_field = depends.dependency.model_fields.get(snake_name)
+        if not query_param_field:
+            camel_name = to_camel(query_param.name)
+            if query_param.name != camel_name:
+                query_param_field = depends.dependency.model_fields.get(camel_name)
         if query_param_field:
             query_param.field_info.description = query_param_field.description or query_param_field.title or ""
     return dependant

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/pydantic_utils/base_model.py

@@ -1,7 +1,7 @@
 import importlib
-from typing import List, Optional
+from typing import List, Optional, Any
 
-from pydantic import BaseModel as PydanticBaseModel, BaseConfig, Field, ConfigDict
+from pydantic import BaseModel as PydanticBaseModel, BaseConfig, Field, ConfigDict, field_validator
 
 from fastgenerateapi.pydantic_utils.json_encoders import JSON_ENCODERS
 from fastgenerateapi.settings.all_settings import settings
@@ -54,6 +54,13 @@ model_config = ConfigDict(
 class BaseModel(PydanticBaseModel):
     model_config = model_config
 
+    @field_validator('*', mode='before')  # '*' 表示匹配所有字段
+    def empty_str_to_none(cls, v: Any) -> Any:
+        """将空字符串转换为None，其他值保持不变"""
+        if isinstance(v, str) and v.strip() == "":  # 处理纯空字符串或仅含空格的字符串
+            return None
+        return v
+
 
 class IdList(BaseModel):
     id_list: List[str] = Field([], description="id数组")

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/schemas_factory/common_function.py

@@ -1,6 +1,6 @@
 from typing import Type, Optional, Union
 
-from pydantic import validator
+from pydantic import validator, field_validator
 from pydantic.fields import FieldInfo
 from tortoise import Model
 
@@ -11,18 +11,20 @@ from fastgenerateapi.settings.all_settings import settings
 def get_field_info(value, description="", default_field_type=None) -> (Type, FieldInfo):
     if value.pk:
         return str, FieldInfo()
+
+    required = False
     if value.field_type is None:
         if default_field_type:
-            field_type = Optional[default_field_type]
+            value.field_type = default_field_type
         else:
-            field_type = Optional[str]
+            value.field_type = str
+    if hasattr(value, "null") and value.null:
+        field_type = Optional[value.field_type]
     else:
-        if hasattr(value, "null") and value.null:
-            field_type = Optional[value.field_type]
-        else:
-            field_type = value.field_type
-    field_info_dict = {}
-    if hasattr(value, "default") and not hasattr(value.default, '__call__'):
+        field_type = value.field_type
+        required = True
+    field_info_dict = {"required": required}
+    if not required and hasattr(value, "default") and not hasattr(value.default, '__call__'):
         field_info_dict.setdefault("default", value.default)
     if hasattr(value, "description"):
         field_info_dict.setdefault("description", description + (value.description or ""))
@@ -111,13 +113,25 @@ def get_dict_from_pydanticmeta(model_class: Type[Model], data: Union[list, tuple
     return fields_info
 
 
+def get_validate_dict() -> dict:
+
+    def empty_str_to_none(v, values):
+        if isinstance(v, str) and v.strip() == "":
+            return None
+        return v
+
+    validator_dict = {
+        "empty_str_to_none": field_validator('*', mode='before')(empty_str_to_none)
+    }
+
+    return validator_dict
+
+
 def get_validate_dict_from_fields(fields_info: dict) -> dict:
     validator_dict = {}
 
     def remove_blank_strings(v, values):
-        if isinstance(v, str):
-            v = v.strip()
-        if v == "":
+        if isinstance(v, str) and v.strip() == "":
             return None
         return v
 
@@ -129,3 +143,5 @@ def get_validate_dict_from_fields(fields_info: dict) -> dict:
     return validator_dict
 
 
+
+

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/schemas_factory/filter_schema_factory.py

@@ -1,4 +1,4 @@
-from typing import Type, Union
+from typing import Type, Union, Optional
 
 from fastapi import Query
 from pydantic import BaseModel, create_model
@@ -9,6 +9,8 @@ from fastgenerateapi.api_view.mixin.dbmodel_mixin import DBModelMixin
 from fastgenerateapi.controller.filter_controller import BaseFilter
 from tortoise import Model
 
+from fastgenerateapi.schemas_factory.common_function import get_validate_dict
+
 
 def filter_schema_factory(model_class: Type[Model], fields: list[str, tuple[str, Type], BaseFilter] = None):
     """
@@ -24,7 +26,7 @@ def filter_schema_factory(model_class: Type[Model], fields: list[str, tuple[str,
         description = DBModelMixin.get_field_description(model_class, field_info.model_field)
         model_fields.update({
             f: (
-                Union[t, str],
+                Optional[t],
                 FieldInfo(
                     title=f"{description}",
                     default=Query("", description=description),
@@ -35,7 +37,8 @@ def filter_schema_factory(model_class: Type[Model], fields: list[str, tuple[str,
     filter_params_model: Type[BaseModel] = create_model(
         model_class.__name__+"CommonFilterParams",
         **model_fields,
-        __config__=model_config
+        __config__=model_config,
+        __validators__=get_validate_dict(),
     )
 
     return filter_params_model

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi/settings/app_settings.py

@@ -7,7 +7,7 @@ from fastgenerateapi.pydantic_utils.base_settings import BaseSettings
 
 
 class AppSettings(BaseSettings):
-    # 字段配置 老版本(pydantic.utils.to_lower_camel)
+    # 字段配置 驼峰格式：新版本(pydantic.alias_generators:to_camel)、老版本(pydantic.utils.to_lower_camel)
     ALIAS_GENERATOR: Optional[str] = Field(default="pydantic.alias_generators.to_snake", description="序列化参数命名方法路径")
 
     # 分页对应字段以及配置默认值

{fastgenerateapi-1.1.13 → fastgenerateapi-1.1.16}/fastgenerateapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastgenerateapi
-Version: 1.1.13
+Version: 1.1.16
 Summary: FastAPIView Class View
 Author: ShiLiang
 Author-email: 2509144896@qq.com
@@ -24,15 +24,17 @@ License-File: LICENSE
 [Github](https://github.com/ShiLiangAPI)
 
 #### 版本说明
-最新版本：v1.1.7+
+[pydantic-v2]
+稳定版本：v1.1.15+
 建议python版本：3.9+
 推荐fastapi版本：0.103.2+
 推荐pydantic版本：2.11.5+
 
+[pydantic-v1]
 稳定版本：v0.0.21
 建议python版本：3.9+
 推荐fastapi版本：0.97.0
-
+推荐pydantic版本：1.10.9+
 
 
 ###### FastGenerateApi 使用说明