jarvis-ai-assistant 0.1.173__py3-none-any.whl → 0.1.175__py3-none-any.whl

jarvis/jarvis_platform/yuanbao.py

@@ -11,6 +11,10 @@ from PIL import Image
 from yaspin import yaspin
 from yaspin.spinners import Spinners
 from yaspin.api import Yaspin
+from rich.live import Live
+from rich.text import Text
+from rich.panel import Panel
+from rich import box
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import while_success
@@ -387,7 +391,6 @@ class YuanbaoPlatform(BasePlatform):
         
         参数:
             message: 要发送的消息文本
-            file_list: 可选的上传和附加文件路径列表
             
         返回:
             模型的响应
@@ -425,7 +428,9 @@ class YuanbaoPlatform(BasePlatform):
         self.multimedia = []
 
         if self.web:
-            payload["supportFunctions"] = ["supportInternetSearch"]
+            payload["supportFunctions"] = ["openInternetSearch"]
+        else:
+            payload["supportFunctions"] = ["autoInternetSearch"]
 
         # 添加系统消息（如果是第一次对话）
         if self.first_chat and self.system_message:
@@ -449,45 +454,82 @@ class YuanbaoPlatform(BasePlatform):
 
             full_response = ""
             is_text_block = False
+            thinking_content = ""
 
-            # 处理SSE流响应
-            for line in response.iter_lines():
-                if not line:
-                    continue
-
-                line_str = line.decode('utf-8')
-
-                # SSE格式的行通常以"data: "开头
-                if line_str.startswith("data: "):
-                    try:
-                        data_str = line_str[6:]  # 移除"data: "前缀
-                        data = json.loads(data_str)
-
-                        # 处理文本类型的消息
-                        if data.get("type") == "text":
-                            is_text_block = True
-                            msg = data.get("msg", "")
-                            if msg:
-                                if not self.suppress_output:
-                                    PrettyOutput.print_stream(msg)
-                                full_response += msg
-
-                        # 处理思考中的消息（可选展示）
-                        elif data.get("type") == "think" and not self.suppress_output:
-                            think_content = data.get("content", "")
-                            # 可以选择性地显示思考过程，但不加入最终响应
-                            PrettyOutput.print_stream(f"{think_content}", is_thinking=True)
-                            pass
+            # 使用Rich的Live组件来实时展示更新
+            if not self.suppress_output:
+                text_content = Text()
+                panel = Panel(text_content, title=f"[bold blue]{self.model_name}[/bold blue]", 
+                          subtitle="思考中...", border_style="blue", box=box.ROUNDED)
+                with Live(panel, refresh_per_second=3, transient=False) as live:
+                    # 处理SSE流响应
+                    for line in response.iter_lines():
+                        if not line:
+                            continue
+
+                        line_str = line.decode('utf-8')
+
+                        # SSE格式的行通常以"data: "开头
+                        if line_str.startswith("data: "):
+                            try:
+                                data_str = line_str[6:]  # 移除"data: "前缀
+                                data = json.loads(data_str)
+
+                                # 处理文本类型的消息
+                                if data.get("type") == "text":
+                                    is_text_block = True
+                                    msg = data.get("msg", "")
+                                    if msg:
+                                        full_response += msg
+                                        text_content.append(msg)
+                                        panel.subtitle = "正在回答..."
+                                        live.update(panel)
+
+                                # 处理思考中的消息
+                                elif data.get("type") == "think":
+                                    think_content = data.get("content", "")
+                                    if think_content:
+                                        thinking_content = think_content
+                                        panel.subtitle = f"思考中: {thinking_content}"
+                                        live.update(panel)
+
+                            except json.JSONDecodeError:
+                                pass
+
+                        # 检测结束标志
+                        elif line_str == "data: [DONE]":
+                            break
+                    
+                    # 显示对话完成状态
+                    panel.subtitle = "[bold green]对话完成[/bold green]"
+                    live.update(panel)
+            else:
+                # 如果禁止输出，则静默处理
+                for line in response.iter_lines():
+                    if not line:
+                        continue
 
-                    except json.JSONDecodeError:
-                        pass
+                    line_str = line.decode('utf-8')
 
