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

fastgenerateapi/__init__.py

@@ -23,6 +23,6 @@ from fastgenerateapi.api_view.update_relation_view import UpdateRelationView
 from fastgenerateapi.channel.websocket_view import WebsocketView
 from fastgenerateapi.channel.consumer import Consumer
 
-# 查看配置模型
-from fastgenerateapi.settings.settings import SettingsModel
+# 模型相关类
+from fastgenerateapi.pydantic_utils.base_model import model_config, BaseModel, IdList
 

fastgenerateapi/__version__.py

@@ -8,7 +8,7 @@
 #                                                  d8888P
 
 
-VERSION = (0, 0, 27)
+VERSION = (1, 1, 6)
 
 __version__ = '.'.join(map(str, VERSION))
 

fastgenerateapi/api_view/base_view.py

@@ -15,7 +15,7 @@ from fastgenerateapi.api_view.mixin.base_mixin import BaseMixin
 from fastgenerateapi.api_view.mixin.dbmodel_mixin import DBModelMixin
 from fastgenerateapi.api_view.mixin.response_mixin import ResponseMixin
 from fastgenerateapi.api_view.mixin.tool_mixin import ToolMixin
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from fastgenerateapi.utils.exception import NOT_FOUND
 
 
@@ -93,10 +93,17 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
         return result
 
     async def delete_queryset(self, queryset: QuerySet):
-
-        await queryset.update(**{
-            settings.app_settings.WHETHER_DELETE_FIELD: self._delete_value()
-        })
+        """
+        考虑到不一定会集成已有的模型，删除根据是否存在字段来判断
+        :param queryset:
+        :return:
+        """
+        if settings.app_settings.WHETHER_DELETE_FIELD in queryset.fields:
+            await queryset.update(**{
+                settings.app_settings.WHETHER_DELETE_FIELD: self._delete_value()
+            })
+        else:
+            await queryset.delete()
 
     @staticmethod
     async def setattr_model(model: Model, prefetch_related_fields, *args, **kwargs) -> Model:
@@ -137,8 +144,11 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
                     attr_model = getattr(attr_model, attr_key, None)
                 model_dict[field[1]] = attr_model
                 model_fields[field[1]] = (type(attr_model), ...)
