style: introduce ruff as linter and formatter (#1356)

* style: remove necessary imports

* style: fix F841

* style: fix F401

* style: fix F811

* style: fix E402

* style: fix E721

* style: fix E722

* style: fix E722

* style: fix F541

* style: ruff format

* style: all passed

* style: add ruff in deps

* style: more ignores in ruff.toml

* style: add pre-commit

pkg/api/http/controller/group.py

@@ -13,6 +13,7 @@ from ....core import app
 preregistered_groups: list[type[RouterGroup]] = []
 """RouterGroup 的预注册列表"""
 
+
 def group_class(name: str, path: str) -> None:
     """注册一个 RouterGroup"""
 
@@ -27,12 +28,12 @@ def group_class(name: str, path: str) -> None:
 
 class AuthType(enum.Enum):
     """认证类型"""
+
     NONE = 'none'
     USER_TOKEN = 'user-token'
 
 
 class RouterGroup(abc.ABC):
-
     name: str
 
     path: str
@@ -49,17 +50,24 @@ class RouterGroup(abc.ABC):
     async def initialize(self) -> None:
         pass
 
-    def route(self, rule: str, auth_type: AuthType = AuthType.USER_TOKEN, **options: typing.Any) -> typing.Callable[[RouteCallable], RouteCallable]:  # decorator
+    def route(
+        self,
+        rule: str,
+        auth_type: AuthType = AuthType.USER_TOKEN,
+        **options: typing.Any,
+    ) -> typing.Callable[[RouteCallable], RouteCallable]:  # decorator
         """注册一个路由"""
+
         def decorator(f: RouteCallable) -> RouteCallable:
             nonlocal rule
             rule = self.path + rule
 
             async def handler_error(*args, **kwargs):
-
                 if auth_type == AuthType.USER_TOKEN:
                     # 从Authorization头中获取token
-                    token = quart.request.headers.get('Authorization', '').replace('Bearer ', '')
+                    token = quart.request.headers.get('Authorization', '').replace(
+                        'Bearer ', ''
+                    )
 
                     if not token:
                         return self.http_status(401, -1, '未提供有效的用户令牌')
@@ -75,11 +83,11 @@ class RouterGroup(abc.ABC):
 
                 try:
                     return await f(*args, **kwargs)
-                except Exception as e:  # 自动 500
+                except Exception:  # 自动 500
                     traceback.print_exc()
                     # return self.http_status(500, -2, str(e))
                     return self.http_status(500, -2, 'internal server error')
-                
+
             new_f = handler_error
             new_f.__name__ = (self.name + rule).replace('/', '__')
             new_f.__doc__ = f.__doc__
@@ -91,20 +99,24 @@ class RouterGroup(abc.ABC):
 
     def success(self, data: typing.Any = None) -> quart.Response:
         """返回一个 200 响应"""
-        return quart.jsonify({
-            'code': 0,
-            'msg': 'ok',
-            'data': data,
-        })
-    
+        return quart.jsonify(
+            {
+                'code': 0,
+                'msg': 'ok',
+                'data': data,
+            }
+        )
+
     def fail(self, code: int, msg: str) -> quart.Response:
         """返回一个异常响应"""
 
-        return quart.jsonify({
-            'code': code,
-            'msg': msg,
-        })
-    
+        return quart.jsonify(
+            {
+                'code': code,
+                'msg': msg,
+            }
+        )
+
     def http_status(self, status: int, code: int, msg: str) -> quart.Response:
         """返回一个指定状态码的响应"""
         return self.fail(code, msg), status

pkg/api/http/controller/groups/logs.py

@@ -1,32 +1,29 @@
 from __future__ import annotations
 
-import traceback
 
 import quart
 
-from .....core import app
 from .. import group
 
 
 @group.group_class('logs', '/api/v1/logs')
 class LogsRouterGroup(group.RouterGroup):
-    
     async def initialize(self) -> None:
         @self.route('', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
         async def _() -> str:
-
             start_page_number = int(quart.request.args.get('start_page_number', 0))
             start_offset = int(quart.request.args.get('start_offset', 0))
 
-            logs_str, end_page_number, end_offset = self.ap.log_cache.get_log_by_pointer(
-                start_page_number=start_page_number,
-                start_offset=start_offset
+            logs_str, end_page_number, end_offset = (
+                self.ap.log_cache.get_log_by_pointer(
+                    start_page_number=start_page_number, start_offset=start_offset
+                )
             )
 
             return self.success(
                 data={
-                    "logs": logs_str,
-                    "end_page_number": end_page_number,
-                    "end_offset": end_offset
+                    'logs': logs_str,
+                    'end_page_number': end_page_number,
+                    'end_offset': end_offset,
                 }
             )

pkg/api/http/controller/groups/pipelines.py

@@ -3,46 +3,41 @@ from __future__ import annotations
 import quart
 
 from .. import group
-from .....entity.persistence import pipeline
 
 
 @group.group_class('pipelines', '/api/v1/pipelines')
 class PipelinesRouterGroup(group.RouterGroup):
-    
     async def initialize(self) -> None:
-        
         @self.route('', methods=['GET', 'POST'])
         async def _() -> str:
             if quart.request.method == 'GET':
-                return self.success(data={
-                    'pipelines': await self.ap.pipeline_service.get_pipelines()
-                })
+                return self.success(
+                    data={'pipelines': await self.ap.pipeline_service.get_pipelines()}
+                )
             elif quart.request.method == 'POST':
                 json_data = await quart.request.json
 
-                pipeline_uuid = await self.ap.pipeline_service.create_pipeline(json_data)
+                pipeline_uuid = await self.ap.pipeline_service.create_pipeline(
+                    json_data
+                )
 
-                return self.success(data={
-                    'uuid': pipeline_uuid
-                })
+                return self.success(data={'uuid': pipeline_uuid})
 
         @self.route('/_/metadata', methods=['GET'])
         async def _() -> str:
-            return self.success(data={
-                'configs': await self.ap.pipeline_service.get_pipeline_metadata()
-            })
+            return self.success(
+                data={'configs': await self.ap.pipeline_service.get_pipeline_metadata()}
+            )
 
         @self.route('/<pipeline_uuid>', methods=['GET', 'PUT', 'DELETE'])
         async def _(pipeline_uuid: str) -> str:
             if quart.request.method == 'GET':
                 pipeline = await self.ap.pipeline_service.get_pipeline(pipeline_uuid)
-                
+
                 if pipeline is None:
                     return self.http_status(404, -1, 'pipeline not found')
 
-                return self.success(data={
-                    'pipeline': pipeline
-                })
+                return self.success(data={'pipeline': pipeline})
             elif quart.request.method == 'PUT':
                 json_data = await quart.request.json
 
@@ -53,4 +48,3 @@ class PipelinesRouterGroup(group.RouterGroup):
                 await self.ap.pipeline_service.delete_pipeline(pipeline_uuid)
 
                 return self.success()
-

pkg/api/http/controller/groups/platform/adapters.py

@@ -5,29 +5,31 @@ from ... import group
 
 @group.group_class('adapters', '/api/v1/platform/adapters')
 class AdaptersRouterGroup(group.RouterGroup):
-
     async def initialize(self) -> None:
         @self.route('', methods=['GET'])
         async def _() -> str:
-            return self.success(data={
-                'adapters': self.ap.platform_mgr.get_available_adapters_info()
-            })
-        
+            return self.success(
+                data={'adapters': self.ap.platform_mgr.get_available_adapters_info()}
+            )
+
         @self.route('/<adapter_name>', methods=['GET'])
         async def _(adapter_name: str) -> str:
-            adapter_info = self.ap.platform_mgr.get_available_adapter_info_by_name(adapter_name)
+            adapter_info = self.ap.platform_mgr.get_available_adapter_info_by_name(
+                adapter_name
+            )
 
             if adapter_info is None:
                 return self.http_status(404, -1, 'adapter not found')
 
-            return self.success(data={
-                'adapter': adapter_info
-            })
-        
+            return self.success(data={'adapter': adapter_info})
+
         @self.route('/<adapter_name>/icon', methods=['GET'])
         async def _(adapter_name: str) -> quart.Response:
-
-            adapter_manifest = self.ap.platform_mgr.get_available_adapter_manifest_by_name(adapter_name)
+            adapter_manifest = (
+                self.ap.platform_mgr.get_available_adapter_manifest_by_name(
+                    adapter_name
+                )
+            )
 
             if adapter_manifest is None:
                 return self.http_status(404, -1, 'adapter not found')
@@ -37,4 +39,4 @@ class AdaptersRouterGroup(group.RouterGroup):
             if icon_path is None:
                 return self.http_status(404, -1, 'icon not found')
 
-            return await quart.send_file(icon_path)
+            return await quart.send_file(icon_path)

pkg/api/http/controller/groups/platform/bots.py

@@ -5,34 +5,27 @@ from ... import group
 
 @group.group_class('bots', '/api/v1/platform/bots')
 class BotsRouterGroup(group.RouterGroup):
-
     async def initialize(self) -> None:
         @self.route('', methods=['GET', 'POST'])
         async def _() -> str:
             if quart.request.method == 'GET':
-                return self.success(data={
-                    'bots': await self.ap.bot_service.get_bots()
-                })
+                return self.success(data={'bots': await self.ap.bot_service.get_bots()})
             elif quart.request.method == 'POST':
                 json_data = await quart.request.json
                 bot_uuid = await self.ap.bot_service.create_bot(json_data)
-                return self.success(data={
-                    'uuid': bot_uuid
-                })
-        
+                return self.success(data={'uuid': bot_uuid})
+
         @self.route('/<bot_uuid>', methods=['GET', 'PUT', 'DELETE'])
         async def _(bot_uuid: str) -> str:
             if quart.request.method == 'GET':
                 bot = await self.ap.bot_service.get_bot(bot_uuid)
                 if bot is None:
                     return self.http_status(404, -1, 'bot not found')
-                return self.success(data={
-                    'bot': bot
-                })
+                return self.success(data={'bot': bot})
             elif quart.request.method == 'PUT':
                 json_data = await quart.request.json
                 await self.ap.bot_service.update_bot(bot_uuid, json_data)
                 return self.success()
             elif quart.request.method == 'DELETE':
                 await self.ap.bot_service.delete_bot(bot_uuid)
-                return self.success()
+                return self.success()

pkg/api/http/controller/groups/plugins.py

@@ -1,17 +1,14 @@
 from __future__ import annotations
 
 
-import traceback
-
 import quart
 
-from .....core import app, taskmgr
+from .....core import taskmgr
 from .. import group
 
 
 @group.group_class('plugins', '/api/v1/plugins')
 class PluginsRouterGroup(group.RouterGroup):
-
     async def initialize(self) -> None:
         @self.route('', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
         async def _() -> str:
@@ -19,63 +16,69 @@ class PluginsRouterGroup(group.RouterGroup):
 
             plugins_data = [plugin.model_dump() for plugin in plugins]
 
-            return self.success(data={
-                'plugins': plugins_data
-            })
-        
-        @self.route('/<author>/<plugin_name>/toggle', methods=['PUT'], auth_type=group.AuthType.USER_TOKEN)
+            return self.success(data={'plugins': plugins_data})
+
+        @self.route(
+            '/<author>/<plugin_name>/toggle',
+            methods=['PUT'],
+            auth_type=group.AuthType.USER_TOKEN,
+        )
         async def _(author: str, plugin_name: str) -> str:
             data = await quart.request.json
             target_enabled = data.get('target_enabled')
             await self.ap.plugin_mgr.update_plugin_switch(plugin_name, target_enabled)
             return self.success()
-        
-        @self.route('/<author>/<plugin_name>/update', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
+
+        @self.route(
+            '/<author>/<plugin_name>/update',
+            methods=['POST'],
+            auth_type=group.AuthType.USER_TOKEN,
+        )
         async def _(author: str, plugin_name: str) -> str:
             ctx = taskmgr.TaskContext.new()
             wrapper = self.ap.task_mgr.create_user_task(
                 self.ap.plugin_mgr.update_plugin(plugin_name, task_context=ctx),
-                kind="plugin-operation",
-                name=f"plugin-update-{plugin_name}",
-                label=f"更新插件 {plugin_name}",
-                context=ctx
+                kind='plugin-operation',
+                name=f'plugin-update-{plugin_name}',
+                label=f'更新插件 {plugin_name}',
+                context=ctx,
             )
-            return self.success(data={
-                'task_id': wrapper.id
-            })
-        
-        @self.route('/<author>/<plugin_name>', methods=['GET', 'DELETE'], auth_type=group.AuthType.USER_TOKEN)
+            return self.success(data={'task_id': wrapper.id})
+
+        @self.route(
+            '/<author>/<plugin_name>',
+            methods=['GET', 'DELETE'],
+            auth_type=group.AuthType.USER_TOKEN,
+        )
         async def _(author: str, plugin_name: str) -> str:
             if quart.request.method == 'GET':
                 plugin = self.ap.plugin_mgr.get_plugin(author, plugin_name)
                 if plugin is None:
                     return self.http_status(404, -1, 'plugin not found')
-                return self.success(data={
-                    'plugin': plugin.model_dump()
-                })
+                return self.success(data={'plugin': plugin.model_dump()})
             elif quart.request.method == 'DELETE':
                 ctx = taskmgr.TaskContext.new()
                 wrapper = self.ap.task_mgr.create_user_task(
                     self.ap.plugin_mgr.uninstall_plugin(plugin_name, task_context=ctx),
-                    kind="plugin-operation",
+                    kind='plugin-operation',
                     name=f'plugin-remove-{plugin_name}',
                     label=f'删除插件 {plugin_name}',
-                    context=ctx
+                    context=ctx,
                 )
 
-                return self.success(data={
-                    'task_id': wrapper.id
-                })
-            
-        @self.route('/<author>/<plugin_name>/config', methods=['GET', 'PUT'], auth_type=group.AuthType.USER_TOKEN)
+                return self.success(data={'task_id': wrapper.id})
+
+        @self.route(
+            '/<author>/<plugin_name>/config',
+            methods=['GET', 'PUT'],
+            auth_type=group.AuthType.USER_TOKEN,
+        )
         async def _(author: str, plugin_name: str) -> quart.Response:
             plugin = self.ap.plugin_mgr.get_plugin(author, plugin_name)
             if plugin is None:
                 return self.http_status(404, -1, 'plugin not found')
             if quart.request.method == 'GET':
-                return self.success(data={
-                    'config': plugin.plugin_config
-                })
+                return self.success(data={'config': plugin.plugin_config})
             elif quart.request.method == 'PUT':
                 data = await quart.request.json
 
@@ -88,21 +91,21 @@ class PluginsRouterGroup(group.RouterGroup):
             data = await quart.request.json
             await self.ap.plugin_mgr.reorder_plugins(data.get('plugins'))
             return self.success()
-        
-        @self.route('/install/github', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
+
+        @self.route(
+            '/install/github', methods=['POST'], auth_type=group.AuthType.USER_TOKEN
+        )
         async def _() -> str:
             data = await quart.request.json
-            
+
             ctx = taskmgr.TaskContext.new()
             short_source_str = data['source'][-8:]
             wrapper = self.ap.task_mgr.create_user_task(
                 self.ap.plugin_mgr.install_plugin(data['source'], task_context=ctx),
-                kind="plugin-operation",
-                name=f'plugin-install-github',
+                kind='plugin-operation',
+                name='plugin-install-github',
                 label=f'安装插件 ...{short_source_str}',
-                context=ctx
+                context=ctx,
             )
 
-            return self.success(data={
-                'task_id': wrapper.id
-            })
+            return self.success(data={'task_id': wrapper.id})

pkg/api/http/controller/groups/provider/models.py

@@ -1,28 +1,23 @@
 import quart
-import uuid
 
 from ... import group
-from ......entity.persistence import model
 
 
 @group.group_class('models/llm', '/api/v1/provider/models/llm')
 class LLMModelsRouterGroup(group.RouterGroup):
-    
     async def initialize(self) -> None:
         @self.route('', methods=['GET', 'POST'])
         async def _() -> str:
             if quart.request.method == 'GET':
-                return self.success(data={
-                    'models': await self.ap.model_service.get_llm_models()
-                })
+                return self.success(
+                    data={'models': await self.ap.model_service.get_llm_models()}
+                )
             elif quart.request.method == 'POST':
                 json_data = await quart.request.json
 
                 model_uuid = await self.ap.model_service.create_llm_model(json_data)
 
-                return self.success(data={
-                    'uuid': model_uuid
-                })
+                return self.success(data={'uuid': model_uuid})
 
         @self.route('/<model_uuid>', methods=['GET', 'DELETE'])
         async def _(model_uuid: str) -> str:
@@ -32,9 +27,7 @@ class LLMModelsRouterGroup(group.RouterGroup):
                 if model is None:
                     return self.http_status(404, -1, 'model not found')
 
-                return self.success(data={
-                    'model': model
-                })
+                return self.success(data={'model': model})
             # elif quart.request.method == 'PUT':
             #     json_data = await quart.request.json
 

pkg/api/http/controller/groups/provider/requesters.py

@@ -5,29 +5,31 @@ from ... import group
 
 @group.group_class('provider/requesters', '/api/v1/provider/requesters')
 class RequestersRouterGroup(group.RouterGroup):
-    
     async def initialize(self) -> None:
         @self.route('', methods=['GET'])
         async def _() -> quart.Response:
-            return self.success(data={
-                'requesters': self.ap.model_mgr.get_available_requesters_info()
-            })
-        
+            return self.success(
+                data={'requesters': self.ap.model_mgr.get_available_requesters_info()}
+            )
+
         @self.route('/<requester_name>', methods=['GET'])
         async def _(requester_name: str) -> quart.Response:
-
-            requester_info = self.ap.model_mgr.get_available_requester_info_by_name(requester_name)
+            requester_info = self.ap.model_mgr.get_available_requester_info_by_name(
+                requester_name
+            )
 
             if requester_info is None:
                 return self.http_status(404, -1, 'requester not found')
 
-            return self.success(data={
-                'requester': requester_info
-            })
-        
+            return self.success(data={'requester': requester_info})
+
         @self.route('/<requester_name>/icon', methods=['GET'])
         async def _(requester_name: str) -> quart.Response:
-            requester_manifest = self.ap.model_mgr.get_available_requester_manifest_by_name(requester_name)
+            requester_manifest = (
+                self.ap.model_mgr.get_available_requester_manifest_by_name(
+                    requester_name
+                )
+            )
 
             if requester_manifest is None:
                 return self.http_status(404, -1, 'requester not found')

pkg/api/http/controller/groups/stats.py

@@ -1,23 +1,21 @@
-import quart
-import asyncio
-
-from .....core import app, taskmgr
 from .. import group
 
 
 @group.group_class('stats', '/api/v1/stats')
 class StatsRouterGroup(group.RouterGroup):
-    
     async def initialize(self) -> None:
         @self.route('/basic', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
         async def _() -> str:
-
             conv_count = 0
             for session in self.ap.sess_mgr.session_list:
-                conv_count += len(session.conversations if session.conversations is not None else [])
+                conv_count += len(
+                    session.conversations if session.conversations is not None else []
+                )
 
-            return self.success(data={
-                'active_session_count': len(self.ap.sess_mgr.session_list),
-                'conversation_count': conv_count,
-                'query_count': self.ap.query_pool.query_id_counter,
-            })
+            return self.success(
+                data={
+                    'active_session_count': len(self.ap.sess_mgr.session_list),
+                    'conversation_count': conv_count,
+                    'query_count': self.ap.query_pool.query_id_counter,
+                }
+            )

pkg/api/http/controller/groups/system.py

@@ -1,63 +1,62 @@
 import quart
-import asyncio
 
-from .....core import app, taskmgr
 from .. import group
 from .....utils import constants
 
 
 @group.group_class('system', '/api/v1/system')
 class SystemRouterGroup(group.RouterGroup):
-    
     async def initialize(self) -> None:
         @self.route('/info', methods=['GET'], auth_type=group.AuthType.NONE)
         async def _() -> str:
             return self.success(
                 data={
-                    "version": constants.semantic_version,
-                    "debug": constants.debug_mode,
-                    "enabled_platform_count": len(self.ap.platform_mgr.get_running_adapters())
+                    'version': constants.semantic_version,
+                    'debug': constants.debug_mode,
+                    'enabled_platform_count': len(
+                        self.ap.platform_mgr.get_running_adapters()
+                    ),
                 }
             )
 
         @self.route('/tasks', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
         async def _() -> str:
-            task_type = quart.request.args.get("type")
+            task_type = quart.request.args.get('type')
 
             if task_type == '':
                 task_type = None
 
-            return self.success(
-                data=self.ap.task_mgr.get_tasks_dict(task_type)
-            )
-        
-        @self.route('/tasks/<task_id>', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
+            return self.success(data=self.ap.task_mgr.get_tasks_dict(task_type))
+
+        @self.route(
+            '/tasks/<task_id>', methods=['GET'], auth_type=group.AuthType.USER_TOKEN
+        )
         async def _(task_id: str) -> str:
             task = self.ap.task_mgr.get_task_by_id(int(task_id))
 
             if task is None:
-                return self.http_status(404, 404, "Task not found")
-            
+                return self.http_status(404, 404, 'Task not found')
+
             return self.success(data=task.to_dict())
-        
+
         @self.route('/reload', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
         async def _() -> str:
             json_data = await quart.request.json
 
-            scope = json_data.get("scope")
+            scope = json_data.get('scope')
 
-            await self.ap.reload(
-                scope=scope
-            )
+            await self.ap.reload(scope=scope)
             return self.success()
 
-        @self.route('/_debug/exec', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
+        @self.route(
+            '/_debug/exec', methods=['POST'], auth_type=group.AuthType.USER_TOKEN
+        )
         async def _() -> str:
             if not constants.debug_mode:
-                return self.http_status(403, 403, "Forbidden")
-            
+                return self.http_status(403, 403, 'Forbidden')
+
             py_code = await quart.request.data
 
             ap = self.ap
 
-            return self.success(data=exec(py_code, {"ap": ap}))
+            return self.success(data=exec(py_code, {'ap': ap}))

pkg/api/http/controller/groups/user.py

@@ -1,22 +1,19 @@
 import quart
-import jwt
 import argon2
 
 from .. import group
-from .....entity.persistence import user
 
 
 @group.group_class('user', '/api/v1/user')
 class UserRouterGroup(group.RouterGroup):
-    
     async def initialize(self) -> None:
         @self.route('/init', methods=['GET', 'POST'], auth_type=group.AuthType.NONE)
         async def _() -> str:
             if quart.request.method == 'GET':
-                return self.success(data={
-                    'initialized': await self.ap.user_service.is_initialized()
-                })
-            
+                return self.success(
+                    data={'initialized': await self.ap.user_service.is_initialized()}
+                )
+
             if await self.ap.user_service.is_initialized():
                 return self.fail(1, '系统已初始化')
 
@@ -28,24 +25,24 @@ class UserRouterGroup(group.RouterGroup):
             await self.ap.user_service.create_user(user_email, password)
 
             return self.success()
-        
+
         @self.route('/auth', methods=['POST'], auth_type=group.AuthType.NONE)
         async def _() -> str:
             json_data = await quart.request.json
 
             try:
-                token = await self.ap.user_service.authenticate(json_data['user'], json_data['password'])
+                token = await self.ap.user_service.authenticate(
+                    json_data['user'], json_data['password']
+                )
             except argon2.exceptions.VerifyMismatchError:
                 return self.fail(1, '用户名或密码错误')
 
-            return self.success(data={
-                'token': token
-            })
+            return self.success(data={'token': token})
 
-        @self.route('/check-token', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
+        @self.route(
+            '/check-token', methods=['GET'], auth_type=group.AuthType.USER_TOKEN
+        )
         async def _(user_email: str) -> str:
             token = await self.ap.user_service.generate_jwt_token(user_email)
 
-            return self.success(data={
-                'token': token
-            })
+            return self.success(data={'token': token})

pkg/api/http/controller/main.py

@@ -7,15 +7,19 @@ import quart
 import quart_cors
 
 from ....core import app, entities as core_entities
+from ....utils import importutil
 
-from .groups import logs, system, plugins, stats, user, pipelines
-from .groups.provider import models, requesters
-from .groups.platform import bots, adapters
+from . import groups
 from . import group
+from .groups import provider as groups_provider
+from .groups import platform as groups_platform
+
+importutil.import_modules_in_pkg(groups)
+importutil.import_modules_in_pkg(groups_provider)
+importutil.import_modules_in_pkg(groups_platform)
 
 
 class HTTPController:
-
     ap: app.Application
 
     quart_app: quart.Quart
@@ -23,7 +27,7 @@ class HTTPController:
     def __init__(self, ap: app.Application) -> None:
         self.ap = ap
         self.quart_app = quart.Quart(__name__)
-        quart_cors.cors(self.quart_app, allow_origin="*")
+        quart_cors.cors(self.quart_app, allow_origin='*')
 
     async def initialize(self) -> None:
         await self.register_routes()
@@ -37,11 +41,9 @@ class HTTPController:
 
             async def exception_handler(*args, **kwargs):
                 try:
-                    await self.quart_app.run_task(
-                        *args, **kwargs
-                    )
+                    await self.quart_app.run_task(*args, **kwargs)
                 except Exception as e:
-                    self.ap.logger.error(f"启动 HTTP 服务失败： {e}")
+                    self.ap.logger.error(f'启动 HTTP 服务失败： {e}')
 
             self.ap.task_mgr.create_task(
                 exception_handler(
@@ -49,63 +51,62 @@ class HTTPController:
                     port=self.ap.instance_config.data['api']['port'],
                     shutdown_trigger=shutdown_trigger_placeholder,
                 ),
-                name="http-api-quart",
+                name='http-api-quart',
                 scopes=[core_entities.LifecycleControlScope.APPLICATION],
             )
 
             # await asyncio.sleep(5)
 
     async def register_routes(self) -> None:
-
-        @self.quart_app.route("/healthz")
+        @self.quart_app.route('/healthz')
         async def healthz():
-            return {"code": 0, "msg": "ok"}
+            return {'code': 0, 'msg': 'ok'}
 
         for g in group.preregistered_groups:
             ginst = g(self.ap, self.quart_app)
             await ginst.initialize()
 
-        frontend_path = "web/out"
+        frontend_path = 'web/out'
 
-        @self.quart_app.route("/")
+        @self.quart_app.route('/')
         async def index():
-            return await quart.send_from_directory(frontend_path, "index.html", mimetype="text/html")
+            return await quart.send_from_directory(
+                frontend_path, 'index.html', mimetype='text/html'
+            )
 
-        @self.quart_app.route("/<path:path>")
+        @self.quart_app.route('/<path:path>')
         async def static_file(path: str):
             if not os.path.exists(os.path.join(frontend_path, path)):
-                if os.path.exists(os.path.join(frontend_path, path+".html")):
+                if os.path.exists(os.path.join(frontend_path, path + '.html')):
                     path += '.html'
                 else:
                     return await quart.send_from_directory(frontend_path, '404.html')
 
             mimetype = None
 
-            if path.endswith(".html"):
-                mimetype = "text/html"
-            elif path.endswith(".js"):
-                mimetype = "application/javascript"
-            elif path.endswith(".css"):
-                mimetype = "text/css"
-            elif path.endswith(".png"):
-                mimetype = "image/png"
-            elif path.endswith(".jpg"):
-                mimetype = "image/jpeg"
-            elif path.endswith(".jpeg"):
-                mimetype = "image/jpeg"
-            elif path.endswith(".gif"):
-                mimetype = "image/gif"
-            elif path.endswith(".svg"):
-                mimetype = "image/svg+xml"
-            elif path.endswith(".ico"):
-                mimetype = "image/x-icon"
-            elif path.endswith(".json"):
-                mimetype = "application/json"
-            elif path.endswith(".txt"):
-                mimetype = "text/plain"
+            if path.endswith('.html'):
+                mimetype = 'text/html'
+            elif path.endswith('.js'):
+                mimetype = 'application/javascript'
+            elif path.endswith('.css'):
+                mimetype = 'text/css'
+            elif path.endswith('.png'):
+                mimetype = 'image/png'
+            elif path.endswith('.jpg'):
+                mimetype = 'image/jpeg'
+            elif path.endswith('.jpeg'):
+                mimetype = 'image/jpeg'
+            elif path.endswith('.gif'):
+                mimetype = 'image/gif'
+            elif path.endswith('.svg'):
+                mimetype = 'image/svg+xml'
+            elif path.endswith('.ico'):
+                mimetype = 'image/x-icon'
+            elif path.endswith('.json'):
+                mimetype = 'application/json'
+            elif path.endswith('.txt'):
+                mimetype = 'text/plain'
 
             return await quart.send_from_directory(
-                frontend_path,
-                path,
-                mimetype=mimetype
+                frontend_path, path, mimetype=mimetype
             )

pkg/api/http/service/bot.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import uuid
-import datetime
 import sqlalchemy
 
 from ....core import app
@@ -29,13 +28,15 @@ class BotService:
             self.ap.persistence_mgr.serialize_model(persistence_bot.Bot, bot)
             for bot in bots
         ]
-    
+
     async def get_bot(self, bot_uuid: str) -> dict | None:
         """获取机器人"""
         result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_bot.Bot).where(persistence_bot.Bot.uuid == bot_uuid)
+            sqlalchemy.select(persistence_bot.Bot).where(
+                persistence_bot.Bot.uuid == bot_uuid
+            )
         )
-        
+
         bot = result.first()
 
         if bot is None:
@@ -50,7 +51,9 @@ class BotService:
 
         # checkout the default pipeline
         result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(persistence_pipeline.LegacyPipeline.is_default == True)
+            sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(
+                persistence_pipeline.LegacyPipeline.is_default == True
+            )
         )
         pipeline = result.first()
         if pipeline is not None:
@@ -64,7 +67,7 @@ class BotService:
         bot = await self.get_bot(bot_data['uuid'])
 
         await self.ap.platform_mgr.load_bot(bot)
-        
+
         return bot_data['uuid']
 
     async def update_bot(self, bot_uuid: str, bot_data: dict) -> None:
@@ -75,19 +78,24 @@ class BotService:
         # set use_pipeline_name
         if 'use_pipeline_uuid' in bot_data:
             result = await self.ap.persistence_mgr.execute_async(
-                sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(persistence_pipeline.LegacyPipeline.uuid == bot_data['use_pipeline_uuid'])
+                sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(
+                    persistence_pipeline.LegacyPipeline.uuid
+                    == bot_data['use_pipeline_uuid']
+                )
             )
             pipeline = result.first()
             if pipeline is not None:
                 bot_data['use_pipeline_name'] = pipeline.name
             else:
-                raise Exception("Pipeline not found")
+                raise Exception('Pipeline not found')
 
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.update(persistence_bot.Bot).values(bot_data).where(persistence_bot.Bot.uuid == bot_uuid)
+            sqlalchemy.update(persistence_bot.Bot)
+            .values(bot_data)
+            .where(persistence_bot.Bot.uuid == bot_uuid)
         )
         await self.ap.platform_mgr.remove_bot(bot_uuid)
-        
+
         # select from db
         bot = await self.get_bot(bot_uuid)
 
@@ -100,7 +108,7 @@ class BotService:
         """删除机器人"""
         await self.ap.platform_mgr.remove_bot(bot_uuid)
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.delete(persistence_bot.Bot).where(persistence_bot.Bot.uuid == bot_uuid)
+            sqlalchemy.delete(persistence_bot.Bot).where(
+                persistence_bot.Bot.uuid == bot_uuid
+            )
         )
-
-

pkg/api/http/service/model.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import uuid
-import datetime
 import sqlalchemy
 
 from ....core import app
@@ -10,7 +9,6 @@ from ....entity.persistence import pipeline as persistence_pipeline
 
 
 class ModelsService:
-
     ap: app.Application
 
     def __init__(self, ap: app.Application) -> None:
@@ -26,15 +24,12 @@ class ModelsService:
             self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model)
             for model in models
         ]
-    
-    async def create_llm_model(self, model_data: dict) -> str:
 
+    async def create_llm_model(self, model_data: dict) -> str:
         model_data['uuid'] = str(uuid.uuid4())
 
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.insert(persistence_model.LLMModel).values(
-                **model_data
-            )
+            sqlalchemy.insert(persistence_model.LLMModel).values(**model_data)
         )
 
         llm_model = await self.get_llm_model(model_data['uuid'])
@@ -43,22 +38,24 @@ class ModelsService:
 
         # check if default pipeline has no model bound
         result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(persistence_pipeline.LegacyPipeline.is_default == True)
+            sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(
+                persistence_pipeline.LegacyPipeline.is_default == True
+            )
         )
         pipeline = result.first()
         if pipeline is not None and pipeline.config['ai']['local-agent']['model'] == '':
             pipeline_config = pipeline.config
             pipeline_config['ai']['local-agent']['model'] = model_data['uuid']
-            pipeline_data = {
-                "config": pipeline_config
-            }
-            await self.ap.pipeline_service.update_pipeline(pipeline.uuid, pipeline_data)            
+            pipeline_data = {'config': pipeline_config}
+            await self.ap.pipeline_service.update_pipeline(pipeline.uuid, pipeline_data)
 
         return model_data['uuid']
 
     async def get_llm_model(self, model_uuid: str) -> dict | None:
         result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.LLMModel).where(persistence_model.LLMModel.uuid == model_uuid)
+            sqlalchemy.select(persistence_model.LLMModel).where(
+                persistence_model.LLMModel.uuid == model_uuid
+            )
         )
 
         model = result.first()