-                # 检测结束标志
-                elif line_str == "data: [DONE]":
-                    break
+                    # SSE格式的行通常以"data: "开头
+                    if line_str.startswith("data: "):
+                        try:
+                            data_str = line_str[6:]  # 移除"data: "前缀
+                            data = json.loads(data_str)
 
-            if not self.suppress_output:
-                PrettyOutput.print_stream_end()
+                            # 处理文本类型的消息
+                            if data.get("type") == "text":
+                                is_text_block = True
+                                msg = data.get("msg", "")
+                                if msg:
+                                    full_response += msg
+
+                        except json.JSONDecodeError:
+                            pass
+
+                    # 检测结束标志
+                    elif line_str == "data: [DONE]":
+                        break
 
             return full_response
 

jarvis/jarvis_platform_manager/main.py

@@ -51,6 +51,7 @@ def list_platforms():
 def chat_with_model(platform_name: str, model_name: str):
     """Chat with specified platform and model"""
     registry = PlatformRegistry.get_global_platform_registry()
+    conversation_history = []  # 存储对话记录
 
     # Create platform instance
     platform = registry.create_platform(platform_name)
@@ -63,12 +64,13 @@ def chat_with_model(platform_name: str, model_name: str):
         platform.set_model_name(model_name)
         platform.set_suppress_output(False)
         PrettyOutput.print(f"连接到 {platform_name} 平台 {model_name} 模型", OutputType.SUCCESS)
-        PrettyOutput.print("可用命令: /bye - 退出聊天, /clear - 清除会话, /upload - 上传文件, /shell - 执行shell命令", OutputType.INFO)
+        PrettyOutput.print("可用命令: /bye - 退出聊天, /clear - 清除会话, /upload - 上传文件, /shell - 执行shell命令, /save - 保存当前对话, /saveall - 保存所有对话", OutputType.INFO)
 
         # Start conversation loop
         while True:
             # Get user input
             user_input = get_multiline_input("")
+            conversation_history.append({"role": "user", "content": user_input})  # 记录用户输入
 
             # Check if input is cancelled
             if user_input.strip() == "/bye":
@@ -84,6 +86,7 @@ def chat_with_model(platform_name: str, model_name: str):
                 try:
                     platform.reset()
                     platform.set_model_name(model_name)  # Reinitialize session
+                    conversation_history = []  # 重置对话记录
                     PrettyOutput.print("会话已清除", OutputType.SUCCESS)
                 except Exception as e:
                     PrettyOutput.print(f"清除会话失败: {str(e)}", OutputType.ERROR)
@@ -110,6 +113,52 @@ def chat_with_model(platform_name: str, model_name: str):
                     PrettyOutput.print(f"上传文件失败: {str(e)}", OutputType.ERROR)
                 continue
 
+            # Check if it is a save command
+            if user_input.strip().startswith("/save"):
+                try:
+                    file_path = user_input.strip()[5:].strip()
+                    if not file_path:
+                        PrettyOutput.print("请指定保存文件名，例如: /save last_message.txt", OutputType.WARNING)
+                        continue
+                    
+                    # Remove quotes if present
+                    if (file_path.startswith('"') and file_path.endswith('"')) or (file_path.startswith("'") and file_path.endswith("'")):
+                        file_path = file_path[1:-1]
+                    
+                    # Write last message content to file
+                    if conversation_history:
+                        with open(file_path, 'w', encoding='utf-8') as f:
+                            last_entry = conversation_history[-1]
+                            f.write(f"{last_entry['content']}\n")
+                        PrettyOutput.print(f"最后一条消息内容已保存到 {file_path}", OutputType.SUCCESS)
+                    else:
+                        PrettyOutput.print("没有可保存的消息", OutputType.WARNING)
+                except Exception as e:
+                    PrettyOutput.print(f"保存消息失败: {str(e)}", OutputType.ERROR)
+                continue
+
+            # Check if it is a saveall command
+            if user_input.strip().startswith("/saveall"):
+                try:
+                    file_path = user_input.strip()[8:].strip()
+                    if not file_path:
+                        PrettyOutput.print("请指定保存文件名，例如: /saveall all_conversations.txt", OutputType.WARNING)
+                        continue
+                    
+                    # Remove quotes if present
+                    if (file_path.startswith('"') and file_path.endswith('"')) or (file_path.startswith("'") and file_path.endswith("'")):
+                        file_path = file_path[1:-1]
+                    
+                    # Write full conversation history to file
+                    with open(file_path, 'w', encoding='utf-8') as f:
+                        for entry in conversation_history:
+                            f.write(f"{entry['role']}: {entry['content']}\n\n")
+                    
+                    PrettyOutput.print(f"所有对话已保存到 {file_path}", OutputType.SUCCESS)
+                except Exception as e:
+                    PrettyOutput.print(f"保存所有对话失败: {str(e)}", OutputType.ERROR)
+                continue
+
             # Check if it is a shell command
             if user_input.strip().startswith("/shell"):
                 try:
