vectorvein 0.1.0__tar.gz → 0.1.2__tar.gz

{vectorvein-0.1.0 → vectorvein-0.1.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: vectorvein
-Version: 0.1.0
+Version: 0.1.2
 Summary: Default template for PDM package
 Author-Email: Anderson <andersonby@163.com>
 License: MIT
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: openai>=1.37.1
 Requires-Dist: tiktoken>=0.7.0
 Requires-Dist: httpx>=0.27.0

{vectorvein-0.1.0 → vectorvein-0.1.2}/pyproject.toml

@@ -1,7 +1,4 @@
 [project]
-name = "vectorvein"
-version = "0.1.0"
-description = "Default template for PDM package"
 authors = [
     { name = "Anderson", email = "andersonby@163.com" },
 ]
@@ -13,17 +10,20 @@ dependencies = [
     "pydantic>=2.8.2",
     "Pillow>=10.4.0",
 ]
-requires-python = ">=3.8"
+description = "Default template for PDM package"
+name = "vectorvein"
 readme = "README.md"
+requires-python = ">=3.10"
+version = "0.1.2"
 
 [project.license]
 text = "MIT"
 
 [build-system]
+build-backend = "pdm.backend"
 requires = [
     "pdm-backend",
 ]
-build-backend = "pdm.backend"
 
 [tool.pdm]
 distribution = true

{vectorvein-0.1.0 → vectorvein-0.1.2}/src/vectorvein/chat_clients/__init__.py

@@ -17,7 +17,7 @@ from .deepseek_client import DeepSeekChatClient, AsyncDeepSeekChatClient
 from ..types import defaults as defs
 from ..types.enums import BackendType, ContextLengthControlType
 from .anthropic_client import AnthropicChatClient, AsyncAnthropicChatClient
-from .utils import format_messages
+from .utils import format_messages, get_token_counts, ToolCallContentProcessor
 
 
 BackendMap = {
@@ -103,8 +103,10 @@ def create_async_chat_client(
 
 
 __all__ = [
+    "BackendType",
+    "format_messages",
+    "get_token_counts",
     "create_chat_client",
     "create_async_chat_client",
-    "format_messages",
-    "BackendType",
+    "ToolCallContentProcessor",
 ]

{vectorvein-0.1.0 → vectorvein-0.1.2}/src/vectorvein/chat_clients/openai_compatible_client.py

@@ -11,9 +11,8 @@ from openai import OpenAI, AsyncOpenAI, AzureOpenAI, AsyncAzureOpenAI
 
 from .base_client import BaseChatClient, BaseAsyncChatClient
 from .utils import (
-    tool_use_re,
     cutoff_messages,
-    extract_tool_calls,
+    ToolCallContentProcessor,
     generate_tool_use_system_prompt,
 )
 from ..settings import settings
@@ -120,13 +119,15 @@ class OpenAICompatibleChatClient(BaseChatClient):
                 for chunk in response:
                     if len(chunk.choices) == 0:
                         continue
+                    if not chunk.choices[0].delta:
+                        continue
                     if self.model_setting.function_call_available:
                         yield chunk.choices[0].delta.model_dump()
                     else:
                         message = chunk.choices[0].delta.model_dump()
                         full_content += message["content"] if message["content"] else ""
                         if tools:
-                            tool_call_data = extract_tool_calls(full_content)
+                            tool_call_data = ToolCallContentProcessor(result["content"]).tool_calls
                             if tool_call_data:
                                 message["tool_calls"] = tool_call_data["tool_calls"]
                         if full_content in ("<", "<|", "<|▶", "<|▶|") or full_content.startswith("<|▶|>"):
@@ -149,10 +150,11 @@ class OpenAICompatibleChatClient(BaseChatClient):
                         tool_call.model_dump() for tool_call in response.choices[0].message.tool_calls
                     ]
                 else:
-                    tool_call_data = extract_tool_calls(result["content"])
+                    tool_call_content_processor = ToolCallContentProcessor(result["content"])
+                    tool_call_data = tool_call_content_processor.tool_calls
                     if tool_call_data:
                         result["tool_calls"] = tool_call_data["tool_calls"]
-                        result["content"] = tool_use_re.sub("", result["content"])
+                        result["content"] = tool_call_content_processor.non_tool_content
             return result
 
 
@@ -255,13 +257,15 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                 async for chunk in response:
                     if len(chunk.choices) == 0:
                         continue
+                    if not chunk.choices[0].delta:
+                        continue
                     if self.model_setting.function_call_available:
                         yield chunk.choices[0].delta.model_dump()
                     else:
                         message = chunk.choices[0].delta.model_dump()
                         full_content += message["content"] if message["content"] else ""
                         if tools:
-                            tool_call_data = extract_tool_calls(full_content)
+                            tool_call_data = ToolCallContentProcessor(result["content"]).tool_calls
                             if tool_call_data:
                                 message["tool_calls"] = tool_call_data["tool_calls"]
                         if full_content in ("<", "<|", "<|▶", "<|▶|") or full_content.startswith("<|▶|>"):
@@ -284,8 +288,9 @@ class AsyncOpenAICompatibleChatClient(BaseAsyncChatClient):
                         tool_call.model_dump() for tool_call in response.choices[0].message.tool_calls
                     ]
                 else:
-                    tool_call_data = extract_tool_calls(result["content"])
+                    tool_call_content_processor = ToolCallContentProcessor(result["content"])
+                    tool_call_data = tool_call_content_processor.tool_calls
                     if tool_call_data:
                         result["tool_calls"] = tool_call_data["tool_calls"]
-                        result["content"] = tool_use_re.sub("", result["content"])
+                        result["content"] = tool_call_content_processor.non_tool_content
             return result

{vectorvein-0.1.0 → vectorvein-0.1.2}/src/vectorvein/chat_clients/utils.py

@@ -12,7 +12,49 @@ from ..utilities.media_processing import ImageProcessor
 chatgpt_encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
 gpt_4o_encoding = tiktoken.encoding_for_model("gpt-4o")
 
-tool_use_re = re.compile(r"<\|▶\|>(.*?)<\|◀\|>", re.DOTALL)
+
+class ToolCallContentProcessor:
+    tool_use_re = re.compile(r"<\|▶\|>(.*?)<\|◀\|>", re.DOTALL)
+
+    def __init__(self, content: str):
+        self.content = content
+
+    @property
+    def non_tool_content(self):
+        return re.sub(self.tool_use_re, "", self.content).strip()
+
+    @property
+    def tool_calls(self):
+        if "<|▶|>" not in self.content or "<|◀|>" not in self.content:
+            return {}
+        tool_calls_matches = re.findall(self.tool_use_re, self.content)
+        if tool_calls_matches:
+            tool_call_data = {}
+            for match in tool_calls_matches:
+                try:
+                    tool_call_data = json.loads(match)
+                except json.JSONDecodeError:
+                    print(f"Failed to parse tool call data:\nContent: {self.content}\nMatch: {match}")
+
+            if not tool_call_data:
+                return {}
+
+            arguments = json.dumps(tool_call_data["arguments"], ensure_ascii=False)
+            return {
+                "tool_calls": [
+                    {
+                        "index": 0,
+                        "id": "fc1",
+                        "function": {
+                            "arguments": arguments,
+                            "name": tool_call_data["name"],
+                        },
+                        "type": "function",
+                    }
+                ]
+            }
+        else:
+            return {}
 
 
 def get_assistant_role_key(backend: BackendType) -> str:
@@ -48,7 +90,7 @@ def convert_type(value, value_type):
         return value  # 如果类型未知，返回原始值
 
 
-def get_token_counts(text: str, model: str = "") -> int:
+def get_token_counts(text: str | dict, model: str = "") -> int:
     if not isinstance(text, str):
         text = str(text)
     if model == "gpt-3.5-turbo":
@@ -396,189 +438,6 @@ def format_text_message(content, role, attachments, backend, native_multimodal):
             return {"role": role, "content": content}
 
 
-def format_messages_v1(
-    messages: list, backend: BackendType = BackendType.OpenAI, native_multimodal: bool = False
-) -> list:
-    """将 VectorVein 的 Message 序列化后的格式转换为不同模型支持的格式
-
-    Args:
-        messages (list): VectorVein messages list.
-        backend (str, optional): Messages format target backend. Defaults to BackendType.OpenAI.
-        native_multimodal (bool, optional): Use native multimodal ability. Defaults to False.
-
-    Returns:
-        list: _description_
-    """
-
-    backend = backend.lower()
-    formatted_messages = []
-    for message in messages:
-        content = message["content"]["text"]
-        if message["content_type"] == "TXT":
-            role = "user" if message["author_type"] == "U" else get_assistant_role_key(backend)
-            if not message.get("attachments"):
-                if backend == BackendType.Gemini:
-                    formatted_message = {"role": role, "parts": [{"text": content}]}
-                else:
-                    formatted_message = {"role": role, "content": content}
-                formatted_messages.append(formatted_message)
-                continue
-
-            images_extensions = ("jpg", "jpeg", "png", "bmp")
-            has_images = any(attachment.lower().endswith(images_extensions) for attachment in message["attachments"])
-
-            content += "\n# Attachments:\n"
-            content += "\n".join([f"- {attachment}" for attachment in message["attachments"]])
-
-            if native_multimodal and has_images:
-                if backend == BackendType.Gemini:
-                    parts = [{"text": content}]
-                    for attachment in message["attachments"]:
-                        if attachment.lower().endswith(images_extensions):
-                            parts.append(format_image_message(image=attachment, backend=backend))
-                    formatted_message = {"role": role, "parts": parts}
-                else:
-                    formatted_message = {
-                        "role": role,
-                        "content": [
-                            {"type": "text", "text": content},
-                            *[
-                                format_image_message(image=attachment, backend=backend)
-                                for attachment in message["attachments"]
-                                if attachment.lower().endswith(images_extensions)
-                            ],
-                        ],
-                    }
-                formatted_messages.append(formatted_message)
-            else:
-                if backend == BackendType.Gemini:
-                    formatted_message = {"role": role, "parts": [{"text": content}]}
-                else:
-                    formatted_message = {"role": role, "content": content}
-                formatted_messages.append(formatted_message)
-        elif message["content_type"] == "WKF" and message["status"] in ("S", "R"):
-            # TODO: 目前只考虑单个 tool_call 的情况
-            if backend in (BackendType.OpenAI, BackendType.ZhiPuAI, BackendType.Mistral):
-                tool_call_message = {
-                    "content": None,
-                    "role": "assistant",
-                    "tool_calls": [
-                        {
-                            "id": message["metadata"]["selected_workflow"]["tool_call_id"],
-                            "type": "function",
-                            "function": {
-                                "name": message["metadata"]["selected_workflow"]["function_name"],
-                                "arguments": json.dumps(message["metadata"]["selected_workflow"]["params"]),
-                            },
-                        }
-                    ],
-                }
-            elif backend == BackendType.Anthropic:
-                tool_call_message = {
-                    "role": "assistant",
-                    "content": [
-                        {
-                            "type": "tool_use",
-                            "id": message["metadata"]["selected_workflow"]["tool_call_id"],
-                            "name": message["metadata"]["selected_workflow"]["function_name"],
-                            "input": message["metadata"]["selected_workflow"]["params"],
-                        },
-                    ],
-                }
-                if content:
-                    tool_call_message["content"].insert(
-                        0,
-                        {
-                            "type": "text",
-                            "text": content,
-                        },
-                    )
-            elif backend == BackendType.Gemini:
-                tool_call_message = {
-                    "role": "model",
-                    "parts": [
-                        {
-                            "functionCall": {
-                                "name": message["metadata"]["selected_workflow"]["function_name"],
-                                "args": message["metadata"]["selected_workflow"]["params"],
-                            }
-                        },
-                    ],
-                }
-                if content:
-                    tool_call_message["parts"].insert(
-                        0,
-                        {
-                            "text": content,
-                        },
-                    )
-            else:
-                tool_call_message = {
-                    "content": json.dumps(
-                        {
-                            "name": message["metadata"]["selected_workflow"]["function_name"],
-                            "arguments": json.dumps(message["metadata"]["selected_workflow"]["params"]),
-                        },
-                        ensure_ascii=False,
-                    ),
-                    "role": "assistant",
-                }
-            formatted_messages.append(tool_call_message)
-
-            if backend in (BackendType.OpenAI, BackendType.ZhiPuAI, BackendType.Mistral):
-                tool_call_result_message = {
-                    "role": "tool",
-                    "tool_call_id": message["metadata"]["selected_workflow"]["tool_call_id"],
-                    "name": message["metadata"]["selected_workflow"]["function_name"],
-                    "content": message["metadata"].get("workflow_result", ""),
-                }
-            elif backend == BackendType.Anthropic:
-                tool_call_result_message = {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "tool_result",
-                            "tool_use_id": message["metadata"]["selected_workflow"]["tool_call_id"],
-                            "content": message["metadata"].get("workflow_result", ""),
-                        }
-                    ],
-                }
-            elif backend == BackendType.Gemini:
-                tool_call_result_message = {
-                    "role": "function",
-                    "parts": [
-                        {
-                            "functionResponse": {
-                                "name": message["metadata"]["selected_workflow"]["function_name"],
-                                "response": {
-                                    "name": message["metadata"]["selected_workflow"]["function_name"],
-                                    "content": message["metadata"].get("workflow_result", ""),
-                                },
-                            }
-                        }
-                    ],
-                }
-            else:
-                tool_call_result_message = {
-                    "role": "user",
-                    "content": json.dumps(
-                        {
-                            "function": message["metadata"]["selected_workflow"]["function_name"],
-                            "result": message["metadata"].get("workflow_result", ""),
-                        },
-                        ensure_ascii=False,
-                    ),
-                }
-            formatted_messages.append(tool_call_result_message)
-
-            if content and backend not in (BackendType.Mistral, BackendType.Anthropic, BackendType.Gemini):
-                formatted_messages.append({"role": "assistant", "content": content})
-        else:
-            continue
-
-    return formatted_messages
-
-
 def generate_tool_use_system_prompt(tools: list, format_type: str = "json") -> str:
     if format_type == "json":
         return (
@@ -600,36 +459,3 @@ def generate_tool_use_system_prompt(tools: list, format_type: str = "json") -> s
             "## Output format\n<|▶|><invoke><tool_name>[function name:str]</tool_name><parameters><parameter_1_name>[parameter_1_value]</parameter_1_name><parameter_2_name>[parameter_2_value]</parameter_2_name>...</parameters></invoke><|◀|>\n\n"
             "## Example output\n<|▶|><invoke><tool_name>calculator</tool_name><parameters><first_operand>1984135</first_operand><second_operand>9343116</second_operand><operator>*</operator></parameters></invoke><|◀|>"
         )