@@ -66,14 +63,18 @@ class ModelsService:
         if model is None:
             return None
 
-        return self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model)
+        return self.ap.persistence_mgr.serialize_model(
+            persistence_model.LLMModel, model
+        )
 
     async def update_llm_model(self, model_uuid: str, model_data: dict) -> None:
         if 'uuid' in model_data:
             del model_data['uuid']
-        
+
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.update(persistence_model.LLMModel).where(persistence_model.LLMModel.uuid == model_uuid).values(**model_data)
+            sqlalchemy.update(persistence_model.LLMModel)
+            .where(persistence_model.LLMModel.uuid == model_uuid)
+            .values(**model_data)
         )
 
         await self.ap.model_mgr.remove_llm_model(model_uuid)
@@ -84,7 +85,9 @@ class ModelsService:
 
     async def delete_llm_model(self, model_uuid: str) -> None:
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.delete(persistence_model.LLMModel).where(persistence_model.LLMModel.uuid == model_uuid)
+            sqlalchemy.delete(persistence_model.LLMModel).where(
+                persistence_model.LLMModel.uuid == model_uuid
+            )
         )
 
         await self.ap.model_mgr.remove_llm_model(model_uuid)

pkg/api/http/service/pipeline.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import uuid
 import json
-import datetime
 import sqlalchemy
 
 from ....core import app