@@ -133,6 +182,8 @@ def chat_with_model(platform_name: str, model_name: str):
                 response = platform.chat_until_success(user_input)
                 if not response:
                     PrettyOutput.print("没有有效的回复", OutputType.WARNING)
+                else:
+                    conversation_history.append({"role": "assistant", "content": response})  # 记录模型回复
 
             except Exception as e:
                 PrettyOutput.print(f"聊天失败: {str(e)}", OutputType.ERROR)

jarvis/jarvis_tools/cli/main.py

@@ -6,7 +6,26 @@ from jarvis.jarvis_utils.utils import init_env
 
 
 def main() -> int:
-    """命令行工具入口，提供工具列表查看和工具调用功能"""
+    """
+    命令行工具入口，提供工具列表查看和工具调用功能
+    
+    功能:
+        1. 列出所有可用工具 (list命令)
+        2. 调用指定工具 (call命令)
+    
+    参数:
+        通过命令行参数传递，包括:
+        - list: 列出工具
+            --json: 以JSON格式输出
+            --detailed: 显示详细信息
+        - call: 调用工具
+            tool_name: 工具名称
+            --args: 工具参数(JSON格式)
+            --args-file: 从文件加载工具参数
+    
+    返回值:
+        int: 0表示成功，非0表示错误
+    """
     import argparse
     import json
 
@@ -34,24 +53,24 @@ def main() -> int:
     registry = ToolRegistry()
 
     if args.command == "list":
-        tools = registry.get_all_tools()
+        tools = registry.get_all_tools()  # 从注册表获取所有工具信息
 
         if args.json:
             if args.detailed:
-                print(json.dumps(tools, indent=2, ensure_ascii=False))
+                print(json.dumps(tools, indent=2, ensure_ascii=False))  # 输出完整JSON格式
             else:
                 simple_tools = [
                     {"name": t["name"], "description": t["description"]} for t in tools
-                ]
+                ]  # 简化工具信息
                 print(json.dumps(simple_tools, indent=2, ensure_ascii=False))
         else:
-            PrettyOutput.section("可用工具列表", OutputType.SYSTEM)
+            PrettyOutput.section("可用工具列表", OutputType.SYSTEM)  # 使用美化输出
             for tool in tools:
                 print(f"\n✅ {tool['name']}")
                 print(f"   描述: {tool['description']}")
                 if args.detailed:
                     print(f"   参数:")
-                    print(tool["parameters"])
+                    print(tool["parameters"])  # 显示详细参数信息
 
     elif args.command == "call":
         tool_name = args.tool_name
@@ -63,11 +82,11 @@ def main() -> int:
             print(f"可用工具: {available_tools}")
             return 1
 
-        # 获取参数
+        # 获取参数: 支持从命令行直接传入或从文件加载
         tool_args = {}
         if args.args:
             try:
-                tool_args = json.loads(args.args)
+                tool_args = json.loads(args.args)  # 解析JSON格式参数
             except json.JSONDecodeError:
                 PrettyOutput.print("错误: 参数必须是有效的JSON格式", OutputType.ERROR)
                 return 1
@@ -75,14 +94,14 @@ def main() -> int:
         elif args.args_file:
             try:
                 with open(args.args_file, "r", encoding="utf-8") as f:
-                    tool_args = json.load(f)
+                    tool_args = json.load(f)  # 从文件加载JSON参数
             except (json.JSONDecodeError, FileNotFoundError) as e:
                 PrettyOutput.print(
                     f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR
                 )
                 return 1
 
