jarvis-ai-assistant 0.1.193__py3-none-any.whl → 0.1.195__py3-none-any.whl

jarvis/jarvis_platform/kimi.py

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+# Kimi 平台实现模块
+# 提供与 Moonshot AI 的 Kimi 大模型交互功能
 import json
 import mimetypes
 import os
@@ -8,13 +10,17 @@ from typing import Dict, Generator, List, Tuple
 import requests  # type: ignore
 
 from jarvis.jarvis_platform.base import BasePlatform
-from jarvis.jarvis_utils.config import get_data_dir
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import while_success
 
 
 class KimiModel(BasePlatform):
-    """Kimi model implementation"""
+    """Kimi 大模型平台实现类
+    封装了与 Kimi 大模型交互的所有功能，包括：
+    - 会话管理
+    - 文件上传
+    - 消息收发
+    """
 
     platform_name = "kimi"
 
@@ -22,24 +28,24 @@ class KimiModel(BasePlatform):
         """Get model list"""
         return [
             ("kimi", "基于网页的 Kimi，免费接口"),
-            ("k1", "基于网页的 Kimi，深度思考模型")
-            ]
+            ("k1", "基于网页的 Kimi，深度思考模型"),
+        ]
 
     def __init__(self):
         """
         Initialize Kimi model
         """
         super().__init__()
-        self.chat_id = ""
-        self.api_key = os.getenv("KIMI_API_KEY")
+        self.chat_id = ""  # 当前会话ID
+        self.api_key = os.getenv("KIMI_API_KEY")  # 从环境变量获取API密钥
         if not self.api_key:
             PrettyOutput.print("KIMI_API_KEY 未设置", OutputType.WARNING)
-        self.auth_header = f"Bearer {self.api_key}"
+        self.auth_header = f"Bearer {self.api_key}"  # 认证头信息
         self.uploaded_files = []  # 存储已上传文件的信息
-        self.chat_id = ""
-        self.first_chat = True  # 添加标记，用于判断是否是第一次对话
-        self.system_message = ""
-        self.model_name = "kimi"
+        self.chat_id = ""  # 当前会话ID
+        self.first_chat = True  # 标记是否是第一次对话
+        self.system_message = ""  # 系统提示消息
+        self.model_name = "kimi"  # 默认模型名称
 
     def set_system_prompt(self, message: str):
         """Set system message"""
@@ -52,45 +58,47 @@ class KimiModel(BasePlatform):
     def _create_chat(self) -> bool:
         """Create a new chat session"""
         url = "https://kimi.moonshot.cn/api/chat"
-        payload = json.dumps({
-            "name": "Unnamed session",
-            "is_example": False,
-            "kimiplus_id": "kimi"
-        })
+        payload = json.dumps(
+            {"name": "Unnamed session", "is_example": False, "kimiplus_id": "kimi"}
+        )
         headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
+            "Authorization": self.auth_header,
+            "Content-Type": "application/json",
         }
         try:
-            response = while_success(lambda: requests.request("POST", url, headers=headers, data=payload), sleep_time=5)
+            response = while_success(
+                lambda: requests.request("POST", url, headers=headers, data=payload),
+                sleep_time=5,
+            )
             if response.status_code != 200:
-                PrettyOutput.print(f"错误：创建会话失败：{response.json()}", OutputType.ERROR)
+                PrettyOutput.print(
+                    f"错误：创建会话失败：{response.json()}", OutputType.ERROR
+                )
                 return False
             self.chat_id = response.json()["id"]
             return True
         except Exception as e:
             PrettyOutput.print(f"错误：创建会话失败：{e}", OutputType.ERROR)
             return False
-        
+
     def _get_presigned_url(self, filename: str, action: str) -> Dict:
         """Get presigned upload URL"""
         url = "https://kimi.moonshot.cn/api/pre-sign-url"
-        
-        
-        
-        payload = json.dumps({
-            "action": action,
-            "name": os.path.basename(filename)
-        }, ensure_ascii=False)
-        
+
+        payload = json.dumps(
+            {"action": action, "name": os.path.basename(filename)}, ensure_ascii=False
+        )
+
         headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
+            "Authorization": self.auth_header,
+            "Content-Type": "application/json",
         }
-        
-        response = while_success(lambda: requests.post(url, headers=headers, data=payload), sleep_time=5)
+
+        response = while_success(
+            lambda: requests.post(url, headers=headers, data=payload), sleep_time=5
+        )
         return response.json()
