fastgenerateapi 0.0.28__py2.py3-none-any.whl → 1.1.6__py2.py3-none-any.whl

fastgenerateapi/deps/filter_params_deps.py

@@ -1,25 +1,55 @@
-from typing import Type, Union, Any
+from typing import Type, Union, Any, Optional
 
-from fastapi import Depends
+from fastapi import Depends, Query
+from pydantic import create_model
 from tortoise import Model
 
 from fastgenerateapi.controller.filter_controller import BaseFilter
+from fastgenerateapi.data_type.data_type import PYDANTIC_SCHEMA
+from fastgenerateapi.pydantic_utils.base_model import EmptyPydantic, SearchPydantic
 from fastgenerateapi.schemas_factory.filter_schema_factory import filter_schema_factory
 
 
-def filter_params_deps(model_class: Type[Model], fields: list[str, tuple[str, Type], BaseFilter] = None):
+def search_params_deps(fields: Optional[list[str]] = None):
+    """
+    目的：当 fields 为空时，不会生成search的文档
+    :param fields:
+    :return:
+    """
+    if not fields:
+        filter_schema_dep = EmptyPydantic
+    else:
+        filter_schema_dep = SearchPydantic
+
+    def filter_search(search_params: filter_schema_dep = Depends()):
+        return getattr(search_params, "search", "")
+
+    return filter_search
+
+
+def filter_params_deps(
+        model_class: Type[Model],
+        fields: Optional[list[str, tuple[str, Type], BaseFilter]] = None,
+        schema: Optional[PYDANTIC_SCHEMA] = None
+):
     """
         生成filter依赖
     """
+    filter_schema_dep = schema or EmptyPydantic
     filter_params_model = filter_schema_factory(model_class, fields)
 
-    def filter_query(filter_params: filter_params_model = Depends(filter_params_model)) -> dict[str, Any]:
+    def filter_query(
+            filter_params: filter_params_model = Depends(),
+            filter_schema: filter_schema_dep = Depends(),
+    ) -> dict[str, Any]:
         """
             filter 筛选字段依赖
         :param filter_params:
+        :param filter_schema:
         :return:
         """
         result = filter_params.dict(exclude_none=True)
+        result.update(filter_schema.dict(exclude_none=True))
         return result
 
     return filter_query

fastgenerateapi/deps/paginator_deps.py

@@ -4,9 +4,9 @@ from fastapi import Depends, Query
 from pydantic import create_model
 from pydantic.fields import FieldInfo
 
-from fastgenerateapi.pydantic_utils.base_model import BaseModel, QueryConfig
-from fastgenerateapi.settings.register_settings import settings
-from fastgenerateapi.utils.parse_str import parse_str_to_int, parse_str_to_bool
+from fastgenerateapi.pydantic_utils.base_model import BaseModel, model_config
+from fastgenerateapi.settings.all_settings import settings
+from fastgenerateapi.utils.str_util import parse_str_to_int, parse_str_to_bool
 
 
 def paginator_deps():
@@ -42,7 +42,7 @@ def paginator_deps():
             FieldInfo(default=Query(settings.app_settings.DEFAULT_WHETHER_PAGE), title="是否分页", description="是否分页")
         ),
     }
-    pagination_model: Type[BaseModel] = create_model("paginator", **fields, __config__=QueryConfig)
+    pagination_model: Type[BaseModel] = create_model("paginator", **fields, __config__=model_config)
 
     def pagination_deps(paginator: pagination_model = Depends(pagination_model)) -> pagination_model:
         current_page_value = parse_str_to_int(getattr(paginator, settings.app_settings.CURRENT_PAGE_FIELD))

fastgenerateapi/deps/tree_params_deps.py

@@ -3,9 +3,10 @@ from typing import Type, Any, Optional
 from fastapi import Depends, Query
 from pydantic.fields import FieldInfo
 
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.pydantic_utils.base_model import model_config
+from fastgenerateapi.pydantic_utils.base_model import ModelConfig
+from fastgenerateapi.settings.all_settings import settings
 
-from fastgenerateapi.pydantic_utils.base_model import QueryConfig
 from pydantic import BaseModel, create_model
 
 