-        # 检查必需参数
+        # 检查必需参数是否完整
         required_params = tool_obj.parameters.get("required", [])
         missing_params = [p for p in required_params if p not in tool_args]
 
@@ -98,10 +117,10 @@ def main() -> int:
                 print(f"  - {param_name}: {desc}")
             return 1
 
-        # 执行工具
+        # 执行工具并处理结果
         result = registry.execute_tool(tool_name, tool_args)
 
-        # 显示结果
+        # 显示执行结果
         if result["success"]:
             PrettyOutput.section(f"工具 {tool_name} 执行成功", OutputType.SUCCESS)
         else:

jarvis/jarvis_tools/registry.py

@@ -33,8 +33,8 @@ tool_call_help = f"""
 want: 想要从执行结果中获取到的信息，如果工具输出内容过长，会根据此字段尝试提取有效信息
 name: 工具名称
 arguments:
-    param1: 值1
-    param2: 值2
+  param1: 值1
+  param2: 值2
 {ct("TOOL_CALL")}
 </format>
 
@@ -49,7 +49,7 @@ arguments:
 <rule>
 ### 2. 严格遵守格式
 - 完全按照上述格式
-- 使用正确的YAML缩进
+- 使用正确的YAML格式，2个空格作为缩进
 - 包含所有必需参数
 </rule>
 
@@ -72,15 +72,15 @@ arguments:
 
 <string_format>
 # 📝 字符串参数格式
-始终使用 | 语法表示字符串参数：
+始终使用 |2 语法表示字符串参数，防止多行字符串行首空格引起歧义：
 
 {ot("TOOL_CALL")}
 want: 当前的git状态，期望获取xxx的提交记录
 name: execute_script
 arguments:
-    interpreter: bash
-    script_cotent: |
-        git status --porcelain
+  interpreter: bash
+  script_cotent: |2
+    git status --porcelain
 {ct("TOOL_CALL")}
 </string_format>
 
@@ -96,7 +96,7 @@ arguments:
 <common_errors>
 # ⚠️ 常见错误
 - 同时调用多个工具
-- 字符串参数缺少 |
+- 字符串参数缺少 |2
 - 假设工具结果
 - 创建虚构对话
 - 在没有所需信息的情况下继续

jarvis/jarvis_utils/config.py

@@ -160,4 +160,4 @@ def get_max_big_content_size() -> int:
     返回：
         int: 最大大内容大小，默认为1MB
     """
-    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '64000'))
+    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '96000'))

jarvis/jarvis_utils/embedding.py

@@ -20,131 +20,72 @@ def get_context_token_count(text: str) -> int:
         int: 文本中的token数量
     """
     try:
-        # 使用擅长处理通用文本的快速分词器
         tokenizer = load_tokenizer()
-        chunks = split_text_into_chunks(text, 512)
-        return sum([len(tokenizer.encode(chunk)) for chunk in chunks]) # type: ignore
-
+        # 分批处理长文本，确保不超过模型最大长度
+        total_tokens = 0
+        chunk_size = 100  # 每次处理100个字符，避免超过模型最大长度（考虑到中文字符可能被编码成多个token）
+        for i in range(0, len(text), chunk_size):
+            chunk = text[i:i + chunk_size]
+            tokens = tokenizer.encode(chunk)  # type: ignore
+            total_tokens += len(tokens)
+        return total_tokens
     except Exception as e:
         PrettyOutput.print(f"计算token失败: {str(e)}", OutputType.WARNING)
-        # 回退到基于字符的粗略估计
         return len(text) // 4  # 每个token大约4个字符的粗略估计
 
 def split_text_into_chunks(text: str, max_length: int = 512, min_length: int = 50) -> List[str]:
-    """将文本分割成带重叠窗口的块，优化RAG检索效果。
+    """将文本分割成块，基于token数量进行切割。
 
     参数：
         text: 要分割的输入文本
-        max_length: 每个块的最大长度
-        min_length: 每个块的最小长度（除了最后一块可能较短）
+        max_length: 每个块的最大token数量
+        min_length: 每个块的最小token数量（除了最后一块可能较短）
 
     返回：
-        List[str]: 文本块列表，每个块的长度尽可能接近但不超过max_length
+        List[str]: 文本块列表，每个块的token数量不超过max_length且不小于min_length
     """
     if not text:
         return []
 
