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
2026-06-02 20:14:36 +00:00 · 2025-04-29 17:24:07 +08:00
parent 09e70d70e9
commit 209f16af76
240 changed files with 5307 additions and 4689 deletions
--- a/pkg/api/http/controller/groups/logs.py
+++ b/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,
                }
            )
--- a/pkg/api/http/controller/groups/pipelines.py
+++ b/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()
-
--- a/pkg/api/http/controller/groups/platform/adapters.py
+++ b/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)
--- a/pkg/api/http/controller/groups/platform/bots.py
+++ b/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()
--- a/pkg/api/http/controller/groups/plugins.py
+++ b/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})
--- a/pkg/api/http/controller/groups/provider/models.py
+++ b/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

--- a/pkg/api/http/controller/groups/provider/requesters.py
+++ b/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')
--- a/pkg/api/http/controller/groups/stats.py
+++ b/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,
+                }
+            )
--- a/pkg/api/http/controller/groups/system.py
+++ b/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}))
--- a/pkg/api/http/controller/groups/user.py
+++ b/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})