@@ -25,8 +26,7 @@ def tree_params_deps():
         )
     }
 
-    filter_tree_params_model: Type[BaseModel] = create_model(
-        __model_name="TreeFilterParams", **model_fields,  __config__=QueryConfig)
+    filter_tree_params_model: Type[BaseModel] = create_model("TreeFilterParams", __config__=model_config, **model_fields)
 
     def filter_query(filter_params: filter_tree_params_model = Depends(filter_tree_params_model)) -> Optional[str]:
         """

fastgenerateapi/fastapi_utils/all.py

@@ -0,0 +1,5 @@
+
+# 统一导入
+from .param_utils import *
+from .response_utils import *
+

fastgenerateapi/fastapi_utils/param_utils.py

@@ -0,0 +1,37 @@
+# 用于解决依赖中使用Query、Path等参数时，无法获取相关信息的问题
+
+from typing import List, Optional
+
+import fastapi
+from fastapi import params
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import get_sub_dependant
+
+
+def get_param_sub_dependant(
+        *,
+        param_name: str,
+        depends: params.Depends,
+        path: str,
+        security_scopes: Optional[List[str]] = None,
+) -> Dependant:
+    assert depends.dependency
+    dependant = get_sub_dependant(
+        depends=depends,
+        dependency=depends.dependency,
+        path=path,
+        name=param_name,
+        security_scopes=security_scopes,
+    )
+    for query_param in dependant.query_params:
+        query_param_field = depends.dependency.model_fields.get(query_param.name)
+        if query_param_field:
+            query_param.field_info.description = query_param_field.description or query_param_field.title or ""
+        else:
+            query_param.field_info.description = query_param_field.description or query_param_field.title or ""
+    return dependant
+
+
+fastapi.dependencies.utils.get_param_sub_dependant = get_param_sub_dependant
+
+

fastgenerateapi/fastapi_utils/response_utils.py

@@ -0,0 +1,344 @@
+# 解决中间键日志问题
+# request.scope["customize_result"]中存储业务函数的响应
+# request.scope["customize_para"]中存储router 中的name、summary、description参数
+
+# 重写fastapi routing 把路由解析参数附加到requests
+
+from contextlib import AsyncExitStack
+from fastapi._compat import ModelField, _normalize_errors
+from fastapi.dependencies.utils import get_typed_return_annotation
+from fastapi.types import IncEx
+
+import asyncio
+import email.message
+import enum
+import inspect
+import json
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Set,
+    Type,
+    Union,
+)
+
+from fastapi import params
+from fastapi.datastructures import Default, DefaultPlaceholder
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import (
+    get_body_field,
+    get_dependant,
+    get_parameterless_sub_dependant,
+    solve_dependencies,
+)
+from fastapi.exceptions import RequestValidationError
+from fastapi.routing import run_endpoint_function
+from fastapi.utils import (
+    create_cloned_field,
+    create_response_field,
+    is_body_allowed_for_status_code, generate_unique_id,
+)
+from fastapi._compat import Undefined
+from pydantic.utils import lenient_issubclass
+from starlette import routing
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.routing import BaseRoute
+from starlette.routing import (
+    compile_path,
+    get_name,
+    request_response,
+)
+from fastapi.routing import serialize_response
+from fastapi import routing as fastapi_routing
+
+
+# 把数据储存到request.scope字典中
+def get_request_handler(
+        dependant: Dependant,
+        body_field: Optional[ModelField] = None,
+        status_code: Optional[int] = None,
+        response_class: Union[Type[Response], DefaultPlaceholder] = Default(JSONResponse),
+        response_field: Optional[ModelField] = None,
+        response_model_include: Optional[IncEx] = None,
+        response_model_exclude: Optional[IncEx] = None,
+        response_model_by_alias: bool = True,
+        response_model_exclude_unset: bool = False,
+        response_model_exclude_defaults: bool = False,
+        response_model_exclude_none: bool = False,
+        dependency_overrides_provider: Optional[Any] = None,
+        customize_para: Dict = None,
+) -> Callable[[Request], Coroutine[Any, Any, Response]]:
+    assert dependant.call is not None, "dependant.call must be a function"
+    is_coroutine = asyncio.iscoroutinefunction(dependant.call)
+    is_body_form = body_field and isinstance(body_field.field_info, params.Form)
+    if isinstance(response_class, DefaultPlaceholder):
+        actual_response_class: Type[Response] = response_class.value
+    else:
+        actual_response_class = response_class
+
+    async def app(request: Request) -> Response:
+        request.scope["customize_para"] = customize_para  # 增加
+        try:
+            body: Any = None
+            if body_field:
+                if is_body_form:
+                    body = await request.form()
+                    stack = request.scope.get("fastapi_astack")
+                    assert isinstance(stack, AsyncExitStack)
+                    stack.push_async_callback(body.close)
+                else:
+                    body_bytes = await request.body()
+                    if body_bytes:
+                        json_body: Any = Undefined
+                        content_type_value = request.headers.get("content-type")
+                        if not content_type_value:
+                            json_body = await request.json()
+                        else:
+                            message = email.message.Message()
+                            message["content-type"] = content_type_value
+                            if message.get_content_maintype() == "application":
+                                subtype = message.get_content_subtype()
+                                if subtype == "json" or subtype.endswith("+json"):
+                                    json_body = await request.json()
+                        if json_body != Undefined:
+                            body = json_body
+                        else:
+                            body = body_bytes
+        except json.JSONDecodeError as e:
+            raise RequestValidationError(
+                [
+                    {
+                        "type": "json_invalid",
+                        "loc": ("body", e.pos),
+                        "msg": "JSON decode error",
+                        "input": {},
+                        "ctx": {"error": e.msg},
+                    }
+                ],
+                body=e.doc,
+            ) from e
+        except HTTPException:
+            raise
+        except Exception as e:
+            raise HTTPException(
+                status_code=400, detail="There was an error parsing the body"
+            ) from e
+        solved_result = await solve_dependencies(
+            request=request,
+            dependant=dependant,
+            body=body,
+            dependency_overrides_provider=dependency_overrides_provider,
+        )
+        values, errors, background_tasks, sub_response, _ = solved_result
+        if errors:
+            raise RequestValidationError(_normalize_errors(errors), body=body)
+        else:
+            raw_response = await run_endpoint_function(
+                dependant=dependant, values=values, is_coroutine=is_coroutine
+            )
+
+            if isinstance(raw_response, Response):
+                if raw_response.background is None:
+                    raw_response.background = background_tasks
+                request.scope["customize_result"] = raw_response      # 增加
+                return raw_response
+
+            request.scope["customize_result"] = raw_response      # 增加
+            response_args: Dict[str, Any] = {"background": background_tasks}
+            # If status_code was set, use it, otherwise use the default from the
+            # response class, in the case of redirect it's 307
+            current_status_code = (
+                status_code if status_code else sub_response.status_code
+            )
+            if current_status_code is not None:
+                response_args["status_code"] = current_status_code
+            if sub_response.status_code:
+                response_args["status_code"] = sub_response.status_code
+            content = await serialize_response(
+                field=response_field,
+                response_content=raw_response,
+                include=response_model_include,
+                exclude=response_model_exclude,
+                by_alias=response_model_by_alias,
+                exclude_unset=response_model_exclude_unset,
+                exclude_defaults=response_model_exclude_defaults,
+                exclude_none=response_model_exclude_none,
+                is_coroutine=is_coroutine,
+            )
+            response = actual_response_class(content, **response_args)
+            if not is_body_allowed_for_status_code(response.status_code):
+                response.body = b""
+            response.headers.raw.extend(sub_response.headers.raw)
+            return response
+
+    return app
+
+
+# 从__init__中调用方法get_route_handler，并携带参数
+# get_route_handler调用get_request_handler，并携带参数
+class APIRoute(routing.Route):
+    def __init__(
+            self,
+            path: str,
+            endpoint: Callable[..., Any],
+            *,
+            response_model: Any = Default(None),
+            status_code: Optional[int] = None,
+            tags: Optional[List[Union[str, enum.Enum]]] = None,
+            dependencies: Optional[Sequence[params.Depends]] = None,
+            summary: Optional[str] = None,
+            description: Optional[str] = None,
+            response_description: str = "Successful Response",
+            responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
+            deprecated: Optional[bool] = None,
+            name: Optional[str] = None,
+            methods: Optional[Union[Set[str], List[str]]] = None,
+            operation_id: Optional[str] = None,
+            response_model_include: Optional[IncEx] = None,
+            response_model_exclude: Optional[IncEx] = None,
+            response_model_by_alias: bool = True,
+            response_model_exclude_unset: bool = False,
+            response_model_exclude_defaults: bool = False,
+            response_model_exclude_none: bool = False,
+            include_in_schema: bool = True,
+            response_class: Union[Type[Response], DefaultPlaceholder] = Default(
+                JSONResponse
+            ),
+            dependency_overrides_provider: Optional[Any] = None,
+            callbacks: Optional[List[BaseRoute]] = None,
+            openapi_extra: Optional[Dict[str, Any]] = None,
+            generate_unique_id_function: Union[
+                Callable[["APIRoute"], str], DefaultPlaceholder
+            ] = Default(generate_unique_id),
+    ) -> None:
+        self.path = path
+        self.endpoint = endpoint
+        if isinstance(response_model, DefaultPlaceholder):
+            return_annotation = get_typed_return_annotation(endpoint)
+            if lenient_issubclass(return_annotation, Response):
+                response_model = None
+            else:
+                response_model = return_annotation
+        self.response_model = response_model
+        self.summary = summary
+        self.response_description = response_description
+        self.deprecated = deprecated
+        self.operation_id = operation_id
+        self.response_model_include = response_model_include
+        self.response_model_exclude = response_model_exclude
+        self.response_model_by_alias = response_model_by_alias
+        self.response_model_exclude_unset = response_model_exclude_unset
+        self.response_model_exclude_defaults = response_model_exclude_defaults
+        self.response_model_exclude_none = response_model_exclude_none
+        self.include_in_schema = include_in_schema
+        self.response_class = response_class
+        self.dependency_overrides_provider = dependency_overrides_provider
+        self.callbacks = callbacks
+        self.openapi_extra = openapi_extra
+        self.generate_unique_id_function = generate_unique_id_function
+        self.tags = tags or []
+        self.responses = responses or {}
+        self.name = get_name(endpoint) if name is None else name
+        self.path_regex, self.path_format, self.param_convertors = compile_path(path)
+        if methods is None:
+            methods = ["GET"]
+        self.methods: Set[str] = {method.upper() for method in methods}
+        if isinstance(generate_unique_id_function, DefaultPlaceholder):
+            current_generate_unique_id: Callable[
+                ["APIRoute"], str
+            ] = generate_unique_id_function.value
+        else:
+            current_generate_unique_id = generate_unique_id_function
+        self.unique_id = self.operation_id or current_generate_unique_id(self)
+        # normalize enums e.g. http.HTTPStatus
+        if isinstance(status_code, enum.IntEnum):
+            status_code = int(status_code)
+        self.status_code = status_code
+        if self.response_model:
+            assert is_body_allowed_for_status_code(
+                status_code
+            ), f"Status code {status_code} must not have a response body"
+            response_name = "Response_" + self.unique_id
+            self.response_field = create_response_field(
+                name=response_name,
+                type_=self.response_model,
+                mode="serialization",
+            )
+            # Create a clone of the field, so that a Pydantic submodel is not returned
+            # as is just because it's an instance of a subclass of a more limited class
+            # e.g. UserInDB (containing hashed_password) could be a subclass of User
+            # that doesn't have the hashed_password. But because it's a subclass, it
+            # would pass the validation and be returned as is.
+            # By being a new field, no inheritance will be passed as is. A new model
+            # will always be created.
+            # TODO: remove when deprecating Pydantic v1
+            self.secure_cloned_response_field: Optional[
+                ModelField
+            ] = create_cloned_field(self.response_field)
+        else:
+            self.response_field = None  # type: ignore
+            self.secure_cloned_response_field = None
+        self.dependencies = list(dependencies or [])
+        self.description = description or inspect.cleandoc(self.endpoint.__doc__ or "")
+        # if a "form feed" character (page break) is found in the description text,
+        # truncate description text to the content preceding the first "form feed"
+        self.description = self.description.split("\f")[0].strip()
+        response_fields = {}
+        for additional_status_code, response in self.responses.items():
+            assert isinstance(response, dict), "An additional response must be a dict"
+            model = response.get("model")
+            if model:
+                assert is_body_allowed_for_status_code(
+                    additional_status_code
+                ), f"Status code {additional_status_code} must not have a response body"
+                response_name = f"Response_{additional_status_code}_{self.unique_id}"
+                response_field = create_response_field(name=response_name, type_=model)
+                response_fields[additional_status_code] = response_field
+        if response_fields:
+            self.response_fields: Dict[Union[int, str], ModelField] = response_fields
+        else:
+            self.response_fields = {}
+
+        assert callable(endpoint), "An endpoint must be a callable"
+        self.dependant = get_dependant(path=self.path_format, call=self.endpoint)
+        for depends in self.dependencies[::-1]:
+            self.dependant.dependencies.insert(
+                0,
+                get_parameterless_sub_dependant(depends=depends, path=self.path_format),
+            )
+        self.body_field = get_body_field(dependant=self.dependant, name=self.unique_id)
+        # 增加参数
+        self.app = request_response(self.get_route_handler({
+            "summary": self.summary,
+            "description": self.description,
+            "name": self.name
+        }))
+
+    def get_route_handler(self, customize_para: Dict = None) -> Callable[[Request], Coroutine[Any, Any, Response]]:
+        return get_request_handler(
+            dependant=self.dependant,
+            body_field=self.body_field,
+            status_code=self.status_code,
+            response_class=self.response_class,
+            response_field=self.secure_cloned_response_field,
+            response_model_include=self.response_model_include,
+            response_model_exclude=self.response_model_exclude,
+            response_model_by_alias=self.response_model_by_alias,
+            response_model_exclude_unset=self.response_model_exclude_unset,
+            response_model_exclude_defaults=self.response_model_exclude_defaults,
+            response_model_exclude_none=self.response_model_exclude_none,
+            dependency_overrides_provider=self.dependency_overrides_provider,
+            customize_para=customize_para,  # 增加
+        )
+
+
+fastapi_routing.get_request_handler = get_request_handler
+fastapi_routing.APIRoute.__init__ = APIRoute.__init__
+fastapi_routing.APIRoute.get_route_handler = APIRoute.get_route_handler

fastgenerateapi/model/base_model.py

@@ -0,0 +1,56 @@
+import datetime
+import time
+from typing import Optional
+from tortoise import fields, models, BaseDBAsyncClient
+
+from fastgenerateapi import my_fields
+
+
+class PrimaryKeyMixin(models.Model):
+    id: str = my_fields.PrimaryKeyField(pk=True)
+
+    class Meta:
+        abstract = True
+
+    def __str__(self) -> str:
+        return f"{self.id}"
+
+
+class TimestampMixin(models.Model):
+    created_at: Optional[datetime.datetime] = fields.DatetimeField(null=True, auto_now_add=True, description="创建时间")
+    updated_at: Optional[datetime.datetime] = fields.DatetimeField(null=True, auto_now=True, description="更新时间")
+
+    class Meta:
+        abstract = True
+
+
+class BaseDeleteMixin(models.Model):
+    deleted_at: Optional[int] = my_fields.SoftDeleteField()
+
+    async def delete(self, using_db: Optional[BaseDBAsyncClient] = None) -> None:
+        self.deleted_at = int(time.time() * 1000)
+        await self.save(using_db=using_db)
+
+    class Meta:
+        abstract = True
+
+
+class BaseActiveMixin(models.Model):
+    is_active: Optional[bool] = fields.BooleanField(null=True, default=True, description="数据是否有效")
+
+    async def delete(self, using_db: Optional[BaseDBAsyncClient] = None) -> None:
+        self.is_active = False
+        await self.save(using_db=using_db)
+
+    class Meta:
+        abstract = True
+
+
+class TortoiseOrmAbstractModel(PrimaryKeyMixin, TimestampMixin, BaseDeleteMixin):
+    ...
+
+    class PydanticMeta:
+        exclude = ["delete_at"]
+
+    class Meta:
+        abstract = True

fastgenerateapi/my_fields/enum_field.py

@@ -34,9 +34,8 @@ class IntEnumField(IntEnumFieldInstance):
     """
 
     def __init__(self, enum_list: List[any], **kwargs: Any) -> None:
-        kwargs.setdefault("description", self.get_description(enum_list))
         self.enum_list = enum_list
-        self.description = kwargs.get("description")
+        self.description = kwargs.get("description", "") + " >> " + self.get_description(enum_list)
         super().__init__(enum_type=self.create_enum(enum_list), **kwargs)
 
     @property
@@ -85,7 +84,8 @@ class IntEnumField(IntEnumFieldInstance):
         # 返回创建的枚举类
         return enum_class
 
-    def number_to_words(self, num):
+    @classmethod
+    def number_to_words(cls, num):
         # 定义数字到单词的映射
         ones = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten',
                 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen']
@@ -108,7 +108,7 @@ class IntEnumField(IntEnumFieldInstance):
         if num < 1000:
             hundred_digit = num // 100
             remaining = num % 100
-            return ones[hundred_digit] + '_hundred_' + self.number_to_words(remaining)
+            return ones[hundred_digit] + '_hundred_' + cls.number_to_words(remaining)
 
             # 对于大于1000的数字，可以进一步扩展这个函数来处理
         # 但请注意，标准的英文数字读法会变得复杂，涉及"thousand", "million", "billion"等词
@@ -116,7 +116,7 @@ class IntEnumField(IntEnumFieldInstance):
         # 这里仅处理到9999，如果需要处理更大的数字，请继续扩展这个函数
         thousand_digit = num // 1000
         remaining = num % 1000
