xparse-client 0.3.0b8__py3-none-any.whl → 0.3.0b10__py3-none-any.whl

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("  未提取到数据")
 

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()
 
 

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")

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/_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/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/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.dist-info → xparse_client-0.3.0b10.dist-info}/METADATA

@@ -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.dist-info → xparse_client-0.3.0b10.dist-info}/RECORD

@@ -1,5 +1,5 @@
-example/1_basic_api_usage.py,sha256=x_ZHEWXz6z7qp-sMLBvq7Vpu6nA7YxVCizyQpDday6M,5802
-example/2_async_job.py,sha256=CT03sKz2dwTJRqSde8s5o75oe-p3ze43i0E1i_-Ai5Q,6352
+example/1_basic_api_usage.py,sha256=wUng_3X-6v_dEWD0CvTKzoYUhvNkYlCML0PE2gCPC1Q,5700
+example/2_async_job.py,sha256=n_2nv_GJPJ1t2-6yHGWK1K7uHd8InG63s8C6bL96iS8,6313
 example/3_local_workflow.py,sha256=ZxoT8N0Nz4_s-bkLF0l6UDqBJk_eZZi99WUtUhJseXs,8980
 example/4_advanced_workflow.py,sha256=KH6gmzoKi6oeHIPDv9snw1YehynHTDqWVq1WFtoqGws,10156
 example/README.md,sha256=d-DumaZwbV96K6ZTEryAlDSk9HUhRBg0gG_Yekx9PqA,2336
@@ -9,12 +9,12 @@ tests/unit/__init__.py,sha256=C1308ox8hFFtq3A1vBAVPzL6r8HGVbEbC42ULCpFkjs,25
 tests/unit/test_base.py,sha256=HRW2irYNAX863PBCtJWvN9EJ_UttfOwRI7CRnDdcjEk,11599
 tests/unit/test_client.py,sha256=92geEJ6jBht7nFr5suRbJ6SmkvzCu_HGB5MhSl4Qmr8,3534
 tests/unit/test_config.py,sha256=OAUKvmEtpC-eAglnDzhp1bUyMlUpaeqLAa1QwyxCUdw,5498
-tests/unit/test_exceptions.py,sha256=BEaGSs34_jmdjUuT4e3S3QONDqldamiXNId04PPdMt4,5155
+tests/unit/test_exceptions.py,sha256=H_DfISn5SGEiOsFoLBNK11JVViCyfWv5a0kMfnuzfkY,5138
 tests/unit/test_http.py,sha256=3h-O6k5rcVP_I1sPoISOYLdHAKtSxoPrDOfC3EJyNi0,16490
 tests/unit/api/__init__.py,sha256=5HiLverbqHC-yFxXClrHBjHq62KoONLZPLMMOkYR3eU,23
 tests/unit/api/test_extract.py,sha256=QX4_BAQN6MkRTJQocEf9u6HwOA_XoY_a2djMcuLBCTo,6959
 tests/unit/api/test_local.py,sha256=_DXC8PattJ-CH9inlwDu9s1RCocTGVeYpKFpTiwDwa4,7541
-tests/unit/api/test_parse.py,sha256=EUA3emZFAFefop3CcUgqyLGC1lhd5ujx6x-dGE5h3pw,12639
+tests/unit/api/test_parse.py,sha256=2I9RKmgCEyMy-i_g9r4j-qwsKtdcm7lIrZdhmv6t4PU,13724
 tests/unit/api/test_pipeline.py,sha256=0TC_upZbSllQfuz7uGOCvx28BDNCnX1POR92JLnfrIE,11067
 tests/unit/api/test_workflows.py,sha256=lYVbOWph8ZqxszFQTgcFHnxgdp9jjJM35F-wKO3IUuY,3286
 tests/unit/connectors/test_ftp.py,sha256=7NbV7cL9tIy03L7_sWoALrfDmjda_xOgfAoBfUnF9ks,14605