-    
+
     def support_upload_files(self) -> bool:
         """Check if platform supports upload files"""
         return True
@@ -98,9 +106,11 @@ class KimiModel(BasePlatform):
     def _upload_file(self, file_path: str, presigned_url: str) -> bool:
         """Upload file to presigned URL"""
         try:
-            with open(file_path, 'rb') as f:
+            with open(file_path, "rb") as f:
                 content = f.read()
-                response = while_success(lambda: requests.put(presigned_url, data=content), sleep_time=5)
+                response = while_success(
+                    lambda: requests.put(presigned_url, data=content), sleep_time=5
+                )
                 return response.status_code == 200
         except Exception as e:
             PrettyOutput.print(f"错误：上传文件失败：{e}", OutputType.ERROR)
@@ -109,45 +119,53 @@ class KimiModel(BasePlatform):
     def _get_file_info(self, file_data: Dict, name: str, file_type: str) -> Dict:
         """Get file information"""
         url = "https://kimi.moonshot.cn/api/file"
-        payload = json.dumps({
-            "type": file_type,
-            "name": name,
-            "object_name": file_data["object_name"],
-            "chat_id": self.chat_id,
-            "file_id": file_data.get("file_id", "")
-        }, ensure_ascii=False)
-        
+        payload = json.dumps(
+            {
+                "type": file_type,
+                "name": name,
+                "object_name": file_data["object_name"],
+                "chat_id": self.chat_id,
+                "file_id": file_data.get("file_id", ""),
+            },
+            ensure_ascii=False,
+        )
+
         headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
+            "Authorization": self.auth_header,
+            "Content-Type": "application/json",
         }
-        
-        response = while_success(lambda: requests.post(url, headers=headers, data=payload), sleep_time=5)
+
+        response = while_success(
+            lambda: requests.post(url, headers=headers, data=payload), sleep_time=5
+        )
         return response.json()
 
     def _wait_for_parse(self, file_id: str) -> bool:
         """Wait for file parsing to complete"""
         url = "https://kimi.moonshot.cn/api/file/parse_process"
         headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
+            "Authorization": self.auth_header,
+            "Content-Type": "application/json",
         }
-        
+
         max_retries = 30
         retry_count = 0
-        
+
         while retry_count < max_retries:
             payload = json.dumps({"ids": [file_id]}, ensure_ascii=False)
-            response = while_success(lambda: requests.post(url, headers=headers, data=payload, stream=True), sleep_time=5)
-            
+            response = while_success(
+                lambda: requests.post(url, headers=headers, data=payload, stream=True),
+                sleep_time=5,
+            )
+
             for line in response.iter_lines():
                 if not line:
                     continue
-                    
-                line = line.decode('utf-8')
+
+                line = line.decode("utf-8")
                 if not line.startswith("data: "):
                     continue
-                    
+
                 try:
                     data = json.loads(line[6:])
                     if data.get("event") == "resp":
@@ -158,18 +176,19 @@ class KimiModel(BasePlatform):
                             return False
                 except json.JSONDecodeError:
                     continue
-            
+
             retry_count += 1
             time.sleep(1)
-        
+
         return False
+
     def upload_files(self, file_list: List[str]) -> bool:
         """Upload file list and return file information"""
         if not file_list:
             return True
 
         from yaspin import yaspin  # type: ignore
-        
+
         if not self.chat_id:
             with yaspin(text="创建聊天会话...", color="yellow") as spinner:
                 if not self._create_chat():
@@ -182,22 +201,30 @@ class KimiModel(BasePlatform):
         uploaded_files = []
         for index, file_path in enumerate(file_list, 1):
             file_name = os.path.basename(file_path)
-            with yaspin(text=f"处理文件 [{index}/{len(file_list)}]: {file_name}", color="yellow") as spinner:
+            with yaspin(
+                text=f"处理文件 [{index}/{len(file_list)}]: {file_name}", color="yellow"
+            ) as spinner:
                 try:
                     mime_type, _ = mimetypes.guess_type(file_path)
-                    action = "image" if mime_type and mime_type.startswith('image/') else "file"
-                    
+                    action = (
+                        "image"
+                        if mime_type and mime_type.startswith("image/")
+                        else "file"
+                    )
+
                     # 获取预签名URL
                     spinner.text = f"获取上传URL: {file_name}"
                     presigned_data = self._get_presigned_url(file_path, action)
-                    
+
                     # 上传文件
                     spinner.text = f"上传文件: {file_name}"
                     if self._upload_file(file_path, presigned_data["url"]):
                         # 获取文件信息
                         spinner.text = f"获取文件信息: {file_name}"
