vectorvein 0.2.4__tar.gz → 0.2.6__tar.gz

{vectorvein-0.2.4 → vectorvein-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectorvein
-Version: 0.2.4
+Version: 0.2.6
 Summary: VectorVein python SDK
 Author-Email: Anderson <andersonby@163.com>
 License: MIT

{vectorvein-0.2.4 → vectorvein-0.2.6}/pyproject.toml

@@ -18,7 +18,7 @@ description = "VectorVein python SDK"
 name = "vectorvein"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.2.4"
+version = "0.2.6"
 
 [project.license]
 text = "MIT"

{vectorvein-0.2.4 → vectorvein-0.2.6}/src/vectorvein/api/client.py

@@ -1,4 +1,4 @@
-"""向量脉络 API 客户端"""
+"""VectorVein API Client"""
 
 import time
 import base64
@@ -28,23 +28,23 @@ from .models import (
 
 
 class VectorVeinClient:
-    """向量脉络 API 客户端类"""
+    """VectorVein API Sync Client"""
 
     API_VERSION = "20240508"
     BASE_URL = "https://vectorvein.com/api/v1/open-api"
 
     def __init__(self, api_key: str, base_url: Optional[str] = None):
-        """初始化客户端
+        """Initialize the client
 
         Args:
-            api_key: API密钥
-            base_url: API基础URL，默认为https://vectorvein.com/api/v1/open-api
+            api_key: API key
+            base_url: API base URL, default is https://vectorvein.com/api/v1/open-api
 
         Raises:
-            APIKeyError: API密钥为空或格式不正确
+            APIKeyError: API key is empty or not a string
         """
         if not api_key or not isinstance(api_key, str):
-            raise APIKeyError("API密钥不能为空且必须是字符串类型")
+            raise APIKeyError("API key cannot be empty and must be a string type")
 
         self.api_key = api_key
         self.base_url = base_url or self.BASE_URL
@@ -69,22 +69,22 @@ class VectorVeinClient:
         api_key_type: Literal["WORKFLOW", "VAPP"] = "WORKFLOW",
         **kwargs,
     ) -> Dict[str, Any]:
-        """发送HTTP请求
+        """Send HTTP request
 
         Args:
-            method: HTTP方法
-            endpoint: API端点
-            params: URL参数
-            json: JSON请求体
-            **kwargs: 其他请求参数
+            method: HTTP method
+            endpoint: API endpoint
+            params: URL parameters
+            json: JSON request body
+            **kwargs: Other request parameters
 
         Returns:
-            Dict[str, Any]: API响应
+            Dict[str, Any]: API response
 
         Raises:
-            RequestError: 请求错误
-            VectorVeinAPIError: API错误
-            APIKeyError: API密钥无效或已过期
+            RequestError: Request error
+            VectorVeinAPIError: API error
+            APIKeyError: API key is invalid or expired
         """
         url = f"{self.base_url}/{endpoint}"
         headers = self.default_headers.copy()
@@ -102,7 +102,7 @@ class VectorVeinClient:
             result = response.json()
 
             if result["status"] in [401, 403]:
-                raise APIKeyError("API密钥无效或已过期")
+                raise APIKeyError("API key is invalid or expired")
             if result["status"] != 200 and result["status"] != 202:
                 raise VectorVeinAPIError(message=result.get("msg", "Unknown error"), status_code=result["status"])
             return result
@@ -140,22 +140,22 @@ class VectorVeinClient:
         api_key_type: Literal["WORKFLOW", "VAPP"] = "WORKFLOW",
         timeout: int = 30,
     ) -> Union[str, WorkflowRunResult]:
-        """运行工作流
+        """Run workflow
 
         Args:
-            wid: 工作流ID
-            input_fields: 输入字段列表
-            output_scope: 输出范围，可选值：'all' 或 'output_fields_only'
-            wait_for_completion: 是否等待完成
-            api_key_type: 密钥类型，可选值：'WORKFLOW' 或 'VAPP'
-            timeout: 超时时间（秒）
+            wid: Workflow ID
+            input_fields: Input fields list
+            output_scope: Output scope, optional values: 'all' or 'output_fields_only'
+            wait_for_completion: Whether to wait for completion
+            api_key_type: Key type, optional values: 'WORKFLOW' or 'VAPP'
+            timeout: Timeout (seconds)
 
         Returns:
-            Union[str, WorkflowRunResult]: 工作流运行ID或运行结果
+            Union[str, WorkflowRunResult]: Workflow run ID or run result
 
         Raises:
-            WorkflowError: 工作流运行错误
-            TimeoutError: 超时错误
+            WorkflowError: Workflow run error
+            TimeoutError: Timeout error
         """
         payload = {
             "wid": wid,
@@ -203,22 +203,22 @@ class VectorVeinClient:
     def check_workflow_status(
         self, rid: str, wid: Optional[str] = None, api_key_type: Literal["WORKFLOW", "VAPP"] = "WORKFLOW"
     ) -> WorkflowRunResult:
-        """检查工作流运行状态
+        """Check workflow run status
 
         Args:
-            rid: 工作流运行记录ID
-            wid: 工作流ID，非必填，api_key_type 为 'VAPP' 时必填
-            api_key_type: 密钥类型，可选值：'WORKFLOW' 或 'VAPP'
+            rid: Workflow run record ID
+            wid: Workflow ID, not required, required when api_key_type is 'VAPP'
+            api_key_type: Key type, optional values: 'WORKFLOW' or 'VAPP'
 
         Returns:
-            WorkflowRunResult: 工作流运行结果
+            WorkflowRunResult: Workflow run result
 
         Raises:
-            VectorVeinAPIError: 工作流错误
+            VectorVeinAPIError: Workflow error
         """
         payload = {"rid": rid}
         if api_key_type == "VAPP" and not wid:
-            raise VectorVeinAPIError("api_key_type 为 'VAPP' 时工作流 ID 不能为空")
+            raise VectorVeinAPIError("Workflow ID cannot be empty when api_key_type is 'VAPP'")
         if wid:
             payload["wid"] = wid
         response = self._request("POST", "workflow/check-status", json=payload, api_key_type=api_key_type)
@@ -235,17 +235,17 @@ class VectorVeinClient:
     def get_access_keys(
         self, access_keys: Optional[List[str]] = None, get_type: Literal["selected", "all"] = "selected"
     ) -> List[AccessKey]:
-        """获取访问密钥信息
+        """Get access key information
 
         Args:
-            access_keys: 访问密钥列表
-            get_type: 获取类型，可选值：'selected' 或 'all'
+            access_keys: Access key list
+            get_type: Get type, optional values: 'selected' or 'all'
 
         Returns:
-            List[AccessKey]: 访问密钥信息列表
+            List[AccessKey]: Access key information list
 
         Raises:
-            AccessKeyError: 访问密钥不存在或已失效
+            AccessKeyError: Access key does not exist or has expired
         """
         params = {"get_type": get_type}
         if access_keys:
@@ -256,9 +256,9 @@ class VectorVeinClient:
             return [AccessKey(**key) for key in result["data"]]
         except VectorVeinAPIError as e:
             if e.status_code == 404:
-                raise AccessKeyError("访问密钥不存在")
+                raise AccessKeyError("Access key does not exist")
             elif e.status_code == 403:
-                raise AccessKeyError("访问密钥已失效")
+                raise AccessKeyError("Access key has expired")
             raise
 
     def create_access_keys(
@@ -272,29 +272,29 @@ class VectorVeinClient:
         max_use_count: Optional[int] = None,
         description: Optional[str] = None,
     ) -> List[AccessKey]:
-        """创建访问密钥
+        """Create access key
 
         Args:
-            access_key_type: 密钥类型，可选值：'O'(一次性)、'M'(多次)、'L'(长期)
-            app_id: 单个应用ID
-            app_ids: 多个应用ID列表
-            count: 创建数量
-            expire_time: 过期时间
-            max_credits: 最大积分限制
-            max_use_count: 最大使用次数
-            description: 描述信息
+            access_key_type: Key type, optional values: 'O'(one-time)、'M'(multiple)、'L'(long-term)
+            app_id: Single application ID
+            app_ids: Multiple application ID list
+            count: Create quantity
+            expire_time: Expiration time
+            max_credits: Maximum credit limit
+            max_use_count: Maximum use count
+            description: Description information
 
         Returns:
-            List[AccessKey]: 创建的访问密钥列表
+            List[AccessKey]: Created access key list
 
         Raises:
-            AccessKeyError: 创建访问密钥失败，如类型无效、应用不存在等
+            AccessKeyError: Failed to create access key, such as invalid type, application does not exist, etc.
         """
         if access_key_type not in ["O", "M", "L"]:
-            raise AccessKeyError("无效的访问密钥类型，必须是 'O'(一次性)、'M'(多次) 或 'L'(长期)")
+            raise AccessKeyError("Invalid access key type, must be 'O'(one-time)、'M'(multiple) or 'L'(long-term)")
 
         if app_id and app_ids:
-            raise AccessKeyError("不能同时指定 app_id 和 app_ids")
+            raise AccessKeyError("Cannot specify both app_id and app_ids")
 
         payload = {"access_key_type": access_key_type, "count": count}
 
@@ -316,9 +316,9 @@ class VectorVeinClient:
             return [AccessKey(**key) for key in result["data"]]
         except VectorVeinAPIError as e:
             if e.status_code == 404:
-                raise AccessKeyError("指定的应用不存在")
+                raise AccessKeyError("The specified application does not exist")
             elif e.status_code == 403:
-                raise AccessKeyError("没有权限创建访问密钥")
+                raise AccessKeyError("No permission to create access key")
             raise
 
     def list_access_keys(
@@ -331,19 +331,19 @@ class VectorVeinClient:
         status: Optional[List[str]] = None,
         access_key_type: Optional[Literal["O", "M", "L"]] = None,
     ) -> AccessKeyListResponse:
-        """列出访问密钥
+        """List access keys
 
         Args:
-            page: 页码
-            page_size: 每页数量
-            sort_field: 排序字段
-            sort_order: 排序顺序
-            app_id: 应用ID
-            status: 状态列表
-            access_key_type: 密钥类型列表，可选值：'O'(一次性)、'M'(多次)、'L'(长期)
+            page: Page number
+            page_size: Number of items per page
+            sort_field: Sort field
+            sort_order: Sort order
+            app_id: Application ID
+            status: Status list
+            access_key_type: Key type list, optional values: 'O'(one-time)、'M'(multiple)、'L'(long-term)
 
         Returns:
-            AccessKeyListResponse: 访问密钥列表响应
+            AccessKeyListResponse: Access key list response
         """
         payload = {"page": page, "page_size": page_size, "sort_field": sort_field, "sort_order": sort_order}
 
@@ -358,11 +358,11 @@ class VectorVeinClient:
         return AccessKeyListResponse(**result["data"])
 
     def delete_access_keys(self, app_id: str, access_keys: List[str]) -> None:
-        """删除访问密钥
+        """Delete access key
 
         Args:
-            app_id: 应用ID
-            access_keys: 要删除的访问密钥列表
+            app_id: Application ID
+            access_keys: List of access keys to delete
         """
         payload = {"app_id": app_id, "access_keys": access_keys}
         self._request("POST", "vapp/access-key/delete", json=payload)
@@ -379,18 +379,18 @@ class VectorVeinClient:
         description: Optional[str] = None,
         access_key_type: Optional[Literal["O", "M", "L"]] = None,
     ) -> None:
-        """更新访问密钥
+        """Update access key
 
         Args:
-            access_key: 单个访问密钥
-            access_keys: 多个访问密钥列表
-            app_id: 单个应用ID
-            app_ids: 多个应用ID列表
-            expire_time: 过期时间
-            max_use_count: 最大使用次数
-            max_credits: 最大积分限制
-            description: 描述信息
-            access_key_type: 密钥类型，可选值：'O'(一次性)、'M'(多次)、'L'(长期)
+            access_key: Single access key
+            access_keys: Multiple access key list
+            app_id: Single application ID
+            app_ids: Multiple application ID list
+            expire_time: Expiration time
+            max_use_count: Maximum use count
+            max_credits: Maximum credit limit
+            description: Description information
+            access_key_type: Key type, optional values: 'O'(one-time)、'M'(multiple)、'L'(long-term)
         """
         payload = {}
         if access_key:
@@ -415,21 +415,21 @@ class VectorVeinClient:
         self._request("POST", "vapp/access-key/update", json=payload)
 
     def add_apps_to_access_keys(self, access_keys: List[str], app_ids: List[str]) -> None:
-        """向访问密钥添加应用
+        """Add applications to access keys
 
         Args:
-            access_keys: 访问密钥列表
-            app_ids: 要添加的应用ID列表
+            access_keys: Access key list
+            app_ids: List of application IDs to add
         """
         payload = {"access_keys": access_keys, "app_ids": app_ids}
         self._request("POST", "vapp/access-key/add-apps", json=payload)
 
     def remove_apps_from_access_keys(self, access_keys: List[str], app_ids: List[str]) -> None:
-        """从访问密钥移除应用
+        """Remove applications from access keys
 
         Args:
-            access_keys: 访问密钥列表
-            app_ids: 要移除的应用ID列表
+            access_keys: Access key list
+            app_ids: List of application IDs to remove
         """
         payload = {"access_keys": access_keys, "app_ids": app_ids}
         self._request("POST", "vapp/access-key/remove-apps", json=payload)
@@ -442,17 +442,17 @@ class VectorVeinClient:
         timeout: int = 15 * 60,
         base_url: str = "https://vectorvein.com",
     ) -> str:
-        """生成VApp访问链接
+        """Generate VApp access link
 
         Args:
             app_id: VApp ID
-            access_key: 访问密钥
-            key_id: 密钥ID
-            timeout: 超时时间（秒）
-            base_url: 基础URL
+            access_key: Access key
+            key_id: Key ID
+            timeout: Timeout (seconds)
+            base_url: Base URL
 
         Returns:
-            str: VApp访问链接
+            str: VApp access link
         """
         timestamp = int(time.time())
         message = f"{app_id}:{access_key}:{timestamp}:{timeout}"
@@ -469,23 +469,23 @@ class VectorVeinClient:
 
 
 class AsyncVectorVeinClient:
-    """向量脉络 API 异步客户端类"""
+    """VectorVein API Async Client"""
 
     API_VERSION = "20240508"
     BASE_URL = "https://vectorvein.com/api/v1/open-api"
 
     def __init__(self, api_key: str, base_url: Optional[str] = None):
