fastgenerateapi 1.1.8__tar.gz → 1.1.10__tar.gz

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/PKG-INFO

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

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/__version__.py

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

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/base_view.py

@@ -78,8 +78,11 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             return self.error(msg="relation_model_class not allow None")
         return self.get_active_queryset(self.relation_model_class)
 
-    async def get_object(self, pk, is_with_prefetch):
-        queryset = self.queryset.filter(id=pk)
+    async def get_object(self, pk, model_class=None, is_with_prefetch=False):
+        if model_class:
+            queryset = self.get_active_queryset(model_class).filter(id=pk)
+        else:
+            queryset = self.queryset.filter(id=pk)
         if is_with_prefetch:
             queryset = queryset.prefetch_related(*self.prefetch_related_fields.keys())
         model = await queryset.first()

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/create_view.py

@@ -1,5 +1,7 @@
 from typing import Optional, Type, Union, Any
 
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from pydantic import BaseModel
 from starlette.requests import Request
@@ -73,10 +75,12 @@ class CreateView(BaseView, SaveMixin):
         async def route(
                 request_data: self.create_schema,  # type: ignore
                 request: Request,
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.create(
                 request_data=request_data,
                 request=request,
+                token=token,
                 *args,
                 **kwargs
             )

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/delete_filter_view.py

@@ -1,6 +1,7 @@
 from typing import Optional, Type, Any, Union
 
 from fastapi import Query, Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from starlette.requests import Request
 from starlette.responses import JSONResponse
@@ -9,7 +10,7 @@ from tortoise.transactions import atomic
 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.schemas_factory import response_factory, get_one_schema_factory
 from fastgenerateapi.settings.all_settings import settings
 
 
@@ -34,11 +35,13 @@ class DeleteFilterView(BaseView):
                 request: Request,
                 search: str = Query(default="", description="搜索"),
                 filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields)),
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             await self.destroy_filter(
                 search=search,
                 filters=filters,
                 request=request,
+                token=token,
                 *args, **kwargs
             )
             return self.success(msg="删除成功")
@@ -47,8 +50,10 @@ class DeleteFilterView(BaseView):
     def _handler_destroy_filter_settings(self):
         if self.delete_filter_route:
             return
+        if not hasattr(self, "get_one_schema"):
+            self.get_one_schema = get_one_schema_factory(model_class=self.model_class)
         if not hasattr(self, "get_one_response_schema"):
-            self.get_one_response_schema = response_factory(None, name="GetOne")
+            self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
         doc = self.destroy_filter.__doc__
         summary = doc.strip().split("\n")[0] if doc else "Delete Filter"
         path = f"/{settings.app_settings.ROUTER_FILTER_DELETE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/delete_tree_view.py

@@ -1,6 +1,8 @@
 import time
 from typing import Optional, Type, Any, Union
 
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from pydantic import BaseModel
 from starlette.requests import Request
@@ -10,7 +12,7 @@ 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.schemas_factory import response_factory
+from fastgenerateapi.schemas_factory import response_factory, get_one_schema_factory
 from fastgenerateapi.settings.all_settings import settings
 
 