@@ -10,69 +9,79 @@ from ....entity.persistence import pipeline as persistence_pipeline
 
 
 default_stage_order = [
-    "GroupRespondRuleCheckStage",  # 群响应规则检查
-    "BanSessionCheckStage",  # 封禁会话检查
-    "PreContentFilterStage",  # 内容过滤前置阶段
-    "PreProcessor",  # 预处理器
-    "ConversationMessageTruncator",  # 会话消息截断器
-    "RequireRateLimitOccupancy",  # 请求速率限制占用
-    "MessageProcessor",  # 处理器
-    "ReleaseRateLimitOccupancy",  # 释放速率限制占用
-    "PostContentFilterStage",  # 内容过滤后置阶段
-    "ResponseWrapper",  # 响应包装器
-    "LongTextProcessStage",  # 长文本处理
-    "SendResponseBackStage",  # 发送响应
+    'GroupRespondRuleCheckStage',  # 群响应规则检查
+    'BanSessionCheckStage',  # 封禁会话检查
+    'PreContentFilterStage',  # 内容过滤前置阶段
+    'PreProcessor',  # 预处理器
+    'ConversationMessageTruncator',  # 会话消息截断器
+    'RequireRateLimitOccupancy',  # 请求速率限制占用
+    'MessageProcessor',  # 处理器
+    'ReleaseRateLimitOccupancy',  # 释放速率限制占用
+    'PostContentFilterStage',  # 内容过滤后置阶段
+    'ResponseWrapper',  # 响应包装器
+    'LongTextProcessStage',  # 长文本处理
+    'SendResponseBackStage',  # 发送响应
 ]
 
 
 class PipelineService:
     ap: app.Application
