fastgenerateapi 1.2.8__tar.gz → 1.2.10__tar.gz

{fastgenerateapi-1.2.8 → fastgenerateapi-1.2.10}/PKG-INFO

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

{fastgenerateapi-1.2.8 → fastgenerateapi-1.2.10}/fastgenerateapi/__version__.py

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

{fastgenerateapi-1.2.8 → fastgenerateapi-1.2.10}/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,30 +214,25 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             result[key] = val[0]
         return result
 
-    def gen_get_one_response_schema(self):
-        if not hasattr(self, "get_one_schema") or not self.get_one_schema:
-            get_one_schema_include = []
-            if hasattr(self, "is_with_prefetch") and self.is_with_prefetch and self.prefetch_related_fields:
-                for key, value in self.prefetch_related_fields.items():
-                    if value and type(value) in [list, tuple, set]:
-                        for val in value:
-                            val_str = val
-                            if type(val) in [list, tuple, set]:
-                                val_str = val[0]
-                            get_one_schema_include.append(key + "__" + val_str)
-            self.get_one_schema = get_one_schema_factory(model_class=self.model_class, include=get_one_schema_include)
-
-        return self.get_one_schema
-
-    def gen_get_one_response_schema_factory(self):
+    def get_response_schema(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")
+        if not self.response_schema:
+            self.response_schema = get_one_schema_factory(model_class=self.model_class)
 
-        return self.get_one_response_schema_factory
+        return self.response_schema
+
+    def get_response_schema_factory(self):
+        """
+        如果response_schema不存在，则生成
+        :return:
+        """
+        self.get_response_schema()
+        self.response_schema_factory = response_factory(self.response_schema, name="Common")
+
+        return self.response_schema_factory
 
 
 

{fastgenerateapi-1.2.8 → fastgenerateapi-1.2.10}/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.8 → fastgenerateapi-1.2.10}/fastgenerateapi/api_view/get_all_view.py

@@ -193,8 +193,7 @@ 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()
+            self.get_all_schema = get_all_schema_factory(self.model_class, extra_include=get_all_schema_include)
         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.8 → fastgenerateapi-1.2.10}/fastgenerateapi/api_view/get_one_view.py

@@ -75,7 +75,19 @@ 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()
+            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 = get_one_schema_factory(
+                model_class=self.model_class,
+                extra_include=get_one_schema_include
+            )
         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.8 → fastgenerateapi-1.2.10}/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.8 → fastgenerateapi-1.2.10}/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.8 → fastgenerateapi-1.2.10}/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)
 
 
@@ -155,13 +169,27 @@ def get_model_validate_text_to_list(fields: Optional[List[str]]) -> dict:
     if not fields:
         return {}
     def func(cls, data):
-        for field in fields:
-            if hasattr(data, field):
-                if getattr(data, field):
-                    field_value = getattr(data, field).split(settings.app_settings.TEXT_TO_LIST_SPLIT_VALUE)
+        if isinstance(data, dict):
+            for field in fields:
+                value_str = data.get(field, None)
+                if isinstance(value_str, (list, tuple, set)):
+                    field_value = list(value_str)
+                elif isinstance(value_str, str):
+                    field_value = value_str.split(settings.app_settings.TEXT_TO_LIST_SPLIT_VALUE)
                 else:
-                    field_value = []
-                setattr(data, field, field_value)
+                    field_value = value_str
+                data[field] = field_value
+        else:
+            for field in fields:
+                if hasattr(data, field):
+                    value_str = getattr(data, field)
+                    if isinstance(value_str, (list, tuple, set)):
+                        field_value = list(value_str)
+                    elif isinstance(value_str, str):
+                        field_value = getattr(data, field).split(settings.app_settings.TEXT_TO_LIST_SPLIT_VALUE)
+                    else:
+                        field_value = []
+                    setattr(data, field, field_value)
         return data
 
     return {
@@ -178,12 +206,31 @@ def get_model_validate_list_to_text(fields: Optional[List[str]]) -> dict:
     if not fields:
         return {}
     def func(cls, data: dict):
-        for field in fields:
-            if alias_generator:
-                field = alias_generator(field)
-            value_list = data.get(field, None)
-            if value_list and type(value_list) == list:
-                data[field] = settings.app_settings.TEXT_TO_LIST_SPLIT_VALUE.join(value_list)
+        if isinstance(data, dict):
+            for field in fields:
+                if alias_generator:
+                    field = alias_generator(field)
+                value_list = data.get(field, None)
+                if isinstance(value_list, (list, tuple, set)):
+                    field_value = settings.app_settings.TEXT_TO_LIST_SPLIT_VALUE.join(list(value_list))
+                elif isinstance(value_list, str):
+                    field_value = value_list
+                else:
+                    field_value = None
+                data[field] = field_value
+        else:
+            for field in fields:
+                if alias_generator:
+                    field = alias_generator(field)
+                if hasattr(data, field):
+                    value_list = getattr(data, field)
+                    if isinstance(value_list, (list, tuple, set)):
+                        field_value = settings.app_settings.TEXT_TO_LIST_SPLIT_VALUE.join(list(value_list))
+                    elif isinstance(value_list, str):
+                        field_value = value_list
+                    else:
+                        field_value = None
+                    setattr(data, field, field_value)
         return data
 
     return {

{fastgenerateapi-1.2.8 → fastgenerateapi-1.2.10}/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,22 +29,28 @@ 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)
         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)