@@ -31,12 +31,12 @@ xparse_client/__init__.py,sha256=FyR7W0eteapDoPj2pU4VoTobM8XR2B7f_g4yVI-v2v8,395
 xparse_client/_base.py,sha256=IPYdHREM0CUvZ_kWUp4olYQfsfKzPTQoZuIrNSanKq4,4661
 xparse_client/_client.py,sha256=ZGxZ9xhUitTP-eRhte57ekqUkrXxNubFDL5gojajA2s,6964
 xparse_client/_config.py,sha256=BG3cEW5ywKhmtfHjfTFrdezs2Ugc9P2Y85tzu5OZZ4M,6480
-xparse_client/_http.py,sha256=Y0-x8CZbHVbi4Jmln1d60oD_Pz1nwQAf-0sbON4B9qo,11443
-xparse_client/exceptions.py,sha256=FNozgCFaQSsdeyxE6P-3CZItkTSfFJcIQVrddHWKN0s,9521
+xparse_client/_http.py,sha256=UMPAYZVfEmF8m718s084at6PQtHxiQDqAlv2XgmDuYc,11435
+xparse_client/exceptions.py,sha256=pv0RhaOPsd7NrRCzKjJjqErNG52xPPrXQ7IzWNb-dvI,9473
 xparse_client/api/__init__.py,sha256=MZ3wBTDU666efOBv81MKKtc1UkjUsjzIEOpsnDUAHD4,203
 xparse_client/api/extract.py,sha256=87tH-y4sXPKW35l-d0GmZdK9RIXWq4tfmGZXYJhIN60,3011
 xparse_client/api/local.py,sha256=dARW6RjiNsxliWxs7cB6qQl9eTZNvyjBpOG8qXyaIaw,8214
-xparse_client/api/parse.py,sha256=nvpu5kiN43QlyMW3N6vMruVADu6MdjS-TMbLFjBh-cc,5870
+xparse_client/api/parse.py,sha256=2TBuWg8FY9Vteb06mWcNUfPsTPiIcg8g3eoKtaqP9W4,5786
 xparse_client/api/pipeline.py,sha256=bPCSpWjER-7c7L0iMQ_Xz1VTe5DARMsX5XIcrayGKzw,4530
 xparse_client/api/workflows.py,sha256=29_Rf4bIH1fiJb_bWShkUm-et97ym5ymQFh5i3b5mDI,5945
 xparse_client/connectors/__init__.py,sha256=BLGxk9i8BsVCr4RMrCIh8b9cywBqXXmcDHqfF7C_FX0,1113
@@ -61,8 +61,8 @@ xparse_client/models/local.py,sha256=hqKmyWTU_EhPk6qybtBzmbLybBBaiasTpqM4_zP-ipo
 xparse_client/models/parse.py,sha256=COgxroHkJce_S7d2HGd_1zBYhkpCutGtmjyLnpI2_eI,3154
 xparse_client/models/pipeline.py,sha256=24bDzhrVotQ8St6VLEJLvG2cZF0G2AMioKI34I_hJXI,3297
 xparse_client/models/workflows.py,sha256=BivMdGOAmhP6oYLQSGAAN7yml2xb7vHHrpzwLgN_Afk,1754
-xparse_client-0.3.0b8.dist-info/licenses/LICENSE,sha256=7iuki7DyWMGB8PBzsht7PUt0YjdIcPjrcXNyUFgMJsw,1070
-xparse_client-0.3.0b8.dist-info/METADATA,sha256=mrVOWpID-szyT7O2GlKxymxTLlbWFZfeuIsoxLItmuk,25471
-xparse_client-0.3.0b8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-xparse_client-0.3.0b8.dist-info/top_level.txt,sha256=oQGc_qysOmnSAaLjwB72wH8RBHRAmxB-_qb-Uj6u56o,28
-xparse_client-0.3.0b8.dist-info/RECORD,,
+xparse_client-0.3.0b10.dist-info/licenses/LICENSE,sha256=7iuki7DyWMGB8PBzsht7PUt0YjdIcPjrcXNyUFgMJsw,1070
+xparse_client-0.3.0b10.dist-info/METADATA,sha256=SV-pasi2iASwYXsWFRdLli2uGIQpGAeBfqE5eXM-HMg,25873
+xparse_client-0.3.0b10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+xparse_client-0.3.0b10.dist-info/top_level.txt,sha256=oQGc_qysOmnSAaLjwB72wH8RBHRAmxB-_qb-Uj6u56o,28
+xparse_client-0.3.0b10.dist-info/RECORD,,