fastgenerateapi 1.2.9__tar.gz → 1.2.11__tar.gz

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/PKG-INFO

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

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/__version__.py

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

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/api_view/base_view.py

@@ -26,7 +26,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
     model_class: Optional[Type[Model]] = None  # 数据库模型
     prefetch_related_fields: Union[None, dict] = None
     is_with_prefetch: Optional[bool] = False
-    schema: Optional[Type[BaseModel]] = None  # 返回序列化[未使用]
+    response_schema: Optional[Type[BaseModel]] = None  # 通用返回序列化
     dependencies: Optional[Sequence[params.Depends]] = None
     tags: Optional[List[str]] = None  # swagger标签
     check_ignore_error_fields: Optional[List[str]] = None # 检查唯一字段报错时，不展示这个字段
@@ -214,10 +214,14 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             result[key] = val[0]
         return result
 
-    def gen_get_one_response_schema(self):
-        if not hasattr(self, "get_one_schema") or not self.get_one_schema:
+    def get_response_schema(self):
+        """
+        如果response_schema不存在，则生成
+        :return:
+        """
+        if not self.response_schema:
             get_one_schema_include = []
-            if hasattr(self, "is_with_prefetch") and self.is_with_prefetch and self.prefetch_related_fields:
+            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:
@@ -225,19 +229,19 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
                             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)
+            self.response_schema = get_one_schema_factory(self.model_class, extra_include=get_one_schema_include)
 
-        return self.get_one_schema
+        return self.response_schema
 
-    def gen_get_one_response_schema_factory(self):
+    def get_response_schema_factory(self):
         """
-        如果get_one_response_schema不存在，则生成
+        如果response_schema不存在，则生成
         :return:
         """
-        self.gen_get_one_response_schema()
-        self.get_one_response_schema_factory = response_factory(self.get_one_schema, name="GetOne")
+        self.get_response_schema()
+        self.response_schema_factory = response_factory(self.response_schema, name="Common")
 
-        return self.get_one_response_schema_factory
+        return self.response_schema_factory
 
 
 

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/api_view/create_view.py

@@ -114,8 +114,8 @@ class CreateView(BaseView, SaveMixin):
         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()
-            self.create_response_schema = self.get_one_schema
+            self.create_response_schema_factory = self.get_response_schema_factory()
+            self.create_response_schema = self.response_schema
         if not self.create_summary:
             doc = self.create.__doc__
             self.create_summary = doc.strip().split("\n")[0] if doc else f"Create"

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/api_view/get_all_view.py

@@ -152,9 +152,10 @@ 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)),
+                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:
@@ -193,8 +194,10 @@ class GetAllView(BaseView, GetMixin):
                             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()
+            if hasattr_get_all_schema(self.model_class) or get_all_schema_include:
+                self.get_all_schema = get_all_schema_factory(self.model_class, extra_include=get_all_schema_include)
+            else:
+                self.get_all_schema = self.get_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_factory = response_factory(self.get_page_schema, name="GetPage")

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/api_view/get_one_view.py

@@ -75,7 +75,8 @@ class GetOneView(BaseView, GetMixin):
         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_schema = self.get_response_schema()
+
         self.get_one_response_schema_factory = response_factory(self.get_one_schema, name="GetOne")
         if not self.get_one_summary:
             doc = self.get_one.__doc__

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/api_view/switch_view.py

@@ -66,7 +66,7 @@ class SwitchView(BaseView):
                 path="/%s/{pk}" % ("switch_"+switch_route_field),
                 endpoint=self._switch_decorator(switch_route_field),
                 methods=["PUT"],
-                response_model=self.gen_get_one_response_schema_factory(),
+                response_model=self.get_response_schema_factory(),
                 summary=summary,
                 dependencies=True,
                 error_responses=[NOT_FOUND],

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/api_view/update_view.py

@@ -107,8 +107,8 @@ class UpdateView(BaseView, SaveMixin):
         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()
-            self.update_response_schema = self.get_one_schema
+            self.update_response_schema_factory = self.get_response_schema_factory()
+            self.update_response_schema = self.response_schema
         if not self.update_summary:
             doc = self.update.__doc__
             self.update_summary = doc.strip().split("\n")[0] if doc else f"Update"

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/schemas_factory/common_function.py

