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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xparse-client
-Version: 0.3.0b8
+Version: 0.3.0b10
 Summary: 面向 Agent 和 RAG 的文档处理 Pipeline 客户端
 Author-email: INTSIG-TEXTIN <support@textin.com>
 License-Expression: MIT
@@ -223,6 +223,7 @@ with open("document.pdf", "rb") as f:
         extract_config=ExtractConfig(schema=schema)
     )
 
+# Extract API 返回的结构化数据在 result.result 中
 print(result.result)
 ```
 
@@ -277,22 +278,11 @@ result = client.parse.wait_for_result(
     poll_interval=5.0
 )
 
-print(f"任务完成，解析出 {len(result.result.elements)} 个元素")
-```
-
-### 同步 vs 异步
-
-```python
-# 同步调用（适合小文件）
-result = client.parse.partition(file=f, filename="doc.pdf")
-
-# 异步调用（相同接口，加上 _async 后缀）
-import asyncio
-
-async def main():
-    result = await client.parse.partition_async(file=f, filename="doc.pdf")
-
-asyncio.run(main())
+if result.is_completed:
+    print(f"任务完成，结果 URL: {result.result_url}")
+    print("💡 异步任务返回的是 result_url，需要另外下载来获取解析结果")
+elif result.is_failed:
+    print(f"任务失败: {result.error_message}")
 ```
 
 ---
@@ -326,7 +316,17 @@ result = client.pipeline.execute(
 
 ### 📊 详细的处理统计
 
+Pipeline API 返回详细的处理统计信息：
+
 ```python
+# 使用 Pipeline API 时可以获取统计信息
+result = client.pipeline.execute(
+    file=f,
+    filename="document.pdf",
+    stages=[ParseStage(...), ChunkStage(...), EmbedStage(...)]
+)
+
+# 访问统计信息
 print(f"原始元素: {result.stats.original_elements}")
 print(f"分块后: {result.stats.chunked_elements}")
 print(f"向量化: {result.stats.embedded_elements}")
@@ -750,11 +750,15 @@ job = client.parse.create_async_job(file=f, filename="large.pdf")
 
 # 方式 1：自动等待完成
 result = client.parse.wait_for_result(job_id=job.job_id, timeout=300)
+if result.is_completed:
+    print(f"任务完成，结果 URL: {result.result_url}")
+    # 注意：异步任务返回的是 result_url，需要另外下载来获取解析结果
 
 # 方式 2：手动轮询
 while True:
     status = client.parse.get_result(job_id=job.job_id)
-    if status.status == "completed":
+    if status.is_completed:
+        print(f"结果 URL: {status.result_url}")
         break
     time.sleep(5)
 ```

{xparse_client-0.3.0b8 → xparse_client-0.3.0b10}/README.md

@@ -174,6 +174,7 @@ with open("document.pdf", "rb") as f:
         extract_config=ExtractConfig(schema=schema)
     )
 
+# Extract API 返回的结构化数据在 result.result 中
 print(result.result)
 ```
 
@@ -228,22 +229,11 @@ result = client.parse.wait_for_result(
     poll_interval=5.0
 )
 
-print(f"任务完成，解析出 {len(result.result.elements)} 个元素")
-```
-
-### 同步 vs 异步
-
-```python
-# 同步调用（适合小文件）
-result = client.parse.partition(file=f, filename="doc.pdf")
-
-# 异步调用（相同接口，加上 _async 后缀）
-import asyncio
-
-async def main():
-    result = await client.parse.partition_async(file=f, filename="doc.pdf")
-
-asyncio.run(main())
+if result.is_completed:
+    print(f"任务完成，结果 URL: {result.result_url}")
+    print("💡 异步任务返回的是 result_url，需要另外下载来获取解析结果")
+elif result.is_failed:
+    print(f"任务失败: {result.error_message}")
 ```
 
 ---
@@ -277,7 +267,17 @@ result = client.pipeline.execute(
 
 ### 📊 详细的处理统计
 
+Pipeline API 返回详细的处理统计信息：
+
 ```python
+# 使用 Pipeline API 时可以获取统计信息
+result = client.pipeline.execute(
+    file=f,
+    filename="document.pdf",
+    stages=[ParseStage(...), ChunkStage(...), EmbedStage(...)]
+)
+
+# 访问统计信息
 print(f"原始元素: {result.stats.original_elements}")
 print(f"分块后: {result.stats.chunked_elements}")
 print(f"向量化: {result.stats.embedded_elements}")
@@ -701,11 +701,15 @@ job = client.parse.create_async_job(file=f, filename="large.pdf")
 
 # 方式 1：自动等待完成
 result = client.parse.wait_for_result(job_id=job.job_id, timeout=300)
+if result.is_completed:
+    print(f"任务完成，结果 URL: {result.result_url}")
+    # 注意：异步任务返回的是 result_url，需要另外下载来获取解析结果
 
 # 方式 2：手动轮询
 while True:
     status = client.parse.get_result(job_id=job.job_id)
-    if status.status == "completed":
+    if status.is_completed:
+        print(f"结果 URL: {status.result_url}")
         break
     time.sleep(5)
 ```

{xparse_client-0.3.0b8 → xparse_client-0.3.0b10}/example/1_basic_api_usage.py

@@ -95,9 +95,9 @@ def example_2_extract_structured_data():
             )
 
         print("\n✅ 提取成功!")