-                        file_info = self._get_file_info(presigned_data, file_name, action)
-                        
+                        file_info = self._get_file_info(
+                            presigned_data, file_name, action
+                        )
+
                         # 只有文件需要解析
                         if action == "file":
                             spinner.text = f"等待文件解析: {file_name}"
@@ -211,23 +238,27 @@ class KimiModel(BasePlatform):
                                 return False
                         else:
                             uploaded_files.append(file_info)
-                            spinner.write( f"✅图片处理完成: {file_name}")
+                            spinner.write(f"✅图片处理完成: {file_name}")
                     else:
                         spinner.text = f"文件上传失败: {file_name}"
                         spinner.fail("❌")
                         return False
-                    
+
                 except Exception as e:
                     spinner.text = f"处理文件出错 {file_path}: {str(e)}"
                     spinner.fail("❌")
                     return False
-        
+
         self.uploaded_files = uploaded_files
         return True
 
-
     def chat(self, message: str) -> Generator[str, None, None]:
-        """Send message and get response"""
+        """发送消息并获取响应流
+        参数:
+            message: 要发送的消息内容
+        返回:
+            生成器，逐块返回模型响应
+        """
         if not self.chat_id:
             if not self._create_chat():
                 raise Exception("Failed to create chat session")
@@ -258,18 +289,21 @@ class KimiModel(BasePlatform):
         }
 
         headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
+            "Authorization": self.auth_header,
+            "Content-Type": "application/json",
         }
 
         try:
-            response = while_success(lambda: requests.post(url, headers=headers, json=payload, stream=True), sleep_time=5)
+            response = while_success(
+                lambda: requests.post(url, headers=headers, json=payload, stream=True),
+                sleep_time=5,
+            )
             # 如果禁止输出，则静默处理
             for line in response.iter_lines():
                 if not line:
                     continue
 
-                line = line.decode('utf-8')
+                line = line.decode("utf-8")
                 if not line.startswith("data: "):
                     continue
 
@@ -285,7 +319,6 @@ class KimiModel(BasePlatform):
                 except json.JSONDecodeError:
                     continue
 
-
             return None
 
         except Exception as e:
@@ -298,25 +331,28 @@ class KimiModel(BasePlatform):
 
         url = f"https://kimi.moonshot.cn/api/chat/{self.chat_id}"
         headers = {
-            'Authorization': self.auth_header,
-            'Content-Type': 'application/json'
+            "Authorization": self.auth_header,
+            "Content-Type": "application/json",
         }
 
         try:
-            response = while_success(lambda: requests.delete(url, headers=headers), sleep_time=5)
+            response = while_success(
+                lambda: requests.delete(url, headers=headers), sleep_time=5
+            )
             if response.status_code == 200:
                 self.chat_id = ""
                 self.uploaded_files = []
                 self.first_chat = True  # 重置first_chat标记
                 return True
             else:
-                PrettyOutput.print(f"删除会话失败: HTTP {response.status_code}", OutputType.WARNING)
+                PrettyOutput.print(
+                    f"删除会话失败: HTTP {response.status_code}", OutputType.WARNING
+                )
                 return False
         except Exception as e:
             PrettyOutput.print(f"删除会话时发生错误: {str(e)}", OutputType.ERROR)
             return False
 
-
     def name(self) -> str:
         """Model name"""
         return self.model_name

jarvis/jarvis_platform/openai.py

@@ -22,23 +22,19 @@ class OpenAIModel(BasePlatform):
             PrettyOutput.print("OPENAI_API_KEY 未设置", OutputType.WARNING)
 
         self.base_url = os.getenv("OPENAI_API_BASE", "https://api.openai.com/v1")
-        self.model_name =  os.getenv("JARVIS_MODEL") or "gpt-4o"
+        self.model_name = os.getenv("JARVIS_MODEL") or "gpt-4o"
 
-
-        self.client = OpenAI(
-            api_key=self.api_key,
-            base_url=self.base_url
-        )
+        self.client = OpenAI(api_key=self.api_key, base_url=self.base_url)
         self.messages: List[Dict[str, str]] = []
         self.system_message = ""
 
     def upload_files(self, file_list: List[str]) -> bool:
         """
         上传文件到OpenAI平台
-        
+
         参数:
             file_list: 需要上传的文件路径列表
-            
+
         返回:
             bool: 上传是否成功 (当前实现始终返回False)
         """
