fastgenerateapi 1.2.12__tar.gz → 1.2.13__tar.gz

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

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

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

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

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

@@ -17,6 +17,7 @@ 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,
@@ -84,59 +85,57 @@ def create_schema_factory(
         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_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)})
+    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)

{fastgenerateapi-1.2.12 → 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.12 → 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
+
+
+
+
+
+
+
+
+
+

{fastgenerateapi-1.2.12 → fastgenerateapi-1.2.13}/fastgenerateapi/schemas_factory/get_tree_schema_factory.py

@@ -16,6 +16,7 @@ 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: Optional[bool] = True,
         pydantic_meta_include: Union[list, tuple, set] = None,
         pydantic_meta_exclude: Optional[bool] = True,
         pydantic_meta_get_include: Optional[bool] = True,
@@ -37,43 +38,41 @@ def get_tree_schema_factory(
         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)})
+    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_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)