jarvis-ai-assistant 0.1.209__tar.gz → 0.1.210__tar.gz

{jarvis_ai_assistant-0.1.209/src/jarvis_ai_assistant.egg-info → jarvis_ai_assistant-0.1.210}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.1.209
+Version: 0.1.210
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -55,6 +55,7 @@ Requires-Dist: openai==1.78.1
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pyte==0.8.2
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: httpx>=0.28.1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.1.209"
+version = "0.1.210"
 description = "Jarvis: An AI assistant that uses tools to interact with the system"
 readme = "README.md"
 authors = [{ name = "skyfire", email = "skyfireitdiy@hotmail.com" }]
@@ -37,6 +37,7 @@ dependencies = [
     "tabulate==0.9.0",
     "pyte==0.8.2",
     "pyyaml>=6.0.2",
+    "httpx>=0.28.1",
 ]
 requires-python = ">=3.8"
 

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages  # type: ignore
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.1.209",
+    version="0.1.210",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",
@@ -32,6 +32,7 @@ setup(
         "tabulate==0.9.0",
         "pyte==0.8.2",
         "pyyaml>=6.0.2",
+        "httpx>=0.28.1",
     ],
     extras_require={"dev": ["pytest", "black", "isort", "mypy", "build", "twine"]},
     entry_points={

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/src/jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.209"
+__version__ = "0.1.210"

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/src/jarvis/jarvis_code_agent/code_agent.py

@@ -130,6 +130,8 @@ class CodeAgent:
             platform=platform_instance,
             input_handler=[shell_input_handler, builtin_input_handler],
             need_summary=need_summary,
+            use_methodology=False,  # 禁用方法论
+            use_analysis=False      # 禁用分析
         )
 
         self.agent.set_after_tool_call_cb(self.after_tool_call_cb)

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/src/jarvis/jarvis_platform/tongyi.py

@@ -159,88 +159,93 @@ class TongyiPlatform(BasePlatform):
         }
 
         try:
-            response = while_success(
-                lambda: http.post(url, headers=headers, json=payload, stream=True),
+            # 使用新的stream_post接口发送消息请求，获取流式响应
+            response_stream = while_success(
+                lambda: http.stream_post(url, headers=headers, json=payload),
                 sleep_time=5,
             )
-            if response.status_code != 200:
-                raise Exception(f"HTTP {response.status_code}: {response.text}")
+
             msg_id = ""
             session_id = ""
             thinking_content = ""
             text_content = ""
             in_thinking = False
-            for line in response.iter_lines():
-                if not line:
-                    continue
+            response_data = b""
 
-                # httpx 返回字符串，requests 返回字节，需要兼容处理
-                if isinstance(line, bytes):
-                    line_str = line.decode("utf-8")
-                else:
-                    line_str = str(line)
-
-                if not line_str.startswith("data: "):
-                    continue
+            # 处理流式响应
+            for chunk in response_stream:
+                response_data += chunk
 
+                # 尝试解析SSE格式的数据
                 try:
-                    data = json.loads(line_str[6:])
-                    # 记录消息ID和会话ID
-                    if "msgId" in data:
-                        msg_id = data["msgId"]
-                    if "sessionId" in data:
-                        session_id = data["sessionId"]
-
-                    if "contents" in data and len(data["contents"]) > 0:
-                        for content in data["contents"]:
-                            if content.get("contentType") == "think":
-                                if not in_thinking:
-                                    yield "<think>\n\n"
-                                    in_thinking = True
-                                if content.get("incremental"):
-                                    tmp_content = json.loads(content.get("content"))[
-                                        "content"
-                                    ]
-                                    thinking_content += tmp_content
-                                    yield tmp_content
-                                else:
-                                    tmp_content = json.loads(content.get("content"))[
-                                        "content"
-                                    ]
-                                    if len(thinking_content) < len(tmp_content):
-                                        yield tmp_content[len(thinking_content) :]
-                                        thinking_content = tmp_content
-                                    else:
-                                        # thinking_content = "aaa</thi"
-                                        # tmp_content = "aaa"
-                                        # 应该yield nk>
-                                        # print("\n")
-                                        # print(len(thinking_content))
-                                        # print(len(tmp_content))
-                                        # print("--------------------------------")
-                                        # print(thinking_content)
-                                        # print("--------------------------------")
-                                        # print(tmp_content)
-                                        # print("--------------------------------")
-                                        yield "\r\n</think>\n"[
-                                            len(thinking_content) - len(tmp_content) :
-                                        ]
-                                        thinking_content = tmp_content
-                                    in_thinking = False
-                            elif content.get("contentType") == "text":
-                                if in_thinking:
-                                    continue
-                                if content.get("incremental"):
-                                    tmp_content = content.get("content")
-                                    text_content += tmp_content
-                                    yield tmp_content
-                                else:
-                                    tmp_content = content.get("content")
-                                    if len(text_content) < len(tmp_content):
-                                        yield tmp_content[len(text_content) :]
-                                        text_content = tmp_content
-
-                except json.JSONDecodeError:
+                    # 查找完整的数据行
+                    lines = response_data.decode("utf-8").split("\n")
+                    response_data = b""  # 重置缓冲区
+
+                    for line in lines:
+                        if not line.strip():
+                            continue
+
+                        # SSE格式的行通常以"data: "开头
+                        if line.startswith("data: "):
+                            try:
+                                data = json.loads(line[6:])
+                                # 记录消息ID和会话ID
+                                if "msgId" in data:
+                                    msg_id = data["msgId"]
+                                if "sessionId" in data:
+                                    session_id = data["sessionId"]
+
+                                if "contents" in data and len(data["contents"]) > 0:
+                                    for content in data["contents"]:
+                                        if content.get("contentType") == "think":
+                                            if not in_thinking:
+                                                yield "<think>\n\n"
+                                                in_thinking = True
+                                            if content.get("incremental"):
+                                                tmp_content = json.loads(
+                                                    content.get("content")
+                                                )["content"]
+                                                thinking_content += tmp_content
+                                                yield tmp_content
+                                            else:
+                                                tmp_content = json.loads(
+                                                    content.get("content")
+                                                )["content"]
+                                                if len(thinking_content) < len(
+                                                    tmp_content
+                                                ):
+                                                    yield tmp_content[
+                                                        len(thinking_content) :
+                                                    ]
+                                                    thinking_content = tmp_content
+                                                else:
+                                                    yield "\r\n</think>\n"[
+                                                        len(thinking_content)
+                                                        - len(tmp_content) :
+                                                    ]
+                                                    thinking_content = tmp_content
+                                                in_thinking = False
+                                        elif content.get("contentType") == "text":
+                                            if in_thinking:
+                                                continue
+                                            if content.get("incremental"):
+                                                tmp_content = content.get("content")
+                                                text_content += tmp_content
+                                                yield tmp_content
+                                            else:
+                                                tmp_content = content.get("content")
+                                                if len(text_content) < len(tmp_content):
+                                                    yield tmp_content[
+                                                        len(text_content) :
+                                                    ]
+                                                    text_content = tmp_content
+
+                            except json.JSONDecodeError:
+                                continue
+
+                except UnicodeDecodeError:
+                    # 如果解码失败，继续累积数据
                     continue
 
             self.msg_id = msg_id

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/src/jarvis/jarvis_platform/yuanbao.py

@@ -468,63 +468,66 @@ class YuanbaoPlatform(BasePlatform):
             payload["displayPrompt"] = payload["prompt"]
 
         try:
-            # 发送消息请求，获取流式响应
-            response = while_success(
-                lambda: http.post(
-                    url,
-                    headers=headers,
-                    json=payload,
-                    stream=True,
-                ),
+            # 使用新的stream_post接口发送消息请求，获取流式响应
+            response_stream = while_success(
+                lambda: http.stream_post(url, headers=headers, json=payload),
                 sleep_time=5,
             )
 
-            # 检查响应状态
-            if response.status_code != 200:
-                error_msg = f"发送消息失败，状态码: {response.status_code}"
-                if hasattr(response, "text"):
-                    error_msg += f", 响应: {response.text}"
-                raise Exception(error_msg)
-
             in_thinking = False
-
-            # 处理SSE流响应
-            for line in response.iter_lines():
-                if not line:
+            response_data = b""
+
+            # 处理流式响应
+            for chunk in response_stream:
+                response_data += chunk
+
+                # 尝试解析SSE格式的数据
+                try:
+                    # 查找完整的数据行
+                    lines = response_data.decode("utf-8").split("\n")
+                    response_data = b""  # 重置缓冲区
+
+                    for line in lines:
+                        if not line.strip():
+                            continue
+
+                        # SSE格式的行通常以"data: "开头
+                        if line.startswith("data: "):
+                            try:
+                                data_str = line[6:]  # 移除"data: "前缀
+
+                                # 检查结束标志
+                                if data_str == "[DONE]":
+                                    self.first_chat = False
+                                    return None
+
+                                data = json.loads(data_str)
+
+                                # 处理文本类型的消息
+                                if data.get("type") == "text":
+                                    if in_thinking:
+                                        yield "</think>\n"
+                                        in_thinking = False
+                                    msg = data.get("msg", "")
+                                    if msg:
+                                        yield msg
+
+                                # 处理思考中的消息
+                                elif data.get("type") == "think":
+                                    if not in_thinking:
+                                        yield "<think>\n"
+                                        in_thinking = True
+                                    think_content = data.get("content", "")
+                                    if think_content:
+                                        yield think_content
+
+                            except json.JSONDecodeError:
+                                pass
+
+                except UnicodeDecodeError:
+                    # 如果解码失败，继续累积数据
                     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":
-                            if in_thinking:
-                                yield "</think>\n"
-                                in_thinking = False
-                            msg = data.get("msg", "")
-                            if msg:
-                                yield msg
-
-                        # 处理思考中的消息
-                        elif data.get("type") == "think":
-                            if not in_thinking:
-                                yield "<think>\n"
-                                in_thinking = True
-                            think_content = data.get("content", "")
-                            if think_content:
-                                yield think_content
-
-                    except json.JSONDecodeError:
-                        pass
-
-                # 检测结束标志
-                elif line_str == "data: [DONE]":
-                    return None
             self.first_chat = False
             return None
 

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/src/jarvis/jarvis_utils/git_utils.py

@@ -9,6 +9,7 @@ Git工具模块
 - 获取最新提交的哈希值
 - 从Git差异中提取修改的行范围
 """
+import datetime
 import os
 import re
 import subprocess
@@ -344,6 +345,19 @@ def check_and_update_git_repo(repo_path: str) -> bool:
         return False
 
     try:
+        # 检查最新提交时间是否为今天
+        commit_date_result = subprocess.run(
+            ["git", "log", "-1", "--format=%cd", "--date=short"],
+            cwd=git_root,
+            capture_output=True,
+            text=True,
+        )
+        if commit_date_result.returncode == 0:
+            commit_date = commit_date_result.stdout.strip()
+            today = datetime.date.today().strftime("%Y-%m-%d")
+            if commit_date == today:
+                return False
+
         # 检查是否有未提交的修改
         if has_uncommitted_changes():
             return False

jarvis_ai_assistant-0.1.210/src/jarvis/jarvis_utils/http.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+
+import httpx
+from typing import Any, Dict, Optional, Union, AsyncGenerator, Generator
+
+
+def get_httpx_client() -> httpx.Client:
+    """
+    获取一个配置好的 httpx.Client 对象
+
+    返回:
+        httpx.Client 对象
+    """
+    client = httpx.Client(
+        timeout=httpx.Timeout(None),  # 永不超时
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+        },
+    )
+    return client
+
+
+def get_async_httpx_client() -> httpx.AsyncClient:
+    """
+    获取一个配置好的 httpx.AsyncClient 对象
+
+    返回:
+        httpx.AsyncClient 对象
+    """
+    client = httpx.AsyncClient(
+        timeout=httpx.Timeout(None),  # 永不超时
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+        },
+    )
+    return client
+
+
+# 增强版本的 HTTP 请求方法（使用 httpx 实现，带重试机制，解决连接中断问题）
+def post(
+    url: str,
+    data: Optional[Any] = None,
+    json: Optional[Dict[str, Any]] = None,
+    **kwargs,
+) -> httpx.Response:
+    """
+    发送增强版永不超时的 POST 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        data: (可选) 请求体数据 (表单数据或原始数据)
+        json: (可选) JSON 数据，会自动设置 Content-Type
+        **kwargs: 其他传递给 httpx.post 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    client = get_httpx_client()
+    try:
+        response = client.post(url=url, data=data, json=json, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
+
+
+def get(url: str, **kwargs) -> httpx.Response:
+    """
+    发送增强版永不超时的 GET 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        **kwargs: 其他传递给 httpx.get 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    client = get_httpx_client()
+    try:
+        response = client.get(url=url, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
+
+
+def put(url: str, data: Optional[Any] = None, **kwargs) -> httpx.Response:
+    """
+    发送增强版永不超时的 PUT 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        data: (可选) 请求体数据 (表单数据或原始数据)
+        **kwargs: 其他传递给 httpx.put 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    client = get_httpx_client()
+    try:
+        response = client.put(url=url, data=data, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
+
+
+def delete(url: str, **kwargs) -> httpx.Response:
+    """
+    发送增强版永不超时的 DELETE 请求，使用 httpx 实现，包含重试机制
+
+    参数:
+        url: 请求的 URL
+        **kwargs: 其他传递给 httpx.delete 的参数
+
+    返回:
+        httpx.Response 对象
+
+    注意:
+        此方法使用 httpx 实现，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
+    """
+    client = get_httpx_client()
+    try:
+        response = client.delete(url=url, **kwargs)
+        response.raise_for_status()
+        return response
+    finally:
+        client.close()
+
+
+# 同步流式POST请求方法
+def stream_post(
+    url: str,
+    data: Optional[Any] = None,
+    json: Optional[Dict[str, Any]] = None,
+    **kwargs,
+) -> Generator[bytes, None, None]:
+    """
+    发送流式 POST 请求，使用 httpx 实现，返回标准 Generator
+
+    参数:
+        url: 请求的 URL
+        data: (可选) 请求体数据 (表单数据或原始数据)
+        json: (可选) JSON 数据，会自动设置 Content-Type
+        **kwargs: 其他传递给 httpx.post 的参数
+
+    返回:
+        Generator[bytes, None, None]: 字节流生成器
+
+    注意:
+        此方法使用 httpx 实现流式请求，适用于处理大文件下载或流式响应
+    """
+    client = get_httpx_client()
+    try:
+        with client.stream("POST", url, data=data, json=json, **kwargs) as response:
+            response.raise_for_status()
+            for chunk in response.iter_bytes():
+                yield chunk
+    finally:
+        client.close()

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210/src/jarvis_ai_assistant.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.1.209
+Version: 0.1.210
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -55,6 +55,7 @@ Requires-Dist: openai==1.78.1
 Requires-Dist: tabulate==0.9.0
 Requires-Dist: pyte==0.8.2
 Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: httpx>=0.28.1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"

{jarvis_ai_assistant-0.1.209 → jarvis_ai_assistant-0.1.210}/src/jarvis_ai_assistant.egg-info/requires.txt

@@ -13,6 +13,7 @@ openai==1.78.1
 tabulate==0.9.0
 pyte==0.8.2
 pyyaml>=6.0.2
+httpx>=0.28.1
 
 [dev]
 pytest

jarvis_ai_assistant-0.1.209/src/jarvis/jarvis_utils/http.py

@@ -1,104 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import requests
-from typing import Any, Dict, Optional, Union
-
-
-def get_session() -> requests.Session:
-    """
-    获取一个永不超时的 requests.Session 对象
-
-    返回:
-        requests.Session 对象
-    """
-    session = requests.Session()
-
-    # 设置默认请求头以优化连接
-    session.headers.update(
-        {"Connection": "keep-alive"}
-    )
-
-    return session
-
-
-# 增强版本的 HTTP 请求方法（带重试机制，解决连接中断问题）
-def post(
-    url: str,
-    data: Optional[Union[Dict[str, Any], str, bytes]] = None,
-    json: Optional[Dict[str, Any]] = None,
-    **kwargs,
-) -> requests.Response:
-    """
-    发送增强版永不超时的 POST 请求，包含重试机制
-
-    参数:
-        url: 请求的 URL
-        data: (可选) 请求体数据 (表单数据或原始数据)
-        json: (可选) JSON 数据，会自动设置 Content-Type
-        **kwargs: 其他传递给 requests.post 的参数
-
-    返回:
-        requests.Response 对象
-
-    注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
-    """
-    session = get_session()
-    return session.post(url=url, data=data, json=json, **kwargs)
-
-
-def get(url: str, **kwargs) -> requests.Response:
-    """
-    发送增强版永不超时的 GET 请求，包含重试机制
-
-    参数:
-        url: 请求的 URL
-        **kwargs: 其他传递给 requests.get 的参数
-
-    返回:
-        requests.Response 对象
-
-    注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
-    """
-    session = get_session()
-    return session.get(url=url, **kwargs)
-
-
-def put(
-    url: str, data: Optional[Union[Dict[str, Any], str, bytes]] = None, **kwargs
-) -> requests.Response:
-    """
-    发送增强版永不超时的 PUT 请求，包含重试机制
-
-    参数:
-        url: 请求的 URL
-        data: (可选) 请求体数据 (表单数据或原始数据)
-        **kwargs: 其他传递给 requests.put 的参数
-
-    返回:
-        requests.Response 对象
-
-    注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
-    """
-    session = get_session()
-    return session.put(url=url, data=data, **kwargs)
-
-
-def delete(url: str, **kwargs) -> requests.Response:
-    """
-    发送增强版永不超时的 DELETE 请求，包含重试机制
-
-    参数:
-        url: 请求的 URL
-        **kwargs: 其他传递给 requests.delete 的参数
-
-    返回:
-        requests.Response 对象
-
-    注意:
-        此方法使用增强的永不超时设置，包含自动重试机制，适用于解决"Response ended prematurely"等连接问题
-    """
-    session = get_session()
-    return session.delete(url=url, **kwargs)