-    
+
     def __init__(self, ap: app.Application) -> None:
         self.ap = ap
-    
+
     async def get_pipeline_metadata(self) -> dict:
         return [
             self.ap.pipeline_config_meta_trigger.data,
             self.ap.pipeline_config_meta_safety.data,
             self.ap.pipeline_config_meta_ai.data,
-            self.ap.pipeline_config_meta_output.data
+            self.ap.pipeline_config_meta_output.data,
         ]
 
     async def get_pipelines(self) -> list[dict]:
         result = await self.ap.persistence_mgr.execute_async(
             sqlalchemy.select(persistence_pipeline.LegacyPipeline)
         )
-        
+
         pipelines = result.all()
         return [
-            self.ap.persistence_mgr.serialize_model(persistence_pipeline.LegacyPipeline, pipeline)
+            self.ap.persistence_mgr.serialize_model(
+                persistence_pipeline.LegacyPipeline, pipeline
+            )
             for pipeline in pipelines
         ]
-    
+
     async def get_pipeline(self, pipeline_uuid: str) -> dict | None:
         result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(persistence_pipeline.LegacyPipeline.uuid == pipeline_uuid)
+            sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(
+                persistence_pipeline.LegacyPipeline.uuid == pipeline_uuid
+            )
         )
-        
+
         pipeline = result.first()
 
         if pipeline is None:
             return None
 