-        schema = create_model(__model_name=f"{Model.__name__}{uuid.uuid4()}", **model_fields)
-        return schema.parse_obj(model_dict)
+        schema = create_model(
+            f"{Model.__name__}{uuid.uuid4()}",
+            **model_fields
+        )
+        return schema.model_validate(model_dict)
 
     async def check_unique_field(
             self,

fastgenerateapi/api_view/create_view.py

@@ -11,7 +11,7 @@ from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.api_view.mixin.save_mixin import SaveMixin
 from fastgenerateapi.data_type.data_type import DEPENDENCIES
 from fastgenerateapi.schemas_factory import get_one_schema_factory, create_schema_factory, response_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class CreateView(BaseView, SaveMixin):

fastgenerateapi/api_view/delete_filter_view.py

@@ -10,7 +10,7 @@ from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.data_type.data_type import CALLABLE, DEPENDENCIES
 from fastgenerateapi.deps import filter_params_deps
 from fastgenerateapi.schemas_factory import response_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class DeleteFilterView(BaseView):

fastgenerateapi/api_view/delete_tree_view.py

@@ -9,15 +9,15 @@ from tortoise.transactions import atomic
 
 from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.data_type.data_type import CALLABLE, DEPENDENCIES
-from fastgenerateapi.pydantic_utils.base_model import IDList
+from fastgenerateapi.pydantic_utils.base_model import IdList
 from fastgenerateapi.schemas_factory import response_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class DeleteTreeView(BaseView):
 
     delete_tree_route: Union[bool, DEPENDENCIES] = True
-    delete_tree_schema: Optional[Type[BaseModel]] = IDList
+    delete_tree_schema: Optional[Type[BaseModel]] = IdList
     """
     delete_route: 删除路由开关，可以放依赖函数列表
     delete_schema: 删除请求模型

fastgenerateapi/api_view/delete_view.py

@@ -9,15 +9,15 @@ from tortoise.transactions import atomic
 
 from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.data_type.data_type import CALLABLE, DEPENDENCIES
-from fastgenerateapi.pydantic_utils.base_model import IDList
+from fastgenerateapi.pydantic_utils.base_model import IdList
 from fastgenerateapi.schemas_factory import response_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class DeleteView(BaseView):
 
     delete_route: Union[bool, DEPENDENCIES] = True
-    delete_schema: Optional[Type[BaseModel]] = IDList
+    delete_schema: Optional[Type[BaseModel]] = IdList
     """
     delete_route: 删除路由开关，可以放依赖函数列表
     delete_schema: 删除请求模型

fastgenerateapi/api_view/get_all_view.py

@@ -16,19 +16,20 @@ from fastgenerateapi.api_view.mixin.get_mixin import GetMixin
 from fastgenerateapi.cache.cache_decorator import get_all_cache_decorator
 from fastgenerateapi.cache.key_builder import generate_key_builder
 from fastgenerateapi.controller import SearchController, BaseFilter, FilterController
-from fastgenerateapi.data_type.data_type import DEPENDENCIES
+from fastgenerateapi.data_type.data_type import DEPENDENCIES, PYDANTIC_SCHEMA
 from fastgenerateapi.deps import paginator_deps, filter_params_deps
+from fastgenerateapi.deps.filter_params_deps import search_params_deps
 from fastgenerateapi.schemas_factory import get_all_schema_factory, get_page_schema_factory, get_one_schema_factory, \
     response_factory
 from fastgenerateapi.schemas_factory.get_all_schema_factory import get_list_schema_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class GetAllView(BaseView, GetMixin):
-
     get_all_route: Union[bool, DEPENDENCIES] = True
-    get_all_schema: Optional[Type[BaseModel]] = None
+    get_all_schema: Optional[Type[PYDANTIC_SCHEMA]] = None
     search_fields: Union[None, list] = None
+    filter_schema: Optional[Type[PYDANTIC_SCHEMA]] = None
     filter_fields: Union[None, list] = None
     order_by_fields: Union[None, list] = None
     """
@@ -45,12 +46,12 @@ class GetAllView(BaseView, GetMixin):
     order_by_fields: 排序对应字段
     """
 
-    async def get_all(self, search: str, filters: dict, *args, **kwargs) -> Union[BaseModel, dict, None]:
+    async def get_all(self, search: Optional[str], filters: dict, *args, **kwargs) -> Union[BaseModel, dict, None]:
         queryset = await self.get_queryset(search=search, filters=filters, *args, **kwargs)
 
         return await self.pagination_data(queryset=queryset, *args, **kwargs)
 
-    async def get_queryset(self, search: str, filters: dict, *args, **kwargs) -> QuerySet:
+    async def get_queryset(self, search: Optional[str], filters: dict, *args, **kwargs) -> QuerySet:
         """
         处理search搜索；处理筛选字段；处理外键预加载；处理排序
         """
@@ -81,14 +82,15 @@ class GetAllView(BaseView, GetMixin):
     async def pagination_data(
             self,
             queryset: QuerySet,
-            paginator,
+            paginator=None,
             schema: Type[BaseModel] = None,
             fields: List[Union[str, tuple]] = None,
             *args, **kwargs
     ):
 
         data_list = []
-        if getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
+        if paginator is None or getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == \
+                settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
             model_list = await queryset.all()
         else:
             count = await queryset.count()
@@ -112,7 +114,8 @@ class GetAllView(BaseView, GetMixin):
             else:
                 data_list.append(self.get_all_schema.from_orm(model))
 
-        if getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
+        if paginator is None or getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == \
+                settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
             if schema or fields:
                 return get_list_schema_factory()(**{settings.app_settings.LIST_RESPONSE_FIELD: data_list})
             return self.get_list_schema(**{settings.app_settings.LIST_RESPONSE_FIELD: data_list})
@@ -134,12 +137,13 @@ class GetAllView(BaseView, GetMixin):
         return getattr(page_result, settings.app_settings.LIST_RESPONSE_FIELD, [])
 
     def _get_all_decorator(self, *args: Any, **kwargs: Any) -> DecoratedCallable:
-        @get_all_cache_decorator(cache(expire=settings.app_settings.CACHE_GET_ALL_SECONDS, coder=JsonCoder, key_builder=generate_key_builder))
+        @get_all_cache_decorator(cache(expire=settings.app_settings.CACHE_GET_ALL_SECONDS, coder=JsonCoder,
+                                       key_builder=generate_key_builder))
         async def route(
                 request: Request,
                 paginator=Depends(paginator_deps()),
-                search: str = Query(default="", description="搜索"),
-                filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields)),
+                search: Optional[str] = Depends(search_params_deps(self.search_fields)),
+                filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields, schema=self.filter_schema)),
         ) -> JSONResponse:
             data = await self.get_all(
                 paginator=paginator,
@@ -150,14 +154,17 @@ class GetAllView(BaseView, GetMixin):
                 **kwargs
             )
             return self.success(data=data)