+        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)

{fastgenerateapi-1.2.8 → fastgenerateapi-1.2.10}/fastgenerateapi/schemas_factory/get_all_schema_factory.py

@@ -156,15 +156,17 @@ def get_all_schema_factory(
     return schema
 
 
-def get_list_schema_factory(schema_cls: Type[T] = None, name: str = "") -> Type[T]:
+def get_list_schema_factory(schema_cls: Type[T] = None, response_field: Optional[str] = None, name: str = "") -> Type[T]:
+    if not response_field:
+        response_field = settings.app_settings.LIST_RESPONSE_FIELD
     if schema_cls:
         fields = {
-            settings.app_settings.LIST_RESPONSE_FIELD: (Optional[List[schema_cls]], FieldInfo(default=[], description="数据返回")),
+            response_field: (Optional[List[schema_cls]], FieldInfo(default=[], description="数据返回")),
         }
         name = schema_cls.__name__ + name + "GetListSchema"
     else:
         fields = {
-            settings.app_settings.LIST_RESPONSE_FIELD: (Optional[List], FieldInfo(default=[], description="数据返回")),
+            response_field: (Optional[List], FieldInfo(default=[], description="数据返回")),
         }
         name = name + "GetListSchema"
     schema: Type[T] = create_model(name, **fields, __config__=model_config)

{fastgenerateapi-1.2.8 → fastgenerateapi-1.2.10}/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
 

fastgenerateapi-1.2.10/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.8 → fastgenerateapi-1.2.10}/fastgenerateapi/schemas_factory/get_tree_schema_factory.py

@@ -1,13 +1,13 @@
 from typing import Type, Optional, Union, List
 
-from fastgenerateapi.schemas_factory.get_one_schema_factory import get_one_schema_factory
 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
+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
 
 
@@ -16,47 +16,65 @@ def get_tree_schema_factory(
         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
     """
-    schema_name = name if name else model_class.__name__ + "GetTreeSchema"
-
     all_fields_info: dict = get_dict_from_model_fields(model_class)
 
     include_fields = set()
     exclude_fields = set()
-    if hasattr(model_class, "PydanticMeta"):
-        if 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 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, "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)
-
-        if hasattr(model_class.PydanticMeta, "get_tree_exclude"):
-            exclude_fields.update(model_class.PydanticMeta.get_tree_exclude)
-        if hasattr(model_class.PydanticMeta, "exclude"):
-            exclude_fields.update(model_class.PydanticMeta.exclude)
-    else:
-        include_fields.update(all_fields_info.keys())
-
+    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)
@@ -65,20 +83,26 @@ def get_tree_schema_factory(
         exclude_fields.update(exclude)
 
     all_fields = include_fields.difference(exclude_fields)
-
-    all_fields_info.setdefault(
-        settings.app_settings.DEFAULT_TREE_CHILDREN_FIELD,
-        (Optional[List[schema_name]], FieldInfo(default=[], description="子级目录"))
-    )
     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)
+        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.8 → fastgenerateapi-1.2.10}/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.8 → fastgenerateapi-1.2.10}/fastgenerateapi.egg-info/PKG-INFO

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

fastgenerateapi-1.2.8/fastgenerateapi/schemas_factory/get_relation_schema_factory.py

@@ -1,79 +0,0 @@
-from typing import Type, Optional, Union, List
-
-from fastgenerateapi.schemas_factory.get_one_schema_factory import get_one_schema_factory
-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
-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,
-        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()
-    if hasattr(model_class, "PydanticMeta"):
-        if 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 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, "get_relation_exclude"):
-            exclude_fields.update(model_class.PydanticMeta.get_tree_exclude)
-        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)
-        include_fields.update(include_fields_dict.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"
-    schema: Type[T] = create_model(
-        schema_name, **{field: all_fields_info[field] for field in all_fields}, __config__=model_config)
-
-    return schema
-
-
-
-
-
-
-
-
-
-