fastgenerateapi 0.0.28__py2.py3-none-any.whl → 1.1.7__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, 28)
+VERSION = (1, 1, 7)
 
 __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,18 +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
     """
@@ -44,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搜索；处理筛选字段；处理外键预加载；处理排序
         """
@@ -140,8 +142,8 @@ class GetAllView(BaseView, GetMixin):
         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,
@@ -159,7 +161,7 @@ class GetAllView(BaseView, GetMixin):
         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.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)

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,42 +1,32 @@
+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, Response
+from starlette.responses import JSONResponse, Response, StreamingResponse
 
 from fastgenerateapi.pydantic_utils.base_model import JSON_ENCODERS
 from fastgenerateapi.schemas_factory import response_factory
 
 
-# class CustomSuccessJsonResponse(JSONResponse):
-#     def __init__(self, content: Any, *args, **kwargs):
-#         if not isinstance(content, Response) or not (hasattr(content, "success") or hasattr(content, "code")):
-#             if isinstance(content, dict) and ("success" in content or "code" in content):
-#                 super().__init__(content, *args, **kwargs)
-#             else:
-#                 content = response_factory()(**{
-#                     "success": True,
-#                     "code": settings.app_settings.CODE_SUCCESS_DEFAULT_VALUE,
-#                     settings.app_settings.MESSAGE_RESPONSE_FIELD: "请求成功",
-#                     "data": content
-#                 })
-#                 super().__init__(content.dict(), *args, **kwargs)
-
-
 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:
@@ -53,15 +43,17 @@ class ResponseMixin:
         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 = {}
@@ -84,14 +76,52 @@ 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,
             detail=msg,
             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,
+        )