+
         return route
 
     def _handler_get_all_settings(self):
         if not self.get_all_route:
             return
         self.search_controller = SearchController(self.get_base_filter(self.search_fields))
-        self.filter_controller = FilterController(self.get_base_filter(self.filter_fields))
-        self.get_all_schema = self.get_all_schema or get_all_schema_factory(self.model_class) or self.get_one_schema if hasattr(self, "get_one_schema") else get_one_schema_factory(self.model_class)
+        self.filter_controller = FilterController(self.get_base_filter(self.filter_fields, self.filter_schema))
+        self.get_all_schema = self.get_all_schema or get_all_schema_factory(
+            self.model_class) or self.get_one_schema if hasattr(self, "get_one_schema") else get_one_schema_factory(
+            self.model_class)
         self.get_page_schema = get_page_schema_factory(self.get_all_schema)
         self.get_list_schema = get_list_schema_factory(self.get_all_schema)
         self.get_all_response_schema = response_factory(self.get_page_schema, name="GetPage")
@@ -172,6 +179,3 @@ class GetAllView(BaseView, GetMixin):
             summary=summary,
             dependencies=self.get_all_route,
         )
-
-
-

fastgenerateapi/api_view/get_one_view.py

@@ -14,7 +14,7 @@ from fastgenerateapi.cache.cache_decorator import get_one_cache_decorator
 from fastgenerateapi.cache.key_builder import generate_key_builder
 from fastgenerateapi.data_type.data_type import CALLABLE, DEPENDENCIES
 from fastgenerateapi.schemas_factory import get_one_schema_factory, response_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from fastgenerateapi.utils.exception import NOT_FOUND
 
 

fastgenerateapi/api_view/get_relation_view.py

@@ -16,7 +16,7 @@ from fastgenerateapi.deps import paginator_deps, filter_params_deps
 from fastgenerateapi.schemas_factory import get_page_schema_factory, response_factory
 from fastgenerateapi.schemas_factory.get_all_schema_factory import get_list_schema_factory
 from fastgenerateapi.schemas_factory.get_relation_schema_factory import get_relation_schema_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class GetRelationView(BaseView):

fastgenerateapi/api_view/get_tree_view.py

@@ -25,7 +25,7 @@ from fastgenerateapi.deps import paginator_deps, filter_params_deps
 from fastgenerateapi.deps.tree_params_deps import tree_params_deps
 from fastgenerateapi.schemas_factory import get_one_schema_factory, response_factory
 from fastgenerateapi.schemas_factory.get_tree_schema_factory import get_tree_schema_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class GetTreeView(BaseView):

fastgenerateapi/api_view/mixin/base_mixin.py

@@ -10,10 +10,10 @@ from fastgenerateapi.controller.filter_controller import BaseFilter
 from fastgenerateapi.controller import RouterController
 from fastgenerateapi.controller.ws_controller import WsController
 
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from starlette.exceptions import HTTPException
 
-from fastgenerateapi.data_type.data_type import DEPENDENCIES, T
+from fastgenerateapi.data_type.data_type import DEPENDENCIES, T, PYDANTIC_SCHEMA
 
 
 class BaseMixin(Generic[T], APIRouter, ABC):
@@ -52,10 +52,13 @@ class BaseMixin(Generic[T], APIRouter, ABC):
         #     if hasattr(self, "_handler_sql_get_all_settings"):
         #         getattr(self, "_handler_sql_get_all_settings")()
 
-    def get_base_filter(self, fields: list) -> list:
-        if fields is None:
-            return []
-        return [BaseFilter(field) if not isinstance(field, BaseFilter) else field for field in fields]
+    def get_base_filter(self, fields: list, schema: Optional[PYDANTIC_SCHEMA] = None) -> list:
+        bast_filter_list = []
+        if fields:
+            bast_filter_list += [BaseFilter(field) if not isinstance(field, BaseFilter) else field for field in fields]
+        if schema:
+            bast_filter_list += [BaseFilter((field, model_field.alias)) for field, model_field in schema.__fields__.items()]
+        return bast_filter_list
 
     @staticmethod
     def _get_routes(is_controller_field: bool = False) -> List[str]:
@@ -70,7 +73,8 @@ class BaseMixin(Generic[T], APIRouter, ABC):
     def _get_cls_api_func(cls):
         func_list = inspect.getmembers(cls, inspect.isfunction)
 
-        return [(func[0], inspect.signature(func[1]).return_annotation) for func in func_list if func[0].startswith("view_")]
+        return [(func[0], inspect.signature(func[1]).return_annotation) for func in func_list if
+                func[0].startswith("view_")]
 
     @classmethod
     def _get_cls_ws_func(cls):

fastgenerateapi/api_view/mixin/dbmodel_mixin.py

@@ -1,11 +1,19 @@
 import inspect
 from typing import Type, Union, List, Optional
 
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from tortoise import Model
 
 
 class DBModelMixin:
+    others_description = {
+        "gt": "大于",
+        "gte": "大于等于",
+        "lt": "小于",
+        "lte": "小于等于",
+        "contains": "模糊搜索",
+        "in": "范围",
+    }
 
     @staticmethod
     def _get_pk_field(model_class: Type[Model]) -> str:
@@ -16,34 +24,33 @@ class DBModelMixin:
 
     @staticmethod
     def get_field_description(model_class: Type[Model], fields: Union[str, list, tuple, set]) -> str:
-
+        if fields in ["id", "pk"]:
+            return "主键"
         if type(fields) == str:
             try:
                 field_info = model_class._meta.fields_map.get(fields)
                 field_info_fk = model_class._meta.fields_map.get(fields.rstrip("_id"))
                 if field_info:
-                    return field_info.description
+                    return field_info.description or ""
                 elif fields.endswith("_id") and field_info_fk:
-                    return field_info_fk.description
+                    return field_info_fk.description or ""
                 elif "__" in fields:
                     field_list = fields.split("__", maxsplit=1)
                     description = ""
                     description += DBModelMixin.get_field_description(model_class=model_class, fields=field_list[0])
-                    description += DBModelMixin.get_field_description(
-                        model_class=DBModelMixin._get_foreign_key_relation_class(model_class=model_class, field=field_list[0]),
-                        fields=field_list[1]
-                    )
+                    if field_list[1] in DBModelMixin.others_description:
+                        description += DBModelMixin.get_field_description(
+                            model_class=model_class,
+                            fields=field_list[1]
+                        )
+                    else:
+                        description += DBModelMixin.get_field_description(
+                            model_class=DBModelMixin._get_foreign_key_relation_class(model_class=model_class, field=field_list[0]),
+                            fields=field_list[1]
+                        )
                     return description
                 else:
-                    others_description = {
-                        "gt": "大于",
-                        "gte": "大于等于",
-                        "lt": "小于",
-                        "lte": "小于等于",
-                        "contains": "模糊搜索",
-                        "in": "范围"
-                    }
-                    return others_description.get(fields, "")
+                    return DBModelMixin.others_description.get(fields, "")
 
             except Exception:
                 return fields
@@ -102,7 +109,10 @@ class DBModelMixin:
 
     @staticmethod
     def _get_foreign_key_relation_class(model_class: Type[Model], field: str) -> Type[Model]:
-        module = inspect.getmodule(model_class, inspect.getfile(model_class))
-        res_class = getattr(module, model_class._meta.fields_map.get(field).model_name.split(".")[1])
-        return res_class
+        try:
+            module = inspect.getmodule(model_class, inspect.getfile(model_class))
+            res_class = getattr(module, model_class._meta.fields_map.get(field).model_name.split(".")[1])
+            return res_class
+        except:
+            return model_class
 

fastgenerateapi/api_view/mixin/response_mixin.py

@@ -1,54 +1,59 @@
+import time
+from io import BytesIO
 from typing import Union, Optional, Dict, Any
+from urllib.parse import quote
 
 from fastapi import HTTPException
 from fastapi.encoders import jsonable_encoder
 from pydantic import BaseModel
 
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from starlette.background import BackgroundTask
-from starlette.responses import JSONResponse
+from starlette.responses import JSONResponse, Response, StreamingResponse
 
 from fastgenerateapi.pydantic_utils.base_model import JSON_ENCODERS
 from fastgenerateapi.schemas_factory import response_factory
 
 
-# class CommonResponse(BaseModel):
-#     success: bool = True
-#     code: int = 200
-#     message: str = "请求成功"
-#     data: Union[dict, str, BaseModel] = {}
-
-
 class ResponseMixin:
 
     @staticmethod