@@ -47,10 +43,10 @@ class OpenAIModel(BasePlatform):
     def get_model_list(self) -> List[Tuple[str, str]]:
         """
         获取可用的OpenAI模型列表
-        
+
         返回:
             List[Tuple[str, str]]: 模型ID和名称的元组列表
-            
+
         异常:
             当API调用失败时会打印错误信息并返回空列表
         """
@@ -67,7 +63,7 @@ class OpenAIModel(BasePlatform):
     def set_model_name(self, model_name: str):
         """
         设置当前使用的模型名称
-        
+
         参数:
             model_name: 要设置的模型名称
         """
@@ -77,10 +73,10 @@ class OpenAIModel(BasePlatform):
     def set_system_prompt(self, message: str):
         """
         设置系统消息(角色设定)
-        
+
         参数:
             message: 系统消息内容
-            
+
         说明:
             设置后会立即添加到消息历史中
         """
@@ -90,13 +86,13 @@ class OpenAIModel(BasePlatform):
     def chat(self, message: str) -> Generator[str, None, None]:
         """
         执行对话并返回生成器
-        
+
         参数:
             message: 用户输入的消息内容
-            
+
         返回:
             Generator[str, None, None]: 生成器，逐块返回AI响应内容
-            
+
         异常:
             当API调用失败时会抛出异常并打印错误信息
         """
@@ -107,9 +103,9 @@ class OpenAIModel(BasePlatform):
 
             response = self.client.chat.completions.create(
                 model=self.model_name,  # Use the configured model name
-                messages=self.messages, # type: ignore
-                stream=True
-            ) # type: ignore
+                messages=self.messages,  # type: ignore
+                stream=True,
+            )  # type: ignore
 
             full_response = ""
             for chunk in response:
@@ -130,20 +126,19 @@ class OpenAIModel(BasePlatform):
     def name(self) -> str:
         """
         获取当前使用的模型名称
-        
+
         返回:
             str: 当前配置的模型名称
         """
         return self.model_name
 
-
-    def delete_chat(self)->bool:
+    def delete_chat(self) -> bool:
         """
         删除当前对话历史
-        
+
         返回:
             bool: 操作是否成功
-            
+
         说明:
             如果设置了系统消息，会保留系统消息
         """
@@ -156,17 +151,17 @@ class OpenAIModel(BasePlatform):
     def support_web(self) -> bool:
         """
         检查是否支持网页访问功能
-        
+
         返回:
             bool: 当前是否支持网页访问 (OpenAI平台始终返回False)
         """
         return False
-    
+
     def support_upload_files(self) -> bool:
         """
         检查是否支持上传文件功能
-        
+
         返回:
             bool: 当前是否支持上传文件 (OpenAI平台始终返回False)
         """
-        return False
+        return False

jarvis/jarvis_platform/registry.py