-        """初始化异步客户端
+        """Initialize the async client
 
         Args:
-            api_key: API密钥
-            base_url: API基础URL，默认为https://vectorvein.com/api/v1/open-api
+            api_key: API key
+            base_url: API base URL, default is https://vectorvein.com/api/v1/open-api
 
         Raises:
-            APIKeyError: API密钥为空或格式不正确
+            APIKeyError: API key is empty or not a string
         """
         if not api_key or not isinstance(api_key, str):
-            raise APIKeyError("API密钥不能为空且必须是字符串类型")
+            raise APIKeyError("API key cannot be empty and must be a string type")
 
         self.api_key = api_key
         self.base_url = base_url or self.BASE_URL
@@ -510,22 +510,22 @@ class AsyncVectorVeinClient:
         api_key_type: Literal["WORKFLOW", "VAPP"] = "WORKFLOW",
         **kwargs,
     ) -> Dict[str, Any]:
-        """发送异步HTTP请求
+        """Send asynchronous HTTP request
 
         Args:
-            method: HTTP方法
-            endpoint: API端点
-            params: URL参数
-            json: JSON请求体
-            **kwargs: 其他请求参数
+            method: HTTP method
+            endpoint: API endpoint
+            params: URL parameters
+            json: JSON request body
+            **kwargs: Other request parameters
 
         Returns:
-            Dict[str, Any]: API响应
+            Dict[str, Any]: API response
 
         Raises:
-            RequestError: 请求错误
-            VectorVeinAPIError: API错误
-            APIKeyError: API密钥无效或已过期
+            RequestError: Request error
+            VectorVeinAPIError: API error
+            APIKeyError: API key is invalid or expired
         """
         url = f"{self.base_url}/{endpoint}"
         headers = self.default_headers.copy()
@@ -543,7 +543,7 @@ class AsyncVectorVeinClient:
             result = response.json()
 
             if result["status"] in [401, 403]:
-                raise APIKeyError("API密钥无效或已过期")
+                raise APIKeyError("API key is invalid or expired")
             if result["status"] != 200 and result["status"] != 202:
                 raise VectorVeinAPIError(message=result.get("msg", "Unknown error"), status_code=result["status"])
             return result
@@ -581,22 +581,22 @@ class AsyncVectorVeinClient:
         api_key_type: Literal["WORKFLOW", "VAPP"] = "WORKFLOW",
         timeout: int = 30,
     ) -> Union[str, WorkflowRunResult]:
-        """异步运行工作流
+        """Async run workflow
 
         Args:
-            wid: 工作流ID
-            input_fields: 输入字段列表
-            output_scope: 输出范围，可选值：'all' 或 'output_fields_only'
-            wait_for_completion: 是否等待完成
-            api_key_type: 密钥类型，可选值：'WORKFLOW' 或 'VAPP'
-            timeout: 超时时间（秒）
+            wid: Workflow ID
+            input_fields: Input field list
+            output_scope: Output scope, optional values: 'all' or 'output_fields_only'
+            wait_for_completion: Whether to wait for completion
+            api_key_type: Key type, optional values: 'WORKFLOW' or 'VAPP'
+            timeout: Timeout (seconds)
 
         Returns:
-            Union[str, WorkflowRunResult]: 工作流运行ID或运行结果
+            Union[str, WorkflowRunResult]: Workflow run ID or run result
 
         Raises:
-            WorkflowError: 工作流运行错误
-            TimeoutError: 超时错误
+            WorkflowError: Workflow run error
+            TimeoutError: Timeout error
         """
         payload = {
             "wid": wid,
@@ -644,19 +644,19 @@ class AsyncVectorVeinClient:
     async def check_workflow_status(
         self, rid: str, wid: Optional[str] = None, api_key_type: Literal["WORKFLOW", "VAPP"] = "WORKFLOW"
     ) -> WorkflowRunResult:
-        """异步检查工作流运行状态
+        """Async check workflow run status
 
         Args:
-            rid: 工作流运行记录ID
-            wid: 工作流ID，非必填，api_key_type 为 'VAPP' 时必填
-            api_key_type: 密钥类型，可选值：'WORKFLOW' 或 'VAPP'
+            rid: Workflow run record ID
+            wid: Workflow ID, required when api_key_type is 'VAPP'
+            api_key_type: Key type, optional values: 'WORKFLOW' or 'VAPP'
 
         Raises:
-            VectorVeinAPIError: 工作流错误
+            VectorVeinAPIError: Workflow error
         """
         payload = {"rid": rid}
         if api_key_type == "VAPP" and not wid:
-            raise VectorVeinAPIError("api_key_type 为 'VAPP' 时工作流 ID 不能为空")
+            raise VectorVeinAPIError("Workflow ID cannot be empty when api_key_type is 'VAPP'")
         if wid:
             payload["wid"] = wid
         response = await self._request("POST", "workflow/check-status", json=payload, api_key_type=api_key_type)
@@ -673,17 +673,17 @@ class AsyncVectorVeinClient:
     async def get_access_keys(
         self, access_keys: Optional[List[str]] = None, get_type: Literal["selected", "all"] = "selected"
     ) -> List[AccessKey]:
-        """异步获取访问密钥信息
+        """Async get access key information
 
         Args:
-            access_keys: 访问密钥列表
-            get_type: 获取类型，可选值：'selected' 或 'all'
+            access_keys: Access key list
+            get_type: Get type, optional values: 'selected' or 'all'
 
         Returns:
-            List[AccessKey]: 访问密钥信息列表
+            List[AccessKey]: Access key information list
 
         Raises:
-            AccessKeyError: 访问密钥不存在或已失效
+            AccessKeyError: Access key does not exist or has expired
         """
         params = {"get_type": get_type}
         if access_keys:
@@ -694,9 +694,9 @@ class AsyncVectorVeinClient:
             return [AccessKey(**key) for key in result["data"]]
         except VectorVeinAPIError as e:
             if e.status_code == 404:
-                raise AccessKeyError("访问密钥不存在")
+                raise AccessKeyError("Access key does not exist")
             elif e.status_code == 403:
-                raise AccessKeyError("访问密钥已失效")
+                raise AccessKeyError("Access key has expired")
             raise
 
     async def create_access_keys(
@@ -710,29 +710,29 @@ class AsyncVectorVeinClient:
         max_use_count: Optional[int] = None,
         description: Optional[str] = None,
     ) -> List[AccessKey]:
-        """异步创建访问密钥
+        """Async create access key
 
         Args:
-            access_key_type: 密钥类型，可选值：'O'(一次性)、'M'(多次)、'L'(长期)
-            app_id: 单个应用ID
-            app_ids: 多个应用ID列表
-            count: 创建数量
-            expire_time: 过期时间
-            max_credits: 最大积分限制
-            max_use_count: 最大使用次数
-            description: 描述信息
+            access_key_type: Key type, optional values: 'O'(one-time)、'M'(multiple)、'L'(long-term)
+            app_id: Single application ID
+            app_ids: Multiple application ID list
+            count: Create quantity
+            expire_time: Expiration time
+            max_credits: Maximum credit limit
+            max_use_count: Maximum use count
+            description: Description
 
         Returns:
-            List[AccessKey]: 创建的访问密钥列表
+            List[AccessKey]: Created access key list
 
         Raises:
-            AccessKeyError: 创建访问密钥失败，如类型无效、应用不存在等
+            AccessKeyError: Failed to create access key, such as invalid type, application does not exist, etc.
         """
         if access_key_type not in ["O", "M", "L"]:
-            raise AccessKeyError("无效的访问密钥类型，必须是 'O'(一次性)、'M'(多次) 或 'L'(长期)")
+            raise AccessKeyError("Invalid access key type, must be 'O'(one-time) or 'M'(multiple) or 'L'(long-term)")
 
         if app_id and app_ids:
-            raise AccessKeyError("不能同时指定 app_id 和 app_ids")
+            raise AccessKeyError("Cannot specify both app_id and app_ids")
 
         payload = {"access_key_type": access_key_type, "count": count}
 
@@ -754,9 +754,9 @@ class AsyncVectorVeinClient:
             return [AccessKey(**key) for key in result["data"]]
         except VectorVeinAPIError as e:
             if e.status_code == 404:
-                raise AccessKeyError("指定的应用不存在")
+                raise AccessKeyError("The specified application does not exist")
             elif e.status_code == 403:
-                raise AccessKeyError("没有权限创建访问密钥")
+                raise AccessKeyError("No permission to create access key")
             raise
 
     async def list_access_keys(
@@ -769,19 +769,19 @@ class AsyncVectorVeinClient:
         status: Optional[List[str]] = None,
         access_key_type: Optional[Literal["O", "M", "L"]] = None,
     ) -> AccessKeyListResponse:
-        """异步列出访问密钥
+        """Async list access keys
 
         Args:
-            page: 页码
-            page_size: 每页数量
-            sort_field: 排序字段
-            sort_order: 排序顺序
-            app_id: 应用ID
-            status: 状态列表
-            access_key_type: 密钥类型列表，可选值：'O'(一次性)、'M'(多次)、'L'(长期)
+            page: Page number
+            page_size: Number of items per page
+            sort_field: Sort field
+            sort_order: Sort order
+            app_id: Application ID
+            status: Status list
+            access_key_type: Key type list, optional values: 'O'(one-time)、'M'(multiple)、'L'(long-term)
 
         Returns:
-            AccessKeyListResponse: 访问密钥列表响应
+            AccessKeyListResponse: Access key list response
         """
         payload = {"page": page, "page_size": page_size, "sort_field": sort_field, "sort_order": sort_order}
 
@@ -796,11 +796,11 @@ class AsyncVectorVeinClient:
         return AccessKeyListResponse(**result["data"])
 
     async def delete_access_keys(self, app_id: str, access_keys: List[str]) -> None:
-        """异步删除访问密钥
+        """Async delete access key
 
         Args:
-            app_id: 应用ID
-            access_keys: 要删除的访问密钥列表
+            app_id: Application ID
+            access_keys: List of access keys to delete
         """
         payload = {"app_id": app_id, "access_keys": access_keys}
         await self._request("POST", "vapp/access-key/delete", json=payload)
@@ -817,18 +817,18 @@ class AsyncVectorVeinClient:
         description: Optional[str] = None,
         access_key_type: Optional[Literal["O", "M", "L"]] = None,
     ) -> None:
-        """异步更新访问密钥
+        """Async update access key
 
         Args:
-            access_key: 单个访问密钥
-            access_keys: 多个访问密钥列表
-            app_id: 单个应用ID
-            app_ids: 多个应用ID列表
-            expire_time: 过期时间
-            max_use_count: 最大使用次数
-            max_credits: 最大积分限制
-            description: 描述信息
-            access_key_type: 密钥类型，可选值：'O'(一次性)、'M'(多次)、'L'(长期)
+            access_key: Single access key
+            access_keys: Multiple access key list
+            app_id: Single application ID
+            app_ids: Multiple application ID list
+            expire_time: Expiration time
+            max_use_count: Maximum use count
+            max_credits: Maximum credit limit
+            description: Description
+            access_key_type: Key type, optional values: 'O'(one-time)、'M'(multiple)、'L'(long-term)
         """
         payload = {}
         if access_key:
@@ -853,21 +853,21 @@ class AsyncVectorVeinClient:
         await self._request("POST", "vapp/access-key/update", json=payload)
 
     async def add_apps_to_access_keys(self, access_keys: List[str], app_ids: List[str]) -> None:
-        """异步向访问密钥添加应用
+        """Async add applications to access keys
 
         Args:
-            access_keys: 访问密钥列表
-            app_ids: 要添加的应用ID列表
+            access_keys: Access key list
+            app_ids: List of application IDs to add
         """
         payload = {"access_keys": access_keys, "app_ids": app_ids}
         await self._request("POST", "vapp/access-key/add-apps", json=payload)
 
     async def remove_apps_from_access_keys(self, access_keys: List[str], app_ids: List[str]) -> None:
-        """异步从访问密钥移除应用
+        """Async remove applications from access keys
 
         Args:
-            access_keys: 访问密钥列表
-            app_ids: 要移除的应用ID列表
+            access_keys: Access key list
+            app_ids: List of application IDs to remove
         """
         payload = {"access_keys": access_keys, "app_ids": app_ids}
         await self._request("POST", "vapp/access-key/remove-apps", json=payload)
@@ -880,17 +880,17 @@ class AsyncVectorVeinClient:
         timeout: int = 15 * 60,
         base_url: str = "https://vectorvein.com",
     ) -> str:
-        """异步生成VApp访问链接
+        """Async generate VApp access link
 
         Args:
             app_id: VApp ID
-            access_key: 访问密钥
-            key_id: 密钥ID
-            timeout: 超时时间（秒）
-            base_url: 基础URL
+            access_key: Access key
+            key_id: Key ID
+            timeout: Timeout (seconds)
+            base_url: Base URL
 
         Returns:
-            str: VApp访问链接
+            str: VApp access link
         """
         timestamp = int(time.time())
         message = f"{app_id}:{access_key}:{timestamp}:{timeout}"

{vectorvein-0.2.4 → vectorvein-0.2.6}/src/vectorvein/api/exceptions.py

@@ -1,10 +1,10 @@
-"""向量脉络 API 异常类定义"""
+"""VectorVein API Exception Definitions"""
 
 from typing import Optional
 
 
 class VectorVeinAPIError(Exception):
-    """向量脉络 API 基础异常类"""
+    """Base exception class for VectorVein API"""
 
     def __init__(self, message: str, status_code: Optional[int] = None):
         super().__init__(message)
@@ -12,30 +12,30 @@ class VectorVeinAPIError(Exception):
 
 
 class APIKeyError(VectorVeinAPIError):
-    """API密钥相关错误"""
+    """API key related errors"""
 
     pass
 
 
 class WorkflowError(VectorVeinAPIError):
-    """工作流相关错误"""
+    """Workflow related errors"""
 
     pass
 
 
 class AccessKeyError(VectorVeinAPIError):
-    """访问密钥相关错误"""
+    """Access key related errors"""
 
     pass
 
 
 class RequestError(VectorVeinAPIError):