@@ -61,10 +63,12 @@ class DeleteTreeView(BaseView):
         async def route(
                 request_data: self.delete_tree_schema,  # type: ignore
                 request: Request,
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             await self.destroy_tree(
                 request_data=request_data,
                 request=request,
+                token=token,
                 *args, **kwargs
             )
             return self.success(msg="删除成功")
@@ -73,8 +77,10 @@ class DeleteTreeView(BaseView):
     def _handler_delete_tree_settings(self):
         if self.delete_tree_route:
             return
+        if not hasattr(self, "get_one_schema"):
+            self.get_one_schema = get_one_schema_factory(model_class=self.model_class)
         if not hasattr(self, "get_one_response_schema"):
-            self.get_one_response_schema = response_factory(None, name="GetOne")
+            self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
         doc = self.destroy_tree.__doc__
         summary = doc.strip().split("\n")[0] if doc else "Delete Tree"
         path = f"/{settings.app_settings.ROUTER_RECURSION_DELETE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/delete_view.py

@@ -1,6 +1,8 @@
 import time
 from typing import Optional, Type, Any, Union
 
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from pydantic import BaseModel
 from starlette.requests import Request
@@ -10,7 +12,7 @@ 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.schemas_factory import response_factory
+from fastgenerateapi.schemas_factory import response_factory, get_one_schema_factory
 from fastgenerateapi.settings.all_settings import settings
 
 
@@ -51,10 +53,12 @@ class DeleteView(BaseView):
         async def route(
                 request_data: self.delete_schema,  # type: ignore
                 request: Request,
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             await self.destroy(
                 request_data=request_data,
                 request=request,
+                token=token,
                 *args, **kwargs
             )
             return self.success(msg="删除成功")
@@ -63,8 +67,10 @@ class DeleteView(BaseView):
     def _handler_delete_settings(self):
         if not self.delete_route:
             return
+        if not hasattr(self, "get_one_schema"):
+            self.get_one_schema = get_one_schema_factory(model_class=self.model_class)
         if not hasattr(self, "get_one_response_schema"):
-            self.get_one_response_schema = response_factory(None, name="GetOne")
+            self.get_one_response_schema = response_factory(self.get_one_schema, name="GetOne")
         doc = self.destroy.__doc__
         summary = doc.strip().split("\n")[0] if doc else "Delete All"
         path = f"/{settings.app_settings.ROUTER_DELETE_SUFFIX_FIELD}" if settings.app_settings.ROUTER_WHETHER_ADD_SUFFIX else ""

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/get_all_view.py

@@ -1,6 +1,7 @@
 from typing import Union, Optional, Type, cast, List, Any, Callable, Coroutine
 
 from fastapi import Depends, Query
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from fastapi_cache import JsonCoder
 from fastapi_cache.decorator import cache
@@ -56,7 +57,7 @@ class GetAllView(BaseView, GetMixin):
         处理search搜索；处理筛选字段；处理外键预加载；处理排序
         """
         queryset = self.search_controller.query(queryset=self.queryset, value=search)
-        queryset = await self.filter_queryset(queryset, filters)
+        queryset = await self.filter_queryset(queryset, filters, *args, **kwargs)
         queryset = self.filter_controller.query(queryset=queryset, values=filters)
         queryset = queryset.prefetch_related(*self.prefetch_related_fields.keys())
         if self.order_by_fields:
@@ -66,7 +67,7 @@ class GetAllView(BaseView, GetMixin):
 
         return queryset
 
-    async def filter_queryset(self, queryset: QuerySet, filters: dict) -> QuerySet:
+    async def filter_queryset(self, queryset: QuerySet, filters: dict, *args, **kwargs) -> QuerySet:
         """
         处理filters
             example： value = filters.pop(value, None)   queryset = queryset.filter(field=value+string)
@@ -84,6 +85,7 @@ class GetAllView(BaseView, GetMixin):
             queryset: QuerySet,
             paginator=None,
             schema: Type[BaseModel] = None,
+            name: str = "",  # 当使用fields时，需要输入名称用于自动生成schema
             fields: List[Union[str, tuple]] = None,
             *args, **kwargs
     ):
@@ -117,10 +119,10 @@ class GetAllView(BaseView, GetMixin):
         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 get_list_schema_factory(schema, name)(**{settings.app_settings.LIST_RESPONSE_FIELD: data_list})
             return self.get_list_schema(**{settings.app_settings.LIST_RESPONSE_FIELD: data_list})
         if schema or fields:
-            return get_page_schema_factory()(**{
+            return get_page_schema_factory(schema, name)(**{
                 settings.app_settings.CURRENT_PAGE_FIELD: current_num,
                 settings.app_settings.PAGE_SIZE_FIELD: page_size,
                 settings.app_settings.TOTAL_SIZE_FIELD: count,
@@ -144,12 +146,14 @@ class GetAllView(BaseView, GetMixin):
                 paginator=Depends(paginator_deps()),
                 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)),
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.get_all(
                 paginator=paginator,
                 search=search,
                 filters=filters,
                 request=request,
+                token=token,
                 *args,
                 **kwargs
             )

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/get_one_view.py

@@ -1,5 +1,7 @@
 from typing import Any, Union, Optional, Type
 
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from fastapi_cache import JsonCoder
 from fastapi_cache.decorator import cache
@@ -36,7 +38,7 @@ class GetOneView(BaseView, GetMixin):
     """
 
     async def get_one(self, pk: str, *args, **kwargs):
-        model = await self.get_object(pk, self.is_with_prefetch)
+        model = await self.get_object(pk, is_with_prefetch=self.is_with_prefetch)
         if self.is_with_prefetch:
             await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields, *args, **kwargs)
 
@@ -50,10 +52,12 @@ class GetOneView(BaseView, GetMixin):
         async def route(
                 pk: str,
                 request: Request,
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.get_one(
                 pk=pk,
                 request=request,
+                token=token,
                 *args, **kwargs
             )
             return self.success(data=data)

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/get_relation_view.py

@@ -1,6 +1,7 @@
 from typing import Union, Optional, Type, cast, List, Any
 
 from fastapi import Depends, Query
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from pydantic import BaseModel
 from starlette.requests import Request
@@ -160,6 +161,7 @@ class GetRelationView(BaseView):
                 filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields)),
                 relation_filters: dict = Depends(
                     filter_params_deps(model_class=self.relation_model_class, fields=self.relation_filter_fields)),
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.get_relation(
                 pk=pk,
@@ -168,6 +170,7 @@ class GetRelationView(BaseView):
                 filters=filters,
                 relation_filters=relation_filters,
                 request=request,
+                token=token,
                 *args,
                 **kwargs
             )

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/get_tree_view.py

@@ -1,6 +1,7 @@
 from typing import Union, Optional, Type, cast, List, Any, Callable, Coroutine
 
 from fastapi import Depends, Query
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from fastapi_cache import JsonCoder
 from fastapi_cache.decorator import cache
@@ -157,12 +158,14 @@ class GetTreeView(BaseView):
                 search: str = Query(default="", description="搜索"),
                 node_id: Optional[str] = Depends(tree_params_deps()),
                 filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields)),
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.get_tree(
                 search=search,
                 node_id=node_id,
                 filters=filters,
                 request=request,
+                token=token,
                 *args,
                 **kwargs
             )

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/mixin/base_mixin.py

@@ -162,4 +162,4 @@ class BaseMixin(Generic[T], APIRouter, ABC):
                     route.path == f"{self.prefix}{path}"  # type: ignore
                     and route.methods == methods_  # type: ignore
             ):
-                self.routes.remove(route)
+                self.routes.remove(route) # type: ignore

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/switch_view.py

@@ -1,5 +1,7 @@
-from typing import List, Any
+from typing import List, Any, Optional
 
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from starlette.requests import Request
 from starlette.responses import JSONResponse
@@ -45,8 +47,12 @@ class SwitchView(BaseView):
         return self.get_one_schema.from_orm(model)
 
     def _switch_decorator(self, filed, *args: Any, **kwargs: Any) -> DecoratedCallable:
-        async def route(pk: str, request: Request) -> JSONResponse:
-            data = await self.switch(pk=pk, request=request, filed=filed, *args, **kwargs)
+        async def route(
+                pk: str,
+                request: Request,
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
+        ) -> JSONResponse:
+            data = await self.switch(pk=pk, request=request, filed=filed, token=token, *args, **kwargs)
             return self.success(data=data)
         return route
 

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/update_relation_view.py

@@ -1,5 +1,7 @@
 from typing import Optional, Type, Union, Any
 
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from pydantic import BaseModel
 from starlette.requests import Request
@@ -55,11 +57,13 @@ class UpdateRelationView(BaseView, SaveMixin):
                 pk: str,
                 request_data: self.update_relation_schema,  # type: ignore
                 request: Request,
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             await self.update_relation(
                 pk=pk,
                 request_data=request_data,
                 request=request,
+                token=token,
                 *args, **kwargs
             )
             return self.success()

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/api_view/update_view.py

@@ -1,5 +1,7 @@
 from typing import Optional, Type, Union, Any
 
+from fastapi import Depends
+from fastapi.security import OAuth2PasswordBearer
 from fastapi.types import DecoratedCallable
 from starlette.requests import Request
 from starlette.responses import JSONResponse
@@ -63,11 +65,13 @@ class UpdateView(BaseView, SaveMixin):
                 pk: str,
                 request_data: self.update_schema,  # type: ignore
                 request: Request,
+                token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.update(
                 pk=pk,
                 request_data=request_data,
                 request=request,
+                token=token,
                 *args, **kwargs
             )
             return self.success(data=data)

fastgenerateapi-1.1.10/fastgenerateapi/channel/connection_manager.py

@@ -0,0 +1,30 @@
+from typing import Dict
+
+from starlette.websockets import WebSocket
+
+
+class ConnectionManager:
+    active_connections: Dict[str, WebSocket] = {}
+    active_group_connections: Dict[str, Dict[str, WebSocket]] = {}
+
+    @classmethod
+    def add_connection(cls, user_id: str, websocket: WebSocket):
+        cls.active_connections[user_id] = websocket
+
+    @classmethod
+    def del_connection(cls, user_id: str):
+        if user_id in cls.active_connections:
+            del cls.active_connections[user_id]
+
+    @classmethod
+    def add_group_connection(cls, group_id: str, user_id: str, connection: WebSocket):
+        cls.active_group_connections.setdefault(group_id, {})[user_id] = connection
+
+    @classmethod
+    def del_group_connection(cls, group_id: str, user_id: str):
+        if group_id in cls.active_group_connections:
+            user_dict = cls.active_group_connections[group_id]
+            if user_id in user_dict:
+                del user_dict[user_id]
+                if not user_dict:
+                    del cls.active_group_connections[group_id]

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/channel/consumer.py

@@ -1,17 +1,15 @@
-import _ctypes
 from typing import List, Union
 
-import aioredis
+# from _ctypes import PyObj_FromPtr
 from starlette.endpoints import WebSocketEndpoint
 
+from fastgenerateapi.channel.connection_manager import ConnectionManager
+
 
 class Consumer(WebSocketEndpoint):
     """
     群聊
-    redis_conn:  must
-    使用 aioredis
     """
-    redis_conn: aioredis.Redis
     encoding = "json"
     group_id = None
     user_id = None
@@ -22,9 +20,13 @@ class Consumer(WebSocketEndpoint):
 
         # 用户输入名称
         self.group_id = websocket.path_params.get("group_id")
-        self.user_id = websocket.query_params.get("user_id")
+        self.user_id = await self.get_user_id(websocket)
         await self.group_add(websocket, self.group_id, self.user_id)
-        await self.group_send(self.group_id, {"msg": f"{self.user_id}-加入了聊天室"})
+        # await self.group_send(self.group_id, {"msg": f"{self.user_id}-加入了聊天室"})
+
+    @staticmethod
+    async def get_user_id(websocket):
+        return websocket.query_params.get("user_id")
 
     # 收消息后自动转发
     async def on_receive(self, websocket, data):
@@ -34,18 +36,27 @@ class Consumer(WebSocketEndpoint):
     # 断开 删除
     async def on_disconnect(self, websocket, close_code):
         if self.group_id and self.user_id:
-            await self.redis_conn.hdel(self.group_id, self.user_id)
+            ConnectionManager.del_group_connection(self.group_id, self.user_id)
         pass
 
+    async def check_args(self, group_id, user_id):
+        """
+        用于检查数据是否有效
+        :param group_id:
+        :param user_id:
+        :return:
+        """
+        return True
+
     # 添加组
     async def group_add(self, websocket, group_id, user_key):
-        if not self.redis_conn:
-            await self.error(websocket, code=500, msg="redis未设置")
         if not group_id:
             await self.error(websocket, code=422, msg="未获取到组信息")
         if not user_key:
             await self.error(websocket, code=422, msg="未获取到用户信息")
-        await self.redis_conn.hset(group_id, user_key, id(websocket))
+        if not await self.check_args(group_id, user_key):
+            await self.error(websocket, code=422, msg="无连接权限")
+        ConnectionManager.add_group_connection(group_id, user_key, websocket)
 
     # 群发消息
     @classmethod
@@ -59,17 +70,11 @@ class Consumer(WebSocketEndpoint):
         :param exclude: 默认True排除自己；[int] 时可选排除其他人
         :return:
         """
-        # 先循环 告诉之前的用户有新用户加入了
-        result = await cls.redis_conn.hgetall(group_id)
+        result = ConnectionManager.active_group_connections.get(group_id, {})
         if type(exclude) == bool:
             exclude = [user_id] if user_id and exclude else []
-        for key, value in result.items():
-            if int(value) in exclude:
-                continue
-            try:
-                websocket = _ctypes.PyObj_FromPtr(int(value))
-            except Exception:
-                await cls.redis_conn.hdel(group_id, key)
+        for user_id, websocket in result.items():
+            if user_id in exclude:
                 continue
             await websocket.send_json({
                 "code": code,

fastgenerateapi-1.1.10/fastgenerateapi/channel/websocket_view.py

@@ -0,0 +1,83 @@
+from typing import Union
+
+from starlette.websockets import WebSocket
+
+from fastgenerateapi.api_view.base_view import BaseView
+from fastgenerateapi.channel.connection_manager import ConnectionManager
+from fastgenerateapi.controller.ws_controller import WsController
+from fastgenerateapi.data_type.data_type import DEPENDENCIES
+
+
+class WebsocketView(BaseView):
+    """
+    客户端与服务器之间通信
+    """
+    websocket_route: Union[bool, DEPENDENCIES] = True
+
+    def _handler_websocket_settings(self):
+        self.ws_summary = WsController(self, self._get_cls_ws_func())
+        for ws_router in self.ws_summary.ws_router_data:
+            self._add_api_websocket_route(
+                f"/{ws_router.path}",
+                getattr(self, ws_router.func_name),
+                dependencies=ws_router.dependencies,
+            )
+
+    @classmethod
+    async def accept(cls, user_id:str, websocket: WebSocket):
+        await websocket.accept()
+        ConnectionManager.add_connection(user_id=user_id, websocket=websocket)
+
+        return websocket
+
+    @classmethod
+    async def send(cls, user_id, data, code=200):
+        """
+        群发送消息
+        :param user_id: 用户id
+        :param data: 发送的数据
+        :param code: 状态码
+        :return:
+        """
+        if not user_id or not data:
+            return False
+
+        websocket = ConnectionManager.active_connections.get(user_id)
+        if not websocket:
+            return False
+        await websocket.send_json({
+            "code": code,
+            "from": user_id,
+            # "message": "请求成功",
+            "data": data
+        })
+
+        return True
+
+    @classmethod
+    async def group_send(cls, user_id_list, data, code=200):
+        """
+        群发送消息
+        :param user_id_list: 用户id列表
+        :param data: 发送的数据
+        :param code: 状态码
+        :return:
+        """
+        if not user_id_list or not data:
+            return [], user_id_list
+        success_user_id_list = []
+        fail_user_id_list = []
+        for user_id in user_id_list:
+            websocket = ConnectionManager.active_connections.get(user_id)
+            if not websocket:
+                fail_user_id_list.append(user_id)
+                continue
+            await websocket.send_json({
+                "code": code,
+                "from": user_id,
+                # "message": "请求成功",
+                "data": data
+            })
+            success_user_id_list.append(user_id)
+
+        return success_user_id_list, fail_user_id_list

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/my_fields/enum_field.py

@@ -1,4 +1,4 @@
-from enum import IntEnum
+from enum import IntEnum, Enum
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -36,7 +36,8 @@ class IntEnumField(IntEnumFieldInstance):
 
     def __init__(self, enum_list: List[any], start_num=0, **kwargs: Any) -> None:
         self.enum_list = enum_list
-        self.description = kwargs.get("description", "") + " >> " + self.get_description(enum_list)
+        self.description = kwargs.get("description", "") + " >> " + self.get_description(enum_list, start_num)
+        kwargs["description"] = self.description
         super().__init__(enum_type=self.create_enum(enum_list, start_num=start_num), **kwargs)
 
     @property
@@ -66,15 +67,16 @@ class IntEnumField(IntEnumFieldInstance):
         if value is not None:
             value = int(value)  # pylint: disable=E1102
         self.validate(value)
-        return IntEnumClass(value, self.enum_list)
+        return value
 
-    def get_description(self, enum_list):
+    @staticmethod
+    def get_description(enum_list, start_num=0):
         description = ""
-        for index, val in enumerate(enum_list, 1):
+        for index, val in enumerate(enum_list, start_num):
             description += f"{index}:{val};"
         return description
 
-    def create_enum(self, enum_list, start_num=0):
+    def create_enum(self, enum_list, start_num=0) -> Type[IntEnum]:
         # 创建枚举类的成员字典，确保值是唯一的
 
         members = {self.number_to_words(name): name for name, _ in enumerate(enum_list, start_num)}

{fastgenerateapi-1.1.8 → fastgenerateapi-1.1.10}/fastgenerateapi/schemas_factory/filter_schema_factory.py

@@ -32,7 +32,11 @@ def filter_schema_factory(model_class: Type[Model], fields: list[str, tuple[str,
                 ))
         })
 
-    filter_params_model: Type[BaseModel] = create_model("CommonFilterParams", **model_fields, __config__=model_config)
+    filter_params_model: Type[BaseModel] = create_model(
+        model_class.__name__+"CommonFilterParams",
+        **model_fields,
+        __config__=model_config
+    )
 
     return filter_params_model