-    def success(msg: str = "请求成功",
-                status_code: int = 200,
-                code: Optional[int] = None,
-                data: Union[BaseModel, dict, str, None] = None,
-                background: Optional[BackgroundTask] = None,
-                *args,
-                **kwargs):
+    def success(
+            msg: str = "请求成功",
+            status_code: int = 200,
+            code: Optional[int] = None,
+            data: Union[BaseModel, dict, str, None] = None,
+            background: Optional[BackgroundTask] = None,
+            *args,
+            **kwargs
+    ):
         if data is None:
             json_compatible_data = {}
         else:
             json_compatible_data = jsonable_encoder(data, custom_encoder=JSON_ENCODERS)
         if code is None:
             code = settings.app_settings.CODE_SUCCESS_DEFAULT_VALUE
-        resp = response_factory()(success=True, code=code, message=msg, data=json_compatible_data)
+        resp = response_factory()(**{
+            "success": True,
+            "code": code,
+            settings.app_settings.MESSAGE_RESPONSE_FIELD: msg,
+            "data": json_compatible_data
+        })
         kwargs.update(resp.dict())
         return JSONResponse(kwargs, status_code=status_code, background=background)
 
     @staticmethod
-    def fail(msg: str = "请求失败",
-             status_code: int = 200,
-             code: Optional[int] = None,
-             success: bool = False,
-             data: Union[BaseModel, dict, str, None] = None,
-             background: Optional[BackgroundTask] = None,
-             headers: Optional[Dict[str, Any]] = None,
-             *args,
-             **kwargs):
+    def fail(
+            msg: str = "请求失败",
+            status_code: int = 200,
+            code: Optional[int] = None,
+            # success: bool = False,
+            data: Union[BaseModel, dict, str, None] = None,
+            background: Optional[BackgroundTask] = None,
+            headers: Optional[Dict[str, Any]] = None,
+            *args,
+            **kwargs,
+    ):
 
         if data is None:
             json_compatible_data = {}
@@ -56,7 +61,12 @@ class ResponseMixin:
             json_compatible_data = jsonable_encoder(data, custom_encoder=JSON_ENCODERS)
         if code is None:
             code = settings.app_settings.CODE_FAIL_DEFAULT_VALUE
-        resp = response_factory()(success=success, code=code, message=msg, data=json_compatible_data)
+        resp = response_factory()(**{
+            "success": False,
+            "code": code,
+            settings.app_settings.MESSAGE_RESPONSE_FIELD: msg,
+            "data": json_compatible_data
+        })
         kwargs.update(resp.dict())
         return JSONResponse(
             kwargs,
@@ -66,11 +76,13 @@ class ResponseMixin:
         )
 
     @staticmethod
-    def error(msg: str = "系统繁忙，请稍后再试...",
-              status_code: int = 400,
-              headers: Optional[Dict[str, Any]] = None,
-              *args,
-              **kwargs):
+    def error(
+            msg: str = "系统繁忙，请稍后再试...",
+            status_code: int = 400,
+            headers: Optional[Dict[str, Any]] = None,
+            *args,
+            **kwargs,
+    ):
 
         raise HTTPException(
             status_code=status_code,
@@ -78,3 +90,38 @@ class ResponseMixin:
             headers=headers or {"Access-Control-Allow-Origin": '*'},
         )
 
+    @staticmethod
+    def stream(
+            bytes_io: BytesIO,
+            file_name: Optional[str] = None,
+            media_type: Optional[str] = None,
+            is_xlsx: Optional[bool] = None,
+            is_docx: Optional[bool] = None,
+            is_pdf: Optional[bool] = None,
+    ) -> StreamingResponse:
+        """
+
+        :param bytes_io: io.BytesIO()
+        :param file_name: 文件名称
+        :param media_type: 优先度大于其他参数
+        :param is_xlsx: 自动设置media_type
+        :param is_docx: 自动设置media_type
+        :param is_pdf: 自动设置media_type
+        :return:  StreamingResponse
+        """
+
+        if not media_type:
+            if is_xlsx:
+                media_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8"
+            elif is_docx:
+                media_type = "application/vnd.openxmlformats-officedocument.wordprocessingml.document;charset=UTF-8"
+            elif is_pdf:
+                media_type = "application/pdf"
+        headers = {}
+        if file_name:
+            headers["Content-Disposition"] = f"attachment; filename={quote(file_name, safe='/:?=&')}"
+        return StreamingResponse(
+            bytes_io,
+            media_type= media_type,
+            headers=headers,
+        )