-        return self.ap.persistence_mgr.serialize_model(persistence_pipeline.LegacyPipeline, pipeline)
+        return self.ap.persistence_mgr.serialize_model(
+            persistence_pipeline.LegacyPipeline, pipeline
+        )
 
     async def create_pipeline(self, pipeline_data: dict, default: bool = False) -> str:
         pipeline_data['uuid'] = str(uuid.uuid4())
         pipeline_data['for_version'] = self.ap.ver_mgr.get_current_version()
         pipeline_data['stages'] = default_stage_order.copy()
         pipeline_data['is_default'] = default
-        pipeline_data['config'] = json.load(open('templates/default-pipeline-config.json', 'r', encoding='utf-8'))
+        pipeline_data['config'] = json.load(
+            open('templates/default-pipeline-config.json', 'r', encoding='utf-8')
+        )
 
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.insert(persistence_pipeline.LegacyPipeline).values(**pipeline_data)
+            sqlalchemy.insert(persistence_pipeline.LegacyPipeline).values(
+                **pipeline_data
+            )
         )
-        
+
         pipeline = await self.get_pipeline(pipeline_data['uuid'])
 
         await self.ap.pipeline_mgr.load_pipeline(pipeline)
@@ -90,7 +99,9 @@ class PipelineService:
             del pipeline_data['is_default']
 
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.update(persistence_pipeline.LegacyPipeline).where(persistence_pipeline.LegacyPipeline.uuid == pipeline_uuid).values(**pipeline_data)
+            sqlalchemy.update(persistence_pipeline.LegacyPipeline)
+            .where(persistence_pipeline.LegacyPipeline.uuid == pipeline_uuid)
+            .values(**pipeline_data)
         )
 
         await self.ap.pipeline_mgr.remove_pipeline(pipeline_uuid)
