fastgenerateapi 1.2.11__tar.gz → 1.2.13__tar.gz

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

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

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

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

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

@@ -59,8 +59,8 @@ class UpdateView(BaseView, SaveMixin):
     async def set_update_model(self, model: Model, data_dict: dict, *args, **kwargs) -> Model:
         """
         在数据模型校验前后修改值:
-        - 【不常使用】：这里修改将不做唯一字段校验
-        - 可用于全局修改
+        - 这里修改将不做唯一字段校验
+        - 可用于例如租户id等全局修改，或者字段变更记录等
         data_dict.update({
             "user_id": request.user.id,
         })

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

@@ -1,13 +1,14 @@
 import time
 from datetime import datetime
-from typing import Type, Optional, Union, List
+from typing import Type, Optional, Union, List, Callable
 
+from fastapi import HTTPException
 from pydantic import field_validator, model_validator
 from pydantic.fields import FieldInfo
 from tortoise import Model
 
 from fastgenerateapi.api_view.mixin.dbmodel_mixin import DBModelMixin
-from fastgenerateapi.pydantic_utils.base_model import alias_generator
+from fastgenerateapi.pydantic_utils.base_model import alias_generator, BaseModel
 from fastgenerateapi.settings.all_settings import settings
 
 
@@ -165,6 +166,35 @@ def get_validate_dict_from_fields(fields_info: dict) -> dict:
     return validator_dict
 
 
+class FieldValidateInfo(BaseModel):
+    name: str
+    is_required: bool
+    description: str
+    func: Callable
+
+
+def get_field_validate_dict(infos: List[FieldValidateInfo]) -> dict:
+    """
+    字段做校验
+    :param infos:
+    :return:
+    """
+    if not infos:
+        return {}
+
+    def _func(i: FieldValidateInfo):
+        def func(cls, value):
+            is_empty = value is None or value == ''
+            if i.is_required and is_empty:
+                raise HTTPException(status_code=422, detail=i.description+"不能为空")
+            if not is_empty and not i.func(value):
+                raise HTTPException(status_code=422, detail=i.description+"校验不通过")
+            return value
+        return func
+
+    return {"check_"+info.name: field_validator(info.name)(_func(info)) for info in infos}
+
+
 def get_model_validate_text_to_list(fields: Optional[List[str]]) -> dict:
     """
     详情列表用于返回

{fastgenerateapi-1.2.11 → fastgenerateapi-1.2.13}/fastgenerateapi/schemas_factory/create_schema_factory.py

@@ -8,7 +8,7 @@ from tortoise import Model
 
 from fastgenerateapi.data_type.data_type import T
 from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_fields, get_dict_from_pydanticmeta, \
