xparse-client 0.3.0b8__tar.gz → 0.3.0b9__tar.gz

{xparse_client-0.3.0b8/xparse_client.egg-info → xparse_client-0.3.0b9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xparse-client
-Version: 0.3.0b8
+Version: 0.3.0b9
 Summary: 面向 Agent 和 RAG 的文档处理 Pipeline 客户端
 Author-email: INTSIG-TEXTIN <support@textin.com>
 License-Expression: MIT

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9}/example/2_async_job.py

@@ -22,9 +22,9 @@ from xparse_client.models import ParseConfig
 
 def example_1_create_and_wait():
     """示例 2.1: 创建异步任务并等待完成"""
-    print("\n" + "="*60)
+    print("\n" + "=" * 60)
     print("示例 2.1: 创建异步任务并等待完成")
-    print("="*60)
+    print("=" * 60)
 
     client = XParseClient.from_env()
 
@@ -37,9 +37,7 @@ def example_1_create_and_wait():
         print("\n📤 创建异步任务...")
         with open(test_file, "rb") as f:
             job = client.parse.create_async_job(
-                file=f,
-                filename=test_file.name,
-                config=ParseConfig(provider="textin")
+                file=f, filename=test_file.name, config=ParseConfig(provider="textin")
             )
 
         print("✅ 任务已创建:")
@@ -47,11 +45,7 @@ def example_1_create_and_wait():
 
         # 等待任务完成
         print("\n⏳ 等待任务完成...")
-        result = client.parse.wait_for_result(
-            job_id=job.job_id,
-            timeout_seconds=60.0,
-            poll_interval_seconds=2.0
-        )
+        result = client.parse.wait_for_result(job_id=job.job_id, timeout=60.0, poll_interval=2.0)
 
         if result.is_completed:
             print("\n✅ 任务完成!")
@@ -70,9 +64,9 @@ def example_1_create_and_wait():
 
 def example_2_manual_polling():
     """示例 2.2: 手动轮询任务状态"""
-    print("\n" + "="*60)
+    print("\n" + "=" * 60)
     print("示例 2.2: 手动轮询任务状态")
-    print("="*60)
+    print("=" * 60)
 
     client = XParseClient.from_env()
 
@@ -84,9 +78,7 @@ def example_2_manual_polling():
         # 创建异步任务
         with open(test_file, "rb") as f:
             job = client.parse.create_async_job(
-                file=f,
-                filename=test_file.name,
-                config=ParseConfig(provider="textin")
+                file=f, filename=test_file.name, config=ParseConfig(provider="textin")
             )
 
         print(f"✅ 任务已创建: {job.job_id}")
@@ -128,9 +120,9 @@ def example_2_manual_polling():
 
 def example_3_error_handling():
     """示例 2.3: 异步任务错误处理"""
-    print("\n" + "="*60)
+    print("\n" + "=" * 60)
     print("示例 2.3: 异步任务错误处理")
-    print("="*60)
+    print("=" * 60)
 
     client = XParseClient.from_env()
 
@@ -142,9 +134,7 @@ def example_3_error_handling():
         print("\n📤 创建任务并设置很短的超时时间...")
         with open(test_file, "rb") as f:
             job = client.parse.create_async_job(
-                file=f,
-                filename=test_file.name,
-                config=ParseConfig(provider="textin")
+                file=f, filename=test_file.name, config=ParseConfig(provider="textin")
             )
 
         print(f"✅ 任务已创建: {job.job_id}")
@@ -153,8 +143,8 @@ def example_3_error_handling():
         try:
             result = client.parse.wait_for_result(
                 job_id=job.job_id,
-                timeout_seconds=0.5,  # 很短的超时
-                poll_interval_seconds=0.2
+                timeout=0.5,  # 很短的超时
+                poll_interval=0.2,
             )
 
             if result.is_completed:
@@ -173,9 +163,9 @@ def example_3_error_handling():
 
 def main():
     """主函数"""
-    print("\n" + "="*60)
+    print("\n" + "=" * 60)
     print("xparse-client 服务端异步任务示例")
-    print("="*60)
+    print("=" * 60)
 
     # 检查环境变量
     if not os.getenv("TEXTIN_APP_ID") or not os.getenv("TEXTIN_SECRET_CODE"):
@@ -196,13 +186,14 @@ def main():
         example_2_manual_polling()
         example_3_error_handling()
 
-        print("\n" + "="*60)
+        print("\n" + "=" * 60)
         print("✅ 所有示例运行完成!")
-        print("="*60)
+        print("=" * 60)
 
     except Exception as e:
         print(f"\n❌ 错误: {e}")
         import traceback