@@ -101,6 +112,8 @@ class PipelineService:
 
     async def delete_pipeline(self, pipeline_uuid: str) -> None:
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.delete(persistence_pipeline.LegacyPipeline).where(persistence_pipeline.LegacyPipeline.uuid == pipeline_uuid)
+            sqlalchemy.delete(persistence_pipeline.LegacyPipeline).where(
+                persistence_pipeline.LegacyPipeline.uuid == pipeline_uuid
+            )
         )
         await self.ap.pipeline_mgr.remove_pipeline(pipeline_uuid)

pkg/api/http/service/user.py

@@ -11,7 +11,6 @@ from ....utils import constants
 
 
 class UserService:
-
     ap: app.Application
 
     def __init__(self, ap: app.Application) -> None:
@@ -24,7 +23,7 @@ class UserService:
 
         result_list = result.all()
         return result_list is not None and len(result_list) > 0
-    
+
     async def create_user(self, user_email: str, password: str) -> None:
         ph = argon2.PasswordHasher()
 
@@ -32,8 +31,7 @@ class UserService:
 
         await self.ap.persistence_mgr.execute_async(
             sqlalchemy.insert(user.User).values(
-                user=user_email,
-                password=hashed_password
+                user=user_email, password=hashed_password
             )
         )
 
@@ -61,12 +59,12 @@ class UserService:
 
         payload = {
             'user': user_email,
-            'iss': 'LangBot-'+constants.edition,
-            'exp': datetime.datetime.now() + datetime.timedelta(seconds=jwt_expire)
+            'iss': 'LangBot-' + constants.edition,
+            'exp': datetime.datetime.now() + datetime.timedelta(seconds=jwt_expire),
         }
 
         return jwt.encode(payload, jwt_secret, algorithm='HS256')
-    
+
     async def verify_jwt_token(self, token: str) -> str:
         jwt_secret = self.ap.instance_config.data['system']['jwt']['secret']