-    # 如果文本长度小于最大长度，直接返回整个文本
-    if len(text) <= max_length:
-        return [text]
-
-    # 预处理：规范化文本，移除多余空白字符
-    text = ' '.join(text.split())
-
-    # 中英文标点符号集合，优化RAG召回的句子边界
-    primary_punctuation = {'.', '!', '?', '\n', '。', '！', '？'}  # 主要句末标点
-    secondary_punctuation = {'；', '：', '…', ';', ':'}  # 次级分隔符
-    tertiary_punctuation = {',', '，', '、', ')', '）', ']', '】', '}', '》', '"', "'"}  # 最低优先级
-
-    chunks = []
-    start = 0
-
-    while start < len(text):
-        # 初始化结束位置为最大可能长度
-        end = min(start + max_length, len(text))
-
-        # 只有当不是最后一块且结束位置等于最大长度时，才尝试寻找句子边界
-        if end < len(text) and end == start + max_length:
-            # 优先查找段落边界，这对RAG特别重要
-            paragraph_boundary = text.rfind('\n\n', start, end)
-            if paragraph_boundary > start and paragraph_boundary < end - min_length:  # 确保不会切得太短
-                end = paragraph_boundary + 2
+    try:
+        chunks = []
+        current_chunk = ""
+        current_tokens = 0
+        
+        # 按较大的块处理文本，避免破坏token边界
+        chunk_size = 50  # 每次处理50个字符
+        for i in range(0, len(text), chunk_size):
+            chunk = text[i:i + chunk_size]
+            chunk_tokens = get_context_token_count(chunk)
+            
+            # 如果当前块加上新块会超过最大长度，且当前块已经达到最小长度，则保存当前块
+            if current_tokens + chunk_tokens > max_length and current_tokens >= min_length:
+                chunks.append(current_chunk)
+                current_chunk = chunk
+                current_tokens = chunk_tokens
             else:
-                # 寻找句子边界，从end-1位置开始
-                found_boundary = False
-                best_boundary = -1
-
-                # 扩大搜索范围以找到更好的语义边界
-                search_range = min(120, end - start - min_length)  # 扩大搜索范围，但确保新块不小于min_length
-
-                # 先尝试找主要标点（句号等）
-                for i in range(end-1, max(start, end-search_range), -1):
-                    if text[i] in primary_punctuation:
-                        best_boundary = i
-                        found_boundary = True
-                        break
-
-                # 如果没找到主要标点，再找次要标点（分号、冒号等）
-                if not found_boundary:
-                    for i in range(end-1, max(start, end-search_range), -1):
-                        if text[i] in secondary_punctuation:
-                            best_boundary = i
-                            found_boundary = True
-                            break
-
-                # 最后考虑逗号和其他可能的边界
-                if not found_boundary:
-                    for i in range(end-1, max(start, end-search_range), -1):
-                        if text[i] in tertiary_punctuation:
-                            best_boundary = i
-                            found_boundary = True
-                            break
-
-                # 如果找到了合适的边界且不会导致太短的块，使用它
-                if found_boundary and (best_boundary - start) >= min_length:
-                    end = best_boundary + 1
-
-        # 添加当前块，并确保删除开头和结尾的空白字符
-        chunk = text[start:end].strip()
-        if chunk and len(chunk) >= min_length:  # 只添加符合最小长度的非空块
-            chunks.append(chunk)
-        elif chunk and not chunks:  # 如果是第一个块且小于最小长度，也添加它
-            chunks.append(chunk)
-        elif chunk:  # 如果块太小，尝试与前一个块合并
-            if chunks:
-                if len(chunks[-1]) + len(chunk) <= max_length * 1.1:  # 允许略微超过最大长度
-                    chunks[-1] = chunks[-1] + " " + chunk
+                current_chunk += chunk
+                current_tokens += chunk_tokens
+
+        # 处理最后一个块
+        if current_chunk:
+            if current_tokens >= min_length:
+                chunks.append(current_chunk)
+            elif chunks:  # 如果最后一个块太短，尝试与前面的块合并
+                last_chunk = chunks[-1]
+                combined = last_chunk + current_chunk
+                combined_tokens = get_context_token_count(combined)
+                if combined_tokens <= max_length:
+                    chunks[-1] = combined
                 else:
-                    # 如果合并会导致太长，添加这个小块（特殊情况）
-                    chunks.append(chunk)
-
-        # 计算下一块的开始位置，调整重叠窗口大小以提高RAG检索质量
-        next_start = end - int(max_length * 0.2)  # 20%的重叠窗口大小
-
-        # 确保总是有前进，避免无限循环
-        if next_start <= start:
-            next_start = start + max(1, min_length // 2)
-
-        start = next_start
-
-    # 最后检查是否有太短的块，尝试合并相邻的短块
-    if len(chunks) > 1:
-        merged_chunks = []
-        i = 0
-        while i < len(chunks):
-            current = chunks[i]
-            # 如果当前块太短且不是最后一个块，尝试与下一个合并
-            if len(current) < min_length and i < len(chunks) - 1:
-                next_chunk = chunks[i + 1]
-                if len(current) + len(next_chunk) <= max_length * 1.1:
-                    merged_chunks.append(current + " " + next_chunk)
-                    i += 2  # 跳过下一个块
-                    continue
-            merged_chunks.append(current)
-            i += 1
-        chunks = merged_chunks
-
-    return chunks
+                    chunks.append(current_chunk)
+
+        return chunks
+
+    except Exception as e:
+        PrettyOutput.print(f"文本分割失败: {str(e)}", OutputType.WARNING)
+        # 发生错误时回退到简单的字符分割
+        return [text[i:i + max_length] for i in range(0, len(text), max_length)]
 
 
 @functools.lru_cache(maxsize=1)

jarvis/jarvis_utils/methodology.py

@@ -12,6 +12,7 @@ import json
 import tempfile
 from typing import Any, Dict, Optional
 
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_utils.config import get_data_dir
 from jarvis.jarvis_utils.output import PrettyOutput, OutputType
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -92,6 +93,42 @@ def _create_methodology_temp_file(methodologies: Dict[str, str]) -> Optional[str
         PrettyOutput.print(f"创建方法论临时文件失败: {str(e)}", OutputType.ERROR)
         return None
 
+def upload_methodology(platform: BasePlatform) -> bool:
+    """
+    上传方法论文件到指定平台
+    
+    参数：
+        platform: 平台实例，需实现upload_files方法
+    
+    返回：
+        bool: 上传是否成功
+    """
+    methodology_dir = _get_methodology_directory()
+    if not os.path.exists(methodology_dir):
+        PrettyOutput.print("方法论文档不存在", OutputType.WARNING)
+        return False
+    
+    methodologies = _load_all_methodologies()
+    if not methodologies:
+        PrettyOutput.print("没有可用的方法论文档", OutputType.WARNING)
+        return False
+    
+    temp_file_path = _create_methodology_temp_file(methodologies)
+    if not temp_file_path:
+        return False
+    
+    try:
+        if hasattr(platform, 'upload_files'):
+            return platform.upload_files([temp_file_path])
+        return False
+    finally:
+        if temp_file_path and os.path.exists(temp_file_path):
+            try:
+                os.remove(temp_file_path)
+            except Exception:
+                pass
+
+
 def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> str:
     """
     加载方法论并上传到大模型。

jarvis/jarvis_utils/output.py

@@ -204,26 +204,7 @@ class PrettyOutput:
         console.print()
         console.print(panel)
         console.print()
-    @staticmethod
-    def print_stream(text: str, is_thinking: bool = False):
-        """
-        打印流式输出，不带换行符。
-
-        参数：
-            text: 要打印的文本
-        """
-        style = RichStyle(color="bright_cyan", bold=True, frame=True, meta={"icon": "🤖"})
-        if is_thinking:
-            style = RichStyle(color="grey58", italic=True, frame=True, meta={"icon": "🤖"})
-        console.print(text, style=style, end="")
-    @staticmethod
-    def print_stream_end():
-        """
-        结束流式输出，带换行符。
-        """
-        end_style = PrettyOutput._get_style(OutputType.SUCCESS)
-        console.print("\n", style=end_style)
-        console.file.flush()
+    
     @staticmethod
     def _get_style(output_type: OutputType) -> RichStyle:
         """