+
         traceback.print_exc()
 
 

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "xparse-client"
-version = "0.3.0b8"
+version = "0.3.0b9"
 description = "面向 Agent 和 RAG 的文档处理 Pipeline 客户端"
 readme = "README.md"
 license = "MIT"

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9}/tests/unit/api/test_parse.py

@@ -59,10 +59,13 @@ class TestParseAPI:
     def test_create_async_job(self, client, sample_pdf_bytes):
         """测试创建异步任务"""
         respx.post(f"{client.config.server_url}/api/xparse/parse/async").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {"job_id": "job_123"},
-            })
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {"job_id": "job_123"},
+                },
+            )
         )
 
         result = client.parse.create_async_job(
@@ -76,10 +79,13 @@ class TestParseAPI:
     def test_create_async_job_with_config(self, client, sample_pdf_bytes):
         """测试创建异步任务（带配置）"""
         respx.post(f"{client.config.server_url}/api/xparse/parse/async").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {"job_id": "job_456"},
-            })
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {"job_id": "job_456"},
+                },
+            )
         )
 
         result = client.parse.create_async_job(
@@ -94,10 +100,13 @@ class TestParseAPI:
     def test_create_async_job_with_webhook(self, client, sample_pdf_bytes):
         """测试创建异步任务（带 webhook）"""
         respx.post(f"{client.config.server_url}/api/xparse/parse/async").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {"job_id": "job_789"},
-            })
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {"job_id": "job_789"},
+                },
+            )
         )
 
         result = client.parse.create_async_job(
@@ -112,18 +121,19 @@ class TestParseAPI:
     def test_get_result_completed(self, client):
         """测试获取已完成的任务结果"""
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "file_id": "file_456",
-                    "status": "completed",
-                    "result_url": "https://example.com/result.json",
-                    "elements": [
-                        {"element_id": "elem_001", "type": "text", "text": "test"}
-                    ],
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "file_id": "file_456",
+                        "status": "completed",
+                        "result_url": "https://example.com/result.json",
+                        "elements": [{"element_id": "elem_001", "type": "text", "text": "test"}],
+                    },
                 },
-            })
+            )
         )
 
         result = client.parse.get_result(job_id="job_123")
@@ -141,13 +151,16 @@ class TestParseAPI:
     def test_get_result_in_progress(self, client):
         """测试获取进行中的任务"""
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "status": "in_progress",
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "in_progress",
+                    },
                 },
-            })
+            )
         )
 
         result = client.parse.get_result(job_id="job_123")
@@ -161,13 +174,16 @@ class TestParseAPI:
     def test_get_result_scheduled(self, client):
         """测试获取已调度但未开始的任务"""
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "status": "scheduled",
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "scheduled",
+                    },
                 },
-            })
+            )
         )
 
         result = client.parse.get_result(job_id="job_123")
@@ -180,14 +196,17 @@ class TestParseAPI:
     def test_get_result_failed(self, client):
         """测试获取失败的任务"""
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "status": "failed",
-                    "error_message": "处理失败",
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "failed",
+                        "error_message": "处理失败",
+                    },
                 },
-            })
+            )
         )
 
         result = client.parse.get_result(job_id="job_123")
@@ -198,35 +217,41 @@ class TestParseAPI:
         assert result.error_message == "处理失败"
 
     @respx.mock
-    @patch('time.sleep')
+    @patch("time.sleep")
     def test_wait_for_result_success(self, mock_sleep, client):
         """测试等待任务完成（成功）"""
         # 第一次查询: 进行中
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
             side_effect=[
-                httpx.Response(200, json={
-                    "code": 200,
-                    "data": {
-                        "job_id": "job_123",
-                        "status": "in_progress",
+                httpx.Response(
+                    200,
+                    json={
+                        "code": 200,
+                        "data": {
+                            "job_id": "job_123",
+                            "status": "in_progress",
+                        },
                     },
-                }),
-                httpx.Response(200, json={
-                    "code": 200,
-                    "data": {
-                        "job_id": "job_123",
-                        "status": "completed",
-                        "elements": [
-                            {"element_id": "elem_001", "type": "text", "text": "test"}
-                        ],
+                ),
+                httpx.Response(
+                    200,
+                    json={
+                        "code": 200,
+                        "data": {
+                            "job_id": "job_123",
+                            "status": "completed",
+                            "elements": [
+                                {"element_id": "elem_001", "type": "text", "text": "test"}
+                            ],
+                        },
                     },
-                }),
+                ),
             ]
         )
 
         result = client.parse.wait_for_result(
             job_id="job_123",
-            poll_interval_seconds=1,
+            poll_interval=1,
         )
 
         assert result.is_completed
@@ -236,18 +261,21 @@ class TestParseAPI:
         mock_sleep.assert_called_with(1)
 
     @respx.mock
-    @patch('time.sleep')
+    @patch("time.sleep")
     def test_wait_for_result_immediate_completion(self, mock_sleep, client):
         """测试等待任务完成（立即完成）"""
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "status": "completed",
-                    "elements": [],
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "completed",
+                        "elements": [],
+                    },
                 },