-        return self.number_to_words(thousand_digit) + '_thousand_' + self.number_to_words(remaining)
+        return cls.number_to_words(thousand_digit) + '_thousand_' + cls.number_to_words(remaining)
 
 
 class IntEnumClass:

fastgenerateapi/my_fields/validator.py

@@ -0,0 +1,60 @@
+import datetime
+import re
+
+from tortoise.validators import Validator
+
+from fastgenerateapi.api_view.mixin.response_mixin import ResponseMixin
+
+
+class BlankStringValidator(Validator):
+    """
+    不允许空字符串校验
+    """
+    def __init__(self, description: str):
+        self.description = description
+
+    def __call__(self, value: str):
+        if isinstance(value, str):
+            value = value.strip()
+        if not value:
+            return ResponseMixin.error(status_code=422, message=f"{self.description}不能为空")
+
+
+class IDCardValidator(Validator):
+    """
+    身份证校验
+    """
+
+    def __call__(self, value: str):
+        if len(value) == 15:
+            return value
+        if len(value) != 18:
+            return ResponseMixin.error(message="身份证输入错误")
+        this_year = datetime.datetime.now().year
+        if int(value[6:10]) < 1000 or int(value[6:10]) > this_year:
+            return ResponseMixin.error(message="身份证输入错误")
+        if int(value[10:12]) < 1 or int(value[10:12]) > 12 or int(value[12:14]) < 1 or int(value[12:14]) > 31:
+            return ResponseMixin.error(message="身份证输入错误")
+        arg_list = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
+        check_list = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"]
+        sum_num = 0
+        for index, num in enumerate(value[:-1]):
+            sum_num += arg_list[index] * int(num)
+        if value[-1] != check_list[sum_num % 11]:
+            return ResponseMixin.error(message=f"身份证: {value} 输入错误")
+        return value
+
+
+class PhoneValidator(Validator):
+    """
+    手机号码校验
+    """
+
+    def __call__(self, value: str):
+        ret = re.compile('^(?:(?:\+|00)86)?1[3-9]\d{9}$')
+        res = ret.match(value)
+        if res:
+            return res.group()
+        return ResponseMixin.error(message="手机号码校验不通过")
+
+