-
-
-def extract_tool_calls(content: str) -> dict:
-    if "<|▶|>" not in content or "<|◀|>" not in content:
-        return {}
-    tool_calls_matches = tool_use_re.findall(content)
-    if tool_calls_matches:
-        tool_call_data = {}
-        for match in tool_calls_matches:
-            try:
-                tool_call_data = json.loads(match)
-            except json.JSONDecodeError:
-                print(f"Failed to parse tool call data:\nContent: {content}\nMatch: {match}")
-
-        if not tool_call_data:
-            return {}
-
-        arguments = json.dumps(tool_call_data["arguments"], ensure_ascii=False)
-        return {
-            "tool_calls": [
-                {
-                    "index": 0,
-                    "id": "fc1",
-                    "function": {
-                        "arguments": arguments,
-                        "name": tool_call_data["name"],
-                    },
-                    "type": "function",
-                }
-            ]
-        }
-    else:
-        return {}

{vectorvein-0.1.0 → vectorvein-0.1.2}/tests/test_create_chat_client.py

@@ -181,14 +181,16 @@ backend = BackendType.MiniMax
 model = "abab6.5s-chat"
 backend = BackendType.Gemini
 model = "gemini-1.5-flash"
+backend = BackendType.OpenAI
+model = "gpt-35-turbo"
 start_time = time.perf_counter()
 # test_sync(backend=backend, model=model, stream=False, use_tool=False)
-test_sync(backend=backend, model=model, stream=False, use_tool=True)
+# test_sync(backend=backend, model=model, stream=False, use_tool=True)
 # test_sync(backend=backend, model=model, stream=True, use_tool=False)
-test_sync(backend=backend, model=model, stream=True, use_tool=True)
+# test_sync(backend=backend, model=model, stream=True, use_tool=True)
 # asyncio.run(test_async(backend=backend, model=model, stream=False, use_tool=False))
-asyncio.run(test_async(backend=backend, model=model, stream=False, use_tool=True))
-# asyncio.run(test_async(backend=backend, model=model, stream=True, use_tool=False))
-asyncio.run(test_async(backend=backend, model=model, stream=True, use_tool=True))
+# asyncio.run(test_async(backend=backend, model=model, stream=False, use_tool=True))
+asyncio.run(test_async(backend=backend, model=model, stream=True, use_tool=False))
+# asyncio.run(test_async(backend=backend, model=model, stream=True, use_tool=True))
 end_time = time.perf_counter()
 print(f"Stream time elapsed: {end_time - start_time} seconds")