-    get_validate_dict_from_fields, get_model_validate_list_to_text
+    get_validate_dict_from_fields, get_model_validate_list_to_text, FieldValidateInfo, get_field_validate_dict
 
 
 def create_schema_factory(
@@ -17,12 +17,15 @@ def create_schema_factory(
         extra_include: Union[list, tuple, set] = None,
         exclude: Union[list, tuple, set] = None,
         frozen_exclude: Union[list, tuple, set] = ("created_at", "updated_at", "modified_at"),
+        pydantic_meta: Optional[bool] = True,
         pydantic_meta_include: Union[list, tuple, set] = None,
         pydantic_meta_exclude: Optional[bool] = True,
         pydantic_meta_save_include: Optional[bool] = True,
         pydantic_meta_save_exclude: Optional[bool] = True,
         pydantic_meta_create_include: Optional[bool] = True,
         pydantic_meta_create_exclude: Optional[bool] = True,
+        pydantic_meta_save_validate: Optional[bool] = True,
+        pydantic_meta_create_validate: Optional[bool] = True,
         pydantic_meta_text_to_list: Optional[bool] = True,
         name: Optional[str] = None
 ) -> Type[T]:
@@ -36,6 +39,8 @@ def create_schema_factory(
     - save_exclude: 增改通用，指定排除字段
     - create_include: 增使用，额外添加字段
     - create_exclude: 增使用，指定排除字段
+    - save_validate: 增改通用，指定字段做校验
+    - create_validate: 增使用，指定字段做校验
 
     逻辑顺序：合并所有include和exclude，排除include下包含的exclude字段
 
@@ -65,53 +70,72 @@ def create_schema_factory(
                 ("item_id_list", List[str], FieldInfo(description="多对多关联id列表")),
             ]
             save_exclude = ["ignore_field"]
+            save_validate = [("phone", phone_validate), ("id_card", id_card_validate)]
             create_include = ["create_user"]
             create_exclude = []
+            create_validate = []
     """
     all_fields_info = get_dict_from_model_fields(model_class)
 
     include_fields = set()
     exclude_fields = set()
     text_to_list_fields = set()
+    validate_field_info = []
     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_save_include and hasattr(model_class.PydanticMeta, "save_include"):
-                save_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.save_include)
-                all_fields_info.update(save_include_fields_dict)
-                include_fields.update(save_include_fields_dict.keys())
-            if pydantic_meta_create_include and hasattr(model_class.PydanticMeta, "create_include"):
-                create_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.create_include)
-                all_fields_info.update(create_include_fields_dict)
-                include_fields.update(create_include_fields_dict.keys())
-            if pydantic_meta_save_exclude and  hasattr(model_class.PydanticMeta, "save_exclude"):
-                exclude_fields.update(model_class.PydanticMeta.save_exclude)
-            if pydantic_meta_create_exclude and hasattr(model_class.PydanticMeta, "create_exclude"):
-                exclude_fields.update(model_class.PydanticMeta.create_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 = Union[List[str], str] if field_info.is_required() else Union[List[str], str, None]
-                    all_fields_info.update({field: (field_type, field_info)})
+    elif pydantic_meta and 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())
+        elif 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_save_include and hasattr(model_class.PydanticMeta, "save_include"):
+            save_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.save_include)
+            all_fields_info.update(save_include_fields_dict)
+            include_fields.update(save_include_fields_dict.keys())
+        if pydantic_meta_create_include and hasattr(model_class.PydanticMeta, "create_include"):
+            create_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.create_include)
+            all_fields_info.update(create_include_fields_dict)
+            include_fields.update(create_include_fields_dict.keys())
+        if pydantic_meta_save_exclude and  hasattr(model_class.PydanticMeta, "save_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.save_exclude)
+        if pydantic_meta_create_exclude and hasattr(model_class.PydanticMeta, "create_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.create_exclude)
+        if pydantic_meta_save_validate and hasattr(model_class.PydanticMeta, "save_validate"):
+            for validate in model_class.PydanticMeta.save_validate:
+                file_type, file_info = all_fields_info.get(validate[0])
+                validate_field_info.append(FieldValidateInfo(
+                    name=validate[0],
+                    is_required=file_info.is_required(),
+                    description=file_info.description,
+                    func=validate[1],
+                ))
+        if pydantic_meta_create_validate and hasattr(model_class.PydanticMeta, "create_validate"):
+            for validate in model_class.PydanticMeta.create_validate:
+                file_type, file_info = all_fields_info.get(validate[0])
+                validate_field_info.append(FieldValidateInfo(
+                    name=validate[0],
+                    is_required=file_info.is_required(),
+                    description=file_info.description,
+                    func=validate[1],
+                ))
+        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 = Union[List[str], str] if field_info.is_required() else Union[List[str], str, None]
+                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)
@@ -136,12 +160,13 @@ def create_schema_factory(
     schema_name = name if name else model_class.__name__ + "CreateSchema"
     schema_field_dict = {field: all_fields_info[field] for field in all_fields}
     validators_dict = get_validate_dict_from_fields(schema_field_dict)
+    field_validators = get_field_validate_dict(validate_field_info)
     text_to_list_validators_dict = get_model_validate_list_to_text(text_to_list_fields)
     schema: Type[T] = create_model(
         schema_name,
         **schema_field_dict,
         __config__=model_config,
-        __validators__={**validators_dict, **text_to_list_validators_dict},
+        __validators__={**validators_dict, **field_validators, **text_to_list_validators_dict},
     )
     return schema
 

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

@@ -24,6 +24,7 @@ def get_all_schema_factory(
         include: Union[list, tuple, set] = None,
         extra_include: Union[list, tuple, set] = None,
         exclude: Union[list, tuple, set] = None,
+        pydantic_meta: Optional[bool] = True,
         pydantic_meta_include: Union[list, tuple, set] = None,
         pydantic_meta_exclude: Optional[bool] = True,
         pydantic_meta_get_include: Optional[bool] = True,
@@ -93,67 +94,65 @@ def get_all_schema_factory(
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
         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.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_all_include and hasattr(model_class.PydanticMeta, "get_all_include"):
-                get_all_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_all_include)
-                all_fields_info.update(get_all_include_fields_dict)
-                include_fields.update(get_all_include_fields_dict.keys())
-            if pydantic_meta_get_all_exclude and hasattr(model_class.PydanticMeta, "get_all_exclude"):
-                exclude_fields.update(model_class.PydanticMeta.get_all_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)})
+    elif pydantic_meta and 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())
+        elif 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_all_include and hasattr(model_class.PydanticMeta, "get_all_include"):
+            get_all_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_all_include)
+            all_fields_info.update(get_all_include_fields_dict)
+            include_fields.update(get_all_include_fields_dict.keys())
+        if pydantic_meta_get_all_exclude and hasattr(model_class.PydanticMeta, "get_all_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.get_all_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__ + "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.11 → fastgenerateapi-1.2.13}/fastgenerateapi/schemas_factory/get_one_schema_factory.py

@@ -25,6 +25,7 @@ def get_one_schema_factory(
         include: Union[list, tuple, set] = None,
         extra_include: Union[list, tuple, set] = None,
         exclude: Union[list, tuple, set] = None,
+        pydantic_meta: Optional[bool] = True,
         pydantic_meta_include: Union[list, tuple, set] = None,
         pydantic_meta_exclude: Optional[bool] = True,
         pydantic_meta_get_include: Optional[bool] = True,
@@ -91,68 +92,66 @@ def get_one_schema_factory(
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
         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.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_one_include and hasattr(model_class.PydanticMeta, "get_one_include"):
-                get_one_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_one_include)
-                all_fields_info.update(get_one_include_fields_dict)
-                include_fields.update(get_one_include_fields_dict.keys())
-            if pydantic_meta_get_one_exclude and hasattr(model_class.PydanticMeta, "get_one_exclude"):
-                exclude_fields.update(model_class.PydanticMeta.get_one_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)})
+    elif pydantic_meta and 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())
+        elif 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_one_include and hasattr(model_class.PydanticMeta, "get_one_include"):
+            get_one_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_one_include)
+            all_fields_info.update(get_one_include_fields_dict)
+            include_fields.update(get_one_include_fields_dict.keys())
+        if pydantic_meta_get_one_exclude and hasattr(model_class.PydanticMeta, "get_one_exclude"):
+            exclude_fields.update(model_class.PydanticMeta.get_one_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__ + "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.13/fastgenerateapi/schemas_factory/get_relation_schema_factory.py

@@ -0,0 +1,101 @@
+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: Optional[bool] = True,
+        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())
+    elif pydantic_meta and 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())
+        elif 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
+
+
+
+
+
+
+
+
+
+