-    """请求相关错误"""
+    """Request related errors"""
 
     pass
 
 
 class TimeoutError(VectorVeinAPIError):
-    """超时错误"""
+    """Timeout errors"""
 
     pass

{vectorvein-0.2.4 → vectorvein-0.2.6}/src/vectorvein/api/models.py

@@ -1,4 +1,4 @@
-"""向量脉络 API 数据模型定义"""
+"""VectorVein API data model definitions"""
 
 from dataclasses import dataclass
 from typing import List, Dict, Optional, Any
@@ -6,7 +6,7 @@ from typing import List, Dict, Optional, Any
 
 @dataclass
 class VApp:
-    """VApp 信息"""
+    """VApp information"""
 
     app_id: str
     title: str
@@ -17,10 +17,10 @@ class VApp:
 
 @dataclass
 class AccessKey:
-    """访问密钥信息"""
+    """Access key information"""
 
     access_key: str
-    access_key_type: str  # O: 一次性, M: 多次, L: 长期
+    access_key_type: str  # O: one-time, M: multiple, L: long-term
     use_count: int
     max_use_count: Optional[int]
     max_credits: Optional[int]
@@ -28,8 +28,8 @@ class AccessKey:
     v_app: Optional[VApp]
     v_apps: List[VApp]
     records: List[Any]
-    status: str  # AC: 有效, IN: 无效, EX: 已过期, US: 已使用
-    access_scope: str  # S: 单应用, M: 多应用
+    status: str  # AC: valid, IN: invalid, EX: expired, US: used
+    access_scope: str  # S: single application, M: multiple applications
     description: str
     create_time: str
     expire_time: str
@@ -38,7 +38,7 @@ class AccessKey:
 
 @dataclass
 class WorkflowInputField:
-    """工作流输入字段"""
+    """Workflow input field"""
 
     node_id: str
     field_name: str
@@ -47,7 +47,7 @@ class WorkflowInputField:
 
 @dataclass
 class WorkflowOutput:
-    """工作流输出结果"""
+    """Workflow output result"""
 
     type: str
     title: str
@@ -56,7 +56,7 @@ class WorkflowOutput:
 
 @dataclass
 class WorkflowRunResult:
-    """工作流运行结果"""
+    """Workflow run result"""
 
     rid: str
     status: int
@@ -66,7 +66,7 @@ class WorkflowRunResult:
 
 @dataclass
 class AccessKeyListResponse:
-    """访问密钥列表响应"""
+    """Access key list response"""
 
     access_keys: List[AccessKey]
     total: int

{vectorvein-0.2.4 → vectorvein-0.2.6}/src/vectorvein/types/defaults.py

@@ -594,6 +594,14 @@ ANTHROPIC_MODELS: Final[Dict[str, Dict[str, Any]]] = {
         "response_format_available": False,
         "native_multimodal": True,
     },
+    "claude-3-7-sonnet-20250219": {
+        "id": "claude-3-7-sonnet-20250219",
+        "context_length": 128000,
+        "max_output_tokens": 8192,
+        "function_call_available": True,
+        "response_format_available": False,
+        "native_multimodal": True,
+    },
 }
 
 # Minimax models

{vectorvein-0.2.4 → vectorvein-0.2.6}/src/vectorvein/workflow/nodes/text_processing.py

@@ -216,3 +216,31 @@ class TemplateCompose(Node):
                 "output": OutputPort(),
             },
         )
+
+
+class RegexExtract(Node):
+    def __init__(self, id: Optional[str] = None):
+        super().__init__(
+            node_type="RegexExtract",
+            category="text_processing",
+            task_name="text_processing.regex_extract",
+            node_id=id,
+            ports={
+                "text": InputPort(
+                    name="text",
+                    port_type=PortType.TEXTAREA,
+                    value="",
+                ),
+                "pattern": InputPort(
+                    name="pattern",
+                    port_type=PortType.INPUT,
+                    value="```.*?\\n(.*?)\\n```",
+                ),
+                "first_match": InputPort(
+                    name="first_match",
+                    port_type=PortType.CHECKBOX,
+                    value=True,
+                ),
+                "output": OutputPort(),
+            },
+        )