style: restrict line-length

pkg/api/http/service/bot.py

@@ -18,23 +18,16 @@ class BotService:
 
     async def get_bots(self) -> list[dict]:
         """获取所有机器人"""
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_bot.Bot)
-        )
+        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_bot.Bot))
 
         bots = result.all()
 
-        return [
-            self.ap.persistence_mgr.serialize_model(persistence_bot.Bot, bot)
-            for bot in bots
-        ]
+        return [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()
@@ -60,9 +53,7 @@ class BotService:
             bot_data['use_pipeline_uuid'] = pipeline.uuid
             bot_data['use_pipeline_name'] = pipeline.name
 
-        await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.insert(persistence_bot.Bot).values(bot_data)
-        )
+        await self.ap.persistence_mgr.execute_async(sqlalchemy.insert(persistence_bot.Bot).values(bot_data))
 
         bot = await self.get_bot(bot_data['uuid'])
 
@@ -79,8 +70,7 @@ class BotService:
         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']
+                    persistence_pipeline.LegacyPipeline.uuid == bot_data['use_pipeline_uuid']
                 )
             )
             pipeline = result.first()
@@ -90,9 +80,7 @@ class BotService:
                 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)
 
@@ -108,7 +96,5 @@ 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

@@ -15,22 +15,15 @@ class ModelsService:
         self.ap = ap
 
     async def get_llm_models(self) -> list[dict]:
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.LLMModel)
-        )
+        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.LLMModel))
 
         models = result.all()
-        return [
-            self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model)
-            for model in models
-        ]
+        return [self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model) for model in models]
 
     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)
-        )
+        await self.ap.persistence_mgr.execute_async(sqlalchemy.insert(persistence_model.LLMModel).values(**model_data))
 
         llm_model = await self.get_llm_model(model_data['uuid'])
 
@@ -53,9 +46,7 @@ class ModelsService:
 
     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()
@@ -63,9 +54,7 @@ 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:
@@ -85,9 +74,7 @@ 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

@@ -39,15 +39,11 @@ class PipelineService:
         ]
 
     async def get_pipelines(self) -> list[dict]:
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_pipeline.LegacyPipeline)
-        )
+        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
         ]
 
@@ -63,23 +59,17 @@ class PipelineService:
         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'])

pkg/api/http/service/user.py

@@ -17,9 +17,7 @@ class UserService:
         self.ap = ap
 
     async def is_initialized(self) -> bool:
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(user.User).limit(1)
-        )
+        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(user.User).limit(1))
 
         result_list = result.all()
         return result_list is not None and len(result_list) > 0
@@ -30,9 +28,7 @@ class UserService:
         hashed_password = ph.hash(password)
 
         await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.insert(user.User).values(
-                user=user_email, password=hashed_password
-            )
+            sqlalchemy.insert(user.User).values(user=user_email, password=hashed_password)
         )
 
     async def get_user_by_email(self, user_email: str) -> user.User | None:
@@ -41,9 +37,7 @@ class UserService:
         )
 
         result_list = result.all()
-        return (
-            result_list[0] if result_list is not None and len(result_list) > 0 else None
-        )
+        return result_list[0] if result_list is not None and len(result_list) > 0 else None
 
     async def authenticate(self, user_email: str, password: str) -> str | None:
         result = await self.ap.persistence_mgr.execute_async(