-            })
+            )
         )
 
         result = client.parse.wait_for_result(job_id="job_123")
@@ -257,18 +285,21 @@ class TestParseAPI:
         assert mock_sleep.call_count == 0
 
     @respx.mock
-    @patch('time.sleep')
+    @patch("time.sleep")
     def test_wait_for_result_task_failed(self, mock_sleep, client):
         """测试等待任务完成（任务失败）"""
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "status": "failed",
-                    "error_message": "文件格式不支持",
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "failed",
+                        "error_message": "文件格式不支持",
+                    },
                 },
-            })
+            )
         )
 
         with pytest.raises(APIError) as exc_info:
@@ -278,62 +309,74 @@ class TestParseAPI:
         assert "文件格式不支持" in str(exc_info.value)
 
     @respx.mock
-    @patch('time.time')
-    @patch('time.sleep')
+    @patch("time.time")
+    @patch("time.sleep")
     def test_wait_for_result_timeout(self, mock_sleep, mock_time, client):
         """测试等待任务超时"""
         # Mock time.time() 返回递增的时间
         mock_time.side_effect = [0, 5, 11]  # 第一次0秒，第二次5秒，第三次11秒
 
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "status": "in_progress",
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "in_progress",
+                    },
                 },
-            })
+            )
         )
 
         with pytest.raises(RequestTimeoutError) as exc_info:
             client.parse.wait_for_result(
                 job_id="job_123",
-                timeout_seconds=10,
-                poll_interval_seconds=5,
+                timeout=10,
+                poll_interval=5,
             )
 
         assert "等待解析任务超时" in str(exc_info.value)
         assert "job_123" in str(exc_info.value)
 
     @respx.mock
-    @patch('time.sleep')
+    @patch("time.sleep")
     def test_wait_for_result_multiple_polls(self, mock_sleep, client):
         """测试多次轮询后完成"""
         # 模拟 3 次轮询: scheduled -> in_progress -> completed
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
             side_effect=[
-                httpx.Response(200, json={
-                    "code": 200,
-                    "data": {"job_id": "job_123", "status": "scheduled"},
-                }),
-                httpx.Response(200, json={
-                    "code": 200,
-                    "data": {"job_id": "job_123", "status": "in_progress"},
-                }),
-                httpx.Response(200, json={
-                    "code": 200,
-                    "data": {
-                        "job_id": "job_123",
-                        "status": "completed",
-                        "elements": [],
+                httpx.Response(
+                    200,
+                    json={
+                        "code": 200,
+                        "data": {"job_id": "job_123", "status": "scheduled"},
+                    },
+                ),
+                httpx.Response(
+                    200,
+                    json={
+                        "code": 200,
+                        "data": {"job_id": "job_123", "status": "in_progress"},
                     },
-                }),
+                ),
+                httpx.Response(
+                    200,
+                    json={
+                        "code": 200,
+                        "data": {
+                            "job_id": "job_123",
+                            "status": "completed",
+                            "elements": [],
+                        },
+                    },
+                ),
             ]
         )
 
         result = client.parse.wait_for_result(
             job_id="job_123",
-            poll_interval_seconds=2,
+            poll_interval=2,
         )
 
         assert result.is_completed
@@ -344,31 +387,33 @@ class TestParseAPI:
     def test_wait_for_result_custom_intervals(self, client):
         """测试自定义轮询参数"""
         respx.get(f"{client.config.server_url}/api/xparse/parse/async/job_123").mock(
-            return_value=httpx.Response(200, json={
-                "code": 200,
-                "data": {
-                    "job_id": "job_123",
-                    "status": "completed",
-                    "elements": [],
+            return_value=httpx.Response(
+                200,
+                json={
+                    "code": 200,
+                    "data": {
+                        "job_id": "job_123",
+                        "status": "completed",
+                        "elements": [],
+                    },
                 },
-            })
+            )
         )
 
         result = client.parse.wait_for_result(
             job_id="job_123",
-            timeout_seconds=300,
-            poll_interval_seconds=10,
+            timeout=300,
+            poll_interval=10,
         )
 
         assert result.is_completed
 
     def test_partition_async_removed(self, client):
         """测试 partition_async 方法已被移除"""
-        assert not hasattr(client.parse, 'partition_async')
+        assert not hasattr(client.parse, "partition_async")
 
     def test_async_job_methods_still_exist(self, client):
         """测试服务端异步任务方法仍然存在"""
-        assert hasattr(client.parse, 'create_async_job')
-        assert hasattr(client.parse, 'get_result')
-        assert hasattr(client.parse, 'wait_for_result')
-
+        assert hasattr(client.parse, "create_async_job")
+        assert hasattr(client.parse, "get_result")
+        assert hasattr(client.parse, "wait_for_result")

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9}/tests/unit/test_exceptions.py