-        # Extract API 返回的数据在 extract_result.extracted_schema 中
-        if result.extract_result and "extracted_schema" in result.extract_result:
-            print(f"  提取的数据: {result.extract_result['extracted_schema']}")
+        # Extract API 返回的数据在 result.result 中
+        if result.result:
+            print(f"  提取的数据: {result.result}")
         else:
             print("  未提取到数据")
 

{xparse_client-0.3.0b8 → xparse_client-0.3.0b10}/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,18 +45,15 @@ 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✅ 任务完成!")
             print(f"  - 任务 ID: {result.job_id}")
             print(f"  - 文件 ID: {result.file_id}")
             print(f"  - 结果 URL: {result.result_url}")
-            print("\n  💡 提示: 需要下载 result_url 来获取解析结果")
+            print("\n  💡 提示: 异步任务只返回 result_url，需要另外下载来获取解析结果")
+            print("           result_url 是一个可以下载的 JSON 文件 URL")
         elif result.is_failed:
             print(f"\n❌ 任务失败: {result.error_message}")
         else:
@@ -70,9 +65,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 +79,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 +121,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 +135,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 +144,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 +164,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 +187,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.0b10}/pyproject.toml

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

{xparse_client-0.3.0b8 → xparse_client-0.3.0b10}/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.0b10}/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.0b10}/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.0b10}/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.0b10}/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.0b10/xparse_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xparse-client
-Version: 0.3.0b8
+Version: 0.3.0b10
 Summary: 面向 Agent 和 RAG 的文档处理 Pipeline 客户端
 Author-email: INTSIG-TEXTIN <support@textin.com>
 License-Expression: MIT
@@ -223,6 +223,7 @@ with open("document.pdf", "rb") as f:
         extract_config=ExtractConfig(schema=schema)
     )
 
+# Extract API 返回的结构化数据在 result.result 中
 print(result.result)
 ```
 
@@ -277,22 +278,11 @@ result = client.parse.wait_for_result(
     poll_interval=5.0
 )
 
-print(f"任务完成，解析出 {len(result.result.elements)} 个元素")
-```
-
-### 同步 vs 异步
-
-```python
-# 同步调用（适合小文件）
-result = client.parse.partition(file=f, filename="doc.pdf")
-
-# 异步调用（相同接口，加上 _async 后缀）
-import asyncio
-
-async def main():
-    result = await client.parse.partition_async(file=f, filename="doc.pdf")
-
-asyncio.run(main())
+if result.is_completed:
+    print(f"任务完成，结果 URL: {result.result_url}")
+    print("💡 异步任务返回的是 result_url，需要另外下载来获取解析结果")
+elif result.is_failed:
+    print(f"任务失败: {result.error_message}")
 ```
 
 ---
@@ -326,7 +316,17 @@ result = client.pipeline.execute(
 
 ### 📊 详细的处理统计
 
+Pipeline API 返回详细的处理统计信息：
+
 ```python
+# 使用 Pipeline API 时可以获取统计信息
+result = client.pipeline.execute(
+    file=f,
+    filename="document.pdf",
+    stages=[ParseStage(...), ChunkStage(...), EmbedStage(...)]
+)
+
+# 访问统计信息
 print(f"原始元素: {result.stats.original_elements}")
 print(f"分块后: {result.stats.chunked_elements}")
 print(f"向量化: {result.stats.embedded_elements}")
@@ -750,11 +750,15 @@ job = client.parse.create_async_job(file=f, filename="large.pdf")
 
 # 方式 1：自动等待完成
 result = client.parse.wait_for_result(job_id=job.job_id, timeout=300)
+if result.is_completed:
+    print(f"任务完成，结果 URL: {result.result_url}")
+    # 注意：异步任务返回的是 result_url，需要另外下载来获取解析结果
 
 # 方式 2：手动轮询
 while True:
     status = client.parse.get_result(job_id=job.job_id)
-    if status.status == "completed":
+    if status.is_completed:
+        print(f"结果 URL: {status.result_url}")
         break
     time.sleep(5)
 ```