@@ -13,20 +13,21 @@ from jarvis.jarvis_utils.config import (get_data_dir, get_normal_model_name,
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 REQUIRED_METHODS = [
-    ('chat', ['message']),           # 方法名和参数列表
-    ('name', []),
-    ('delete_chat', []),
-    ('set_system_prompt', ['message']),
-    ('set_model_name', ['model_name']),
-    ('get_model_list', []),
-    ('upload_files', ['file_list']),
+    ("chat", ["message"]),  # 方法名和参数列表
+    ("name", []),
+    ("delete_chat", []),
+    ("set_system_prompt", ["message"]),
+    ("set_model_name", ["model_name"]),
+    ("get_model_list", []),
+    ("upload_files", ["file_list"]),
 ]
 
+
 class PlatformRegistry:
     """Platform registry"""
 
     global_platform_name: str = "yuanbao"
-    global_platform_registry: Optional['PlatformRegistry'] = None
+    global_platform_registry: Optional["PlatformRegistry"] = None
 
     @staticmethod
     def get_platform_dir() -> str:
@@ -35,7 +36,9 @@ class PlatformRegistry:
             try:
                 os.makedirs(user_platform_dir)
                 # 创建 __init__.py 使其成为 Python 包
-                with open(os.path.join(user_platform_dir, "__init__.py"), "w", errors="ignore") as f:
+                with open(
+                    os.path.join(user_platform_dir, "__init__.py"), "w", errors="ignore"
+                ) as f:
                     pass
             except Exception as e:
                 PrettyOutput.print(f"创建平台目录失败: {str(e)}", OutputType.ERROR)
@@ -66,15 +69,16 @@ class PlatformRegistry:
 
             # 检查方法参数
             import inspect
+
             sig = inspect.signature(method)
-            method_params = [p for p in sig.parameters if p != 'self']
+            method_params = [p for p in sig.parameters if p != "self"]
             if len(method_params) != len(params):
                 missing_methods.append(f"{method_name}(parameter mismatch)")
 
         if missing_methods:
             PrettyOutput.print(
                 f"平台 {platform_class.__name__} 缺少必要的方法: {', '.join(missing_methods)}",
-                OutputType.WARNING
+                OutputType.WARNING,
             )
             return False
 
@@ -108,35 +112,40 @@ class PlatformRegistry:
 
         # 遍历目录下的所有.py文件
         for filename in os.listdir(directory):
-            if filename.endswith('.py') and not filename.startswith('__'):
+            if filename.endswith(".py") and not filename.startswith("__"):
                 module_name = filename[:-3]  # 移除.py后缀
                 try:
                     # 导入模块
                     if package_name:
-                        module = importlib.import_module(f"{package_name}.{module_name}")
+                        module = importlib.import_module(
+                            f"{package_name}.{module_name}"
+                        )
                     else:
                         module = importlib.import_module(module_name)
 
                     # 遍历模块中的所有类
                     for _, obj in inspect.getmembers(module):
                         # 检查是否是BasePlatform的子类，但不是BasePlatform本身
-                        if (inspect.isclass(obj) and
-                            issubclass(obj, BasePlatform) and
-                            obj != BasePlatform and
-                            hasattr(obj, 'platform_name')):
+                        if (
+                            inspect.isclass(obj)
+                            and issubclass(obj, BasePlatform)
+                            and obj != BasePlatform
+                            and hasattr(obj, "platform_name")
+                        ):
                             # 检查平台实现
                             if not PlatformRegistry.check_platform_implementation(obj):
                                 continue
-                            platforms[obj.platform_name] = obj # type: ignore
+                            platforms[obj.platform_name] = obj  # type: ignore
                             break
                 except Exception as e:
-                    PrettyOutput.print(f"加载平台 {module_name} 失败: {str(e)}", OutputType.ERROR)
+                    PrettyOutput.print(
+                        f"加载平台 {module_name} 失败: {str(e)}", OutputType.ERROR
+                    )
 
         return platforms
 
-
     @staticmethod
-    def get_global_platform_registry() -> 'PlatformRegistry':
+    def get_global_platform_registry() -> "PlatformRegistry":
         """Get global platform registry"""
         if PlatformRegistry.global_platform_registry is None:
             PlatformRegistry.global_platform_registry = PlatformRegistry()
@@ -148,27 +157,32 @@ class PlatformRegistry:
         # 从用户平台目录加载额外平台
         platform_dir = PlatformRegistry.get_platform_dir()
         if platform_dir and os.path.exists(platform_dir):
-            for platform_name, platform_class in PlatformRegistry.load_platform_from_dir(platform_dir).items():
+            for (
+                platform_name,
+                platform_class,
+            ) in PlatformRegistry.load_platform_from_dir(platform_dir).items():
                 self.register_platform(platform_name, platform_class)
         platform_dir = os.path.dirname(__file__)
         if platform_dir and os.path.exists(platform_dir):
-            for platform_name, platform_class in PlatformRegistry.load_platform_from_dir(platform_dir).items():
+            for (
+                platform_name,
+                platform_class,
+            ) in PlatformRegistry.load_platform_from_dir(platform_dir).items():
                 self.register_platform(platform_name, platform_class)
 
-
     def get_normal_platform(self) -> BasePlatform:
         platform_name = get_normal_platform_name()
         model_name = get_normal_model_name()
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name) # type: ignore
-        return platform # type: ignore
+        platform.set_model_name(model_name)  # type: ignore
+        return platform  # type: ignore
 
     def get_thinking_platform(self) -> BasePlatform:
         platform_name = get_thinking_platform_name()
         model_name = get_thinking_model_name()
         platform = self.create_platform(platform_name)
-        platform.set_model_name(model_name) # type: ignore
-        return platform # type: ignore
+        platform.set_model_name(model_name)  # type: ignore
+        return platform  # type: ignore
 
     def register_platform(self, name: str, platform_class: Type[BasePlatform]) -> None:
         """Register platform class
@@ -203,4 +217,4 @@ class PlatformRegistry:
 
     def get_available_platforms(self) -> List[str]:
         """Get available platform list"""
-        return list(self.platforms.keys())
+        return list(self.platforms.keys())