@@ -1,6 +1,5 @@
 """异常类测试"""
 
-
 from xparse_client.exceptions import (
     APIError,
     AuthenticationError,
@@ -137,9 +136,9 @@ class TestAPIError:
         """测试超时错误"""
         error = RequestTimeoutError(
             "请求超时",
-            timeout_seconds=30.0,
+            timeout=30.0,
         )
-        assert error.timeout_seconds == 30.0
+        assert error.timeout == 30.0
 
 
 class TestConnectorError:

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9}/xparse_client/_http.py

@@ -291,7 +291,7 @@ class HTTPClient:
                     continue
                 raise RequestTimeoutError(
                     f"请求超时: {path}",
-                    timeout_seconds=timeout or self.config.timeout,
+                    timeout=timeout or self.config.timeout,
                 ) from e
 
             except httpx.RequestError as e:

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9}/xparse_client/api/parse.py

@@ -86,7 +86,6 @@ class Parse(BaseAPI):
         response = self._post("/parse/sync", files=files, data=data)
         return self._parse_response(response, ParseResponse)
 
-
     def create_async_job(
         self,
         *,
@@ -127,7 +126,6 @@ class Parse(BaseAPI):
         response = self._post("/parse/async", files=files, data=data)
         return self._parse_response(response, AsyncJobResponse)
 
-
     def get_result(self, *, job_id: str) -> JobStatusResponse:
         """获取异步解析结果
 
@@ -149,13 +147,12 @@ class Parse(BaseAPI):
         response = self._get(f"/parse/async/{job_id}")
         return self._parse_response(response, JobStatusResponse)
 
-
     def wait_for_result(
         self,
         *,
         job_id: str,
-        timeout_seconds: float = 3600,
-        poll_interval_seconds: float = 5,
+        timeout: float = 3600,
+        poll_interval: float = 5,
     ) -> JobStatusResponse:
         """等待异步任务完成
 
@@ -163,8 +160,8 @@ class Parse(BaseAPI):
 
         Args:
             job_id: 任务 ID
-            timeout_seconds: 超时时间（秒），默认 3600
-            poll_interval_seconds: 轮询间隔（秒），默认 5
+            timeout: 超时时间（秒），默认 3600
+            poll_interval: 轮询间隔（秒），默认 5
 
         Returns:
             JobStatusResponse: 完成的任务结果
@@ -177,8 +174,8 @@ class Parse(BaseAPI):
             >>> job = client.parse.create_async_job(file=file_bytes, filename="doc.pdf")
             >>> result = client.parse.wait_for_result(
             ...     job_id=job.job_id,
-            ...     timeout_seconds=600,
-            ...     poll_interval_seconds=10
+            ...     timeout=600,
+            ...     poll_interval=10
             ... )
         """
         start_time = time.time()
@@ -196,14 +193,13 @@ class Parse(BaseAPI):
                 )
 
             elapsed = time.time() - start_time
-            if elapsed > timeout_seconds:
+            if elapsed > timeout:
                 raise RequestTimeoutError(
                     f"等待解析任务超时: {job_id}",
-                    timeout_seconds=timeout_seconds,
+                    timeout=timeout,
                 )
 
-            time.sleep(poll_interval_seconds)
-
+            time.sleep(poll_interval)
 
 
 __all__ = ["Parse"]

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9}/xparse_client/exceptions.py

@@ -248,21 +248,21 @@ class RequestTimeoutError(APIError):
     请求超时时抛出。
 
     Attributes:
-        timeout_seconds: 超时时间设置
+        timeout: 超时时间设置
     """
 
     def __init__(
         self,
         message: str,
         *,
-        timeout_seconds: float | None = None,
+        timeout: float | None = None,
         **kwargs: Any,
     ) -> None:
-        self.timeout_seconds = timeout_seconds
+        self.timeout = timeout
 
         details = kwargs.pop("details", {}) or {}
-        if timeout_seconds:
-            details["timeout_seconds"] = timeout_seconds
+        if timeout:
+            details["timeout_seconds"] = timeout
 
         super().__init__(message, details=details, **kwargs)
 

{xparse_client-0.3.0b8 → xparse_client-0.3.0b9/xparse_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xparse-client
-Version: 0.3.0b8
+Version: 0.3.0b9
 Summary: 面向 Agent 和 RAG 的文档处理 Pipeline 客户端
 Author-email: INTSIG-TEXTIN <support@textin.com>
 License-Expression: MIT