@@ -1,3 +1,5 @@
+import time
+from datetime import datetime
 from typing import Type, Optional, Union, List
 
 from pydantic import field_validator, model_validator
@@ -42,6 +44,18 @@ def get_field_info(value, description="", default_field_type=None) -> (Type, Fie
         if constraints:
             for key, val in constraints.items():
                 field_info_dict.setdefault(key, val)
+    if settings.app_settings.SWAGGER_OPEN_DEFAULT_EXAMPLES:
+        examples = []
+        if value.field_type == str:
+            examples.append(value.description)
+        elif value.field_type == int:
+            if hasattr(value, "start_num"):
+                examples.append(value.start_num)
+            else:
+                examples.append(0)
+        elif value.field_type == datetime:
+            examples.append(int(time.time() * 1000))
+        field_info_dict.setdefault("examples", examples)
     return field_type, FieldInfo(**field_info_dict)
 
 
@@ -63,11 +77,16 @@ def get_field_info_from_model_class(model_class: Type[Model], field: str, descri
             return Optional[str], FieldInfo(default=None, description=f"{field}")
         return get_field_info(value, description=description)
 
-    field_info = model_class._meta.fields_map.get(field.split("__", maxsplit=1)[0])
+    split_left_field = field.split("__", maxsplit=1)[0]
+    field_info = model_class._meta.fields_map.get(split_left_field)
     if field_info:
         description += field_info.description or ""
+    elif split_left_field.endswith("_id"):
+        field_info = model_class._meta.fields_map.get(split_left_field.removesuffix("_id"))
+        if field_info:
+            description += field_info.description or ""
 
-    model_class = DBModelMixin._get_foreign_key_relation_class(model_class, field.split("__", maxsplit=1)[0])
+    model_class = DBModelMixin._get_foreign_key_relation_class(model_class, split_left_field)
 
     return get_field_info_from_model_class(model_class, field.split("__", maxsplit=1)[1], description)
 
@@ -89,7 +108,7 @@ def get_dict_from_pydanticmeta(model_class: Type[Model], data: Union[list, tuple
             if len(field) == 2:
                 if isinstance(field[1], str):
                     key_field = field[1]
-                if isinstance(field[2], FieldInfo):
+                elif isinstance(field[1], FieldInfo):
                     field_info = field[1]
                 else:
                     field_type = field[1]

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/schemas_factory/common_schema_factory.py

@@ -17,6 +17,8 @@ def common_schema_factory(
         extra_include: Union[list, tuple, set] = None,
         exclude: Union[list, tuple, set] = None,
         exclude_readonly: Optional[bool] = False,
+        pydantic_meta_include: Union[list, tuple, set] = None,
+        pydantic_meta_exclude: Optional[bool] = True,
 ) -> Type[T]:
     """
     Is used to create a CommonSchema
@@ -27,25 +29,31 @@ def common_schema_factory(
     exclude_fields = set()
     if exclude_readonly:
         exclude_fields.update(["id", "created_at", "modified_at", "updated_at"])
-    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)
-    else:
-        include_fields.update(all_fields_info.keys())
-
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
+    else:
+        if hasattr(model_class, "PydanticMeta"):
+            if pydantic_meta_include:
+                include_fields_dict = get_dict_from_pydanticmeta(model_class, pydantic_meta_include)
+                all_fields_info = {**include_fields_dict, **all_fields_info}
+                include_fields.update(include_fields_dict.keys())
+            else:
+                if hasattr(model_class.PydanticMeta, "include"):
+                    include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.include)
+                    all_fields_info = {**include_fields_dict, **all_fields_info}
+                    include_fields.update(include_fields_dict.keys())
+                else:
+                    include_fields.update(all_fields_info.keys())
+            if pydantic_meta_exclude and hasattr(model_class.PydanticMeta, "exclude"):
+                exclude_fields.update(model_class.PydanticMeta.exclude)
+        else:
+            include_fields.update(all_fields_info.keys())
+
     if extra_include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
     if exclude:
         exclude_fields.update(exclude)

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/schemas_factory/get_all_schema_factory.py

@@ -91,7 +91,7 @@ def get_all_schema_factory(
     text_to_list_fields = set()
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
     else:
         if hasattr(model_class, "PydanticMeta"):
@@ -131,29 +131,29 @@ def get_all_schema_factory(
         else:
             include_fields.update(all_fields_info.keys())
 
-    if extra_include:
-        include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-        all_fields_info.update(include_fields_dict)
-        include_fields.update(include_fields_dict.keys())
-    if exclude:
-        exclude_fields.update(exclude)
-
-    all_fields = include_fields.difference(exclude_fields)
-    if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
-        try:
-            all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
-        except Exception:
-            ...
-
-    schema_name = name if name else model_class.__name__ + "GetAllSchema"
-    text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
-    schema: Type[T] = create_model(
-        schema_name,
-        **{field: all_fields_info[field] for field in all_fields},
-        __config__=model_config,
-        __validators__={**text_to_list_validators_dict},
-    )
-    return schema
+        if extra_include:
+            include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
+            all_fields_info.update(include_fields_dict)
+            include_fields.update(include_fields_dict.keys())
+        if exclude:
+            exclude_fields.update(exclude)
+
+        all_fields = include_fields.difference(exclude_fields)
+        if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
+            try:
+                all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
+            except Exception:
+                ...
+
+        schema_name = name if name else model_class.__name__ + "GetAllSchema"
+        text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
+        schema: Type[T] = create_model(
+            schema_name,
+            **{field: all_fields_info[field] for field in all_fields},
+            __config__=model_config,
+            __validators__={**text_to_list_validators_dict},
+        )
+        return schema
 
 
 def get_list_schema_factory(schema_cls: Type[T] = None, response_field: Optional[str] = None, name: str = "") -> Type[T]:

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/schemas_factory/get_one_schema_factory.py

@@ -4,7 +4,6 @@ from pydantic_core import PydanticUndefined
 
 from fastgenerateapi.settings.all_settings import settings
 
-# from fastgenerateapi.pydantic_utils.base_model import Config
 from pydantic import create_model
 from tortoise import Model
 
@@ -13,6 +12,13 @@ from fastgenerateapi.pydantic_utils.base_model import model_config
 from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_fields, get_dict_from_pydanticmeta, \
     get_model_validate_text_to_list
 
+def hasattr_get_one_schema(model_class: Type[Model],):
+    if not hasattr(model_class, "PydanticMeta"):
+        return False
+    if hasattr(model_class.PydanticMeta, "get_one_include") or hasattr(model_class.PydanticMeta, "get_one_exclude"):
+        return True
+    return False
+
 
 def get_one_schema_factory(
         model_class: Type[Model],
@@ -83,7 +89,7 @@ def get_one_schema_factory(
     text_to_list_fields = set()
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
     else:
         if hasattr(model_class, "PydanticMeta"):
@@ -123,30 +129,30 @@ def get_one_schema_factory(
         else:
             include_fields.update(all_fields_info.keys())
 
-    if extra_include:
-        include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-        all_fields_info.update(include_fields_dict)
-        include_fields.update(include_fields_dict.keys())
-    if exclude:
-        exclude_fields.update(exclude)
-
-    all_fields = include_fields.difference(exclude_fields)
-
-    if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
-        try:
-            all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
-        except Exception:
-            ...
-
-    schema_name = name if name else model_class.__name__ + "GetOneSchema"
-    text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
-    schema: Type[T] = create_model(
-        schema_name,
-        **{field: all_fields_info[field] for field in all_fields},
-        __config__=model_config,
-        __validators__={**text_to_list_validators_dict},
-    )
-    return schema
+        if extra_include:
+            include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
+            all_fields_info.update(include_fields_dict)
+            include_fields.update(include_fields_dict.keys())
+        if exclude:
+            exclude_fields.update(exclude)
+
+        all_fields = include_fields.difference(exclude_fields)
+
+        if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
+            try:
+                all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
+            except Exception:
+                ...
+
+        schema_name = name if name else model_class.__name__ + "GetOneSchema"
+        text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
+        schema: Type[T] = create_model(
+            schema_name,
+            **{field: all_fields_info[field] for field in all_fields},
+            __config__=model_config,
+            __validators__={**text_to_list_validators_dict},
+        )
+        return schema
 
 
 

fastgenerateapi-1.2.11/fastgenerateapi/schemas_factory/get_relation_schema_factory.py

@@ -0,0 +1,102 @@
+from typing import Type, Optional, Union, List
+
+from tortoise import Model
+from pydantic import create_model
+
+from fastgenerateapi.data_type.data_type import T
+from fastgenerateapi.pydantic_utils.base_model import model_config
+from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_fields, get_dict_from_pydanticmeta, \
+    get_model_validate_text_to_list
+from fastgenerateapi.settings.all_settings import settings
+
+
+def get_relation_schema_factory(
+        model_class: Type[Model],
+        include: Union[list, tuple, set] = None,
+        extra_include: Union[list, tuple, set] = None,
+        exclude: Union[list, tuple, set] = None,
+        pydantic_meta_include: Union[list, tuple, set] = None,
+        pydantic_meta_exclude: Optional[bool] = True,
+        pydantic_meta_get_relation_include: Optional[bool] = True,
+        pydantic_meta_get_relation_exclude: Optional[bool] = True,
+        pydantic_meta_text_to_list: Optional[bool] = True,
+        name: Optional[str] = None
+) -> Optional[Type[T]]:
+    """
+    Is used to create a GetRelationSchema
+    """
+    all_fields_info: dict = get_dict_from_model_fields(model_class)
+
+    include_fields = set()
+    exclude_fields = set()
+    text_to_list_fields = set()
+    if include:
+        include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
+        all_fields_info.update(include_fields_dict)
+        include_fields.update(include_fields_dict.keys())
+    else:
+        if hasattr(model_class, "PydanticMeta"):
+            if pydantic_meta_include:
+                include_fields_dict = get_dict_from_pydanticmeta(model_class, pydantic_meta_include)
+                all_fields_info.update(include_fields_dict)
+                include_fields.update(include_fields_dict.keys())
+            else:
+                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 pydantic_meta_exclude and hasattr(model_class.PydanticMeta, "exclude"):
+                exclude_fields.update(model_class.PydanticMeta.exclude)
+
+            if pydantic_meta_get_relation_include and hasattr(model_class.PydanticMeta, "get_relation_include"):
+                get_tree_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_tree_include)
+                all_fields_info.update(get_tree_include_fields_dict)
+                include_fields.update(get_tree_include_fields_dict.keys())
+            if pydantic_meta_get_relation_exclude and hasattr(model_class.PydanticMeta, "get_relation_exclude"):
+                exclude_fields.update(model_class.PydanticMeta.get_tree_exclude)
+            if pydantic_meta_text_to_list and hasattr(model_class.PydanticMeta, "text_to_list"):
+                text_to_list_fields = getattr(model_class.PydanticMeta, "text_to_list")
+                for field in text_to_list_fields:
+                    field_info = all_fields_info.get(field)[1]
+                    field_type = List[str] if field_info.is_required() else Optional[List[str]]
+                    all_fields_info.update({field: (field_type, field_info)})
+        else:
+            include_fields.update(all_fields_info.keys())
+
+        if extra_include:
+            include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
+            all_fields_info.update(include_fields_dict)
+            include_fields.update(include_fields_dict.keys())
+        if exclude:
+            exclude_fields.update(exclude)
+
+        all_fields = include_fields.difference(exclude_fields)
+
+        if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
+            try:
+                all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
+            except Exception:
+                ...
+
+        schema_name = name if name else model_class.__name__ + "GetRelationSchema"
+        text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
+        schema: Type[T] = create_model(
+            schema_name,
+            **{field: all_fields_info[field] for field in all_fields},
+            __config__=model_config,
+            __validators__={**text_to_list_validators_dict},
+        )
+
+        return schema
+
+
+
+
+
+
+
+
+
+

fastgenerateapi-1.2.11/fastgenerateapi/schemas_factory/get_tree_schema_factory.py

@@ -0,0 +1,111 @@
+from typing import Type, Optional, Union, List
+
+from pydantic.fields import FieldInfo
+from tortoise import Model
+from pydantic import create_model
+
+from fastgenerateapi.data_type.data_type import T
+from fastgenerateapi.pydantic_utils.base_model import model_config
+from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_fields, get_dict_from_pydanticmeta, \
+    get_model_validate_text_to_list
+from fastgenerateapi.settings.all_settings import settings
+
+
+def get_tree_schema_factory(
+        model_class: Type[Model],
+        include: Union[list, tuple, set] = None,
+        extra_include: Union[list, tuple, set] = None,
+        exclude: Union[list, tuple, set] = None,
+        pydantic_meta_include: Union[list, tuple, set] = None,
+        pydantic_meta_exclude: Optional[bool] = True,
+        pydantic_meta_get_include: Optional[bool] = True,
+        pydantic_meta_get_exclude: Optional[bool] = True,
+        pydantic_meta_get_tree_include: Optional[bool] = True,
+        pydantic_meta_get_tree_exclude: Optional[bool] = True,
+        pydantic_meta_text_to_list: Optional[bool] = True,
+        name: Optional[str] = None
+) -> Optional[Type[T]]:
+    """
+    Is used to create a GetTreeSchema
+    """
+    all_fields_info: dict = get_dict_from_model_fields(model_class)
+
+    include_fields = set()
+    exclude_fields = set()
+    text_to_list_fields = set()
+    if include:
+        include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
+        all_fields_info.update(include_fields_dict)
+        include_fields.update(include_fields_dict.keys())
+    else:
+        if hasattr(model_class, "PydanticMeta"):
+            if pydantic_meta_include:
+                include_fields_dict = get_dict_from_pydanticmeta(model_class, pydantic_meta_include)
+                all_fields_info.update(include_fields_dict)
+                include_fields.update(include_fields_dict.keys())
+            else:
+                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 pydantic_meta_exclude and hasattr(model_class.PydanticMeta, "exclude"):
+                exclude_fields.update(model_class.PydanticMeta.exclude)
+
+            if pydantic_meta_get_include and 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 pydantic_meta_get_exclude and hasattr(model_class.PydanticMeta, "get_exclude"):
+                exclude_fields.update(model_class.PydanticMeta.get_exclude)
+
+            if pydantic_meta_get_tree_include and hasattr(model_class.PydanticMeta, "get_tree_include"):
+                get_tree_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_tree_include)
+                all_fields_info.update(get_tree_include_fields_dict)
+                include_fields.update(get_tree_include_fields_dict.keys())
+            if pydantic_meta_get_tree_exclude and hasattr(model_class.PydanticMeta, "get_tree_exclude"):
+                exclude_fields.update(model_class.PydanticMeta.get_tree_exclude)
+            if pydantic_meta_text_to_list and hasattr(model_class.PydanticMeta, "text_to_list"):
+                text_to_list_fields = getattr(model_class.PydanticMeta, "text_to_list")
+                for field in text_to_list_fields:
+                    field_info = all_fields_info.get(field)[1]
+                    field_type = List[str] if field_info.is_required() else Optional[List[str]]
+                    all_fields_info.update({field: (field_type, field_info)})
+        else:
+            include_fields.update(all_fields_info.keys())
+
+    if extra_include:
+        include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
+        all_fields_info.update(include_fields_dict)
+        include_fields.update(include_fields_dict.keys())
+    if exclude:
+        exclude_fields.update(exclude)
+
+    all_fields = include_fields.difference(exclude_fields)
+    all_fields.add(settings.app_settings.DEFAULT_TREE_CHILDREN_FIELD)
+    if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
+        try:
+            all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
+        except Exception:
+            ...
+    schema_name = name if name else model_class.__name__ + "GetTreeSchema"
+
+    all_fields_info.setdefault(
+        settings.app_settings.DEFAULT_TREE_CHILDREN_FIELD,
+        (Optional[List[schema_name]], FieldInfo(default=[], description="子级目录"))
+    )
+
+    text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
+    schema: Type[T] = create_model(
+        schema_name,
+        **{field: all_fields_info[field] for field in all_fields},
+        __config__=model_config,
+        __validators__={**text_to_list_validators_dict},
+    )
+
+    return schema
+
+
+
+

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi/settings/app_settings.py

@@ -89,6 +89,9 @@ class AppSettings(BaseSettings):
     CACHE_TREE_WHETHER_OPEN: Optional[bool] = Field(default=False, description="树状查询是否打开缓存")
     CACHE_TREE_SECONDS: int = Field(default=3600, description="树状查询缓存时间，单位秒")
 
+    # #######################################  Swagger文档相关  ###############################################
+    SWAGGER_OPEN_DEFAULT_EXAMPLES: Optional[bool] = Field(default=False, description="是否添加默认值")
+
     model_config = SettingsConfigDict(
         env_prefix="APP_",
         env_file=".env",

{fastgenerateapi-1.2.9 → fastgenerateapi-1.2.11}/fastgenerateapi.egg-info/PKG-INFO

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