parallel-web 0.5.1__tar.gz → 0.6.0__tar.gz

{parallel_web-0.5.1 → parallel_web-0.6.0}/.gitignore

@@ -14,3 +14,4 @@ dist
 .envrc
 codegen.log
 Brewfile.lock.json
+uv.lock

parallel_web-0.6.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.6.0"
+}

{parallel_web-0.5.1 → parallel_web-0.6.0}/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## 0.6.0 (2026-05-06)
+
+Full Changelog: [v0.5.1...v0.6.0](https://github.com/parallel-web/parallel-sdk-python/compare/v0.5.1...v0.6.0)
+
+### Features
+
+* **api:** manual updates ([8cb17ac](https://github.com/parallel-web/parallel-sdk-python/commit/8cb17ac6d6c9a5a9e6443d9ecf5c121250b2eed2))
+* **api:** manual updates ([e4008e4](https://github.com/parallel-web/parallel-sdk-python/commit/e4008e4f8432a6c3e2341d18fee37fcedf8a530e))
+* **api:** manual updates ([174407f](https://github.com/parallel-web/parallel-sdk-python/commit/174407ff7467789e19d3abeffcaccd36fd35e786))
+* **api:** manual updates ([1c47c8b](https://github.com/parallel-web/parallel-sdk-python/commit/1c47c8baa579a403064e59a5fbb75400315951c9))
+* **api:** Task Groups v1 added to SDK ([198e317](https://github.com/parallel-web/parallel-sdk-python/commit/198e317bb3b5e5961e63c1c04bac0eb593385b7b))
+* support setting headers via env ([6dd2b05](https://github.com/parallel-web/parallel-sdk-python/commit/6dd2b05bcf25259ae50e650376c3182913439487))
+
+
+### Bug Fixes
+
+* re-export TaskGroup from parallel.types.beta and silence reportDeprecated ([dc6119f](https://github.com/parallel-web/parallel-sdk-python/commit/dc6119f6dccdef75bdbe4ce838dd8ba51cc2428a))
+* **scripts:** remove unreachable check and redundant type annotation ([f63ad0a](https://github.com/parallel-web/parallel-sdk-python/commit/f63ad0ae48994be8b16c20438bb80c61cd943fec))
+* **scripts:** satisfy pyright in alias resolver ([892f474](https://github.com/parallel-web/parallel-sdk-python/commit/892f4743488ae5d8c4683123193da4f4e61d2464))
+* **types:** preserve back-compat aliases for renamed inline classes ([532ee8f](https://github.com/parallel-web/parallel-sdk-python/commit/532ee8f32ecbaf611f0ff5f6c80a532e2f0bcd66))
+* **types:** use module-level alias instead of import-as ([b1b9858](https://github.com/parallel-web/parallel-sdk-python/commit/b1b9858ffa95d90871ce36b06e510638e3546bde))
+* use correct field name format for multipart file arrays ([1e34228](https://github.com/parallel-web/parallel-sdk-python/commit/1e3422859a25c66804f7f588fd24276417c52057))
+
+
+### Chores
+
+* **internal:** more robust bootstrap script ([d4c7737](https://github.com/parallel-web/parallel-sdk-python/commit/d4c773762e983a657fb4c6f5d39529c3467e0994))
+* **internal:** reformat pyproject.toml ([b3c0639](https://github.com/parallel-web/parallel-sdk-python/commit/b3c063982542886a490679f840ca0fad94695227))
+* **scripts:** follow alias and attribute redirections in breaking-change detection ([89b1495](https://github.com/parallel-web/parallel-sdk-python/commit/89b1495236f280eee8af7c48ecff3ff2453291bd))
+* stop tracking uv.lock (project uses requirements*.lock from rye) ([540471a](https://github.com/parallel-web/parallel-sdk-python/commit/540471afb4da3a6ed485af15554cb548e7086bbd))
+
 ## 0.5.1 (2026-04-22)
 
 Full Changelog: [v0.5.0...v0.5.1](https://github.com/parallel-web/parallel-sdk-python/compare/v0.5.0...v0.5.1)

{parallel_web-0.5.1 → parallel_web-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: parallel-web
-Version: 0.5.1
+Version: 0.6.0
 Summary: The official Python library for the Parallel API
 Project-URL: Homepage, https://github.com/parallel-web/parallel-sdk-python
 Project-URL: Repository, https://github.com/parallel-web/parallel-sdk-python

parallel_web-0.6.0/api.md

@@ -0,0 +1,128 @@
+# Shared Types
+
+```python
+from parallel.types import ErrorObject, ErrorResponse, SourcePolicy, Warning
+```
+
+# Parallel
+
+Types:
+
+```python
+from parallel.types import (
+    AdvancedExtractSettings,
+    AdvancedSearchSettings,
+    ExcerptSettings,
+    ExtractError,
+    ExtractResponse,
+    ExtractResult,
+    FetchPolicy,
+    FullContentSettings,
+    SearchResult,
+    UsageItem,
+    WebSearchResult,
+)
+```
+
+Methods:
+
+- <code title="post /v1/extract">client.<a href="./src/parallel/_client.py">extract</a>(\*\*<a href="src/parallel/types/client_extract_params.py">params</a>) -> <a href="./src/parallel/types/extract_response.py">ExtractResponse</a></code>
+- <code title="post /v1/search">client.<a href="./src/parallel/_client.py">search</a>(\*\*<a href="src/parallel/types/client_search_params.py">params</a>) -> <a href="./src/parallel/types/search_result.py">SearchResult</a></code>
+
+# TaskRun
+
+Types:
+
+```python
+from parallel.types import (
+    AutoSchema,
+    Citation,
+    FieldBasis,
+    JsonSchema,
+    ParsedTaskRunResult,
+    RunInput,
+    TaskAdvancedSettings,
+    TaskRun,
+    TaskRunJsonOutput,
+    TaskRunProgressMessageEvent,
+    TaskRunProgressStatsEvent,
+    TaskRunResult,
+    TaskRunSourceStats,
+    TaskRunTextOutput,
+    TaskSpec,
+    TextSchema,
+)
+```
+
+Methods:
+
+- <code title="post /v1/tasks/runs">client.task_run.<a href="./src/parallel/resources/task_run.py">create</a>(\*\*<a href="src/parallel/types/task_run_create_params.py">params</a>) -> <a href="./src/parallel/types/task_run.py">TaskRun</a></code>
+- <code title="get /v1/tasks/runs/{run_id}">client.task_run.<a href="./src/parallel/resources/task_run.py">retrieve</a>(run_id) -> <a href="./src/parallel/types/task_run.py">TaskRun</a></code>
+- <code title="get /v1/tasks/runs/{run_id}/result">client.task_run.<a href="./src/parallel/resources/task_run.py">result</a>(run_id, \*\*<a href="src/parallel/types/task_run_result_params.py">params</a>) -> <a href="./src/parallel/types/task_run_result.py">TaskRunResult</a></code>
+- <code title="get /v1/tasks/runs/{run_id}/input">client.task_run.<a href="./src/parallel/resources/task_run.py">retrieve_input</a>(run_id) -> <a href="./src/parallel/types/run_input.py">RunInput</a></code>
+
+Convenience methods:
+
+- <code title="post /v1/tasks/runs">client.task_run.<a href="./src/parallel/resources/task_run.py">execute</a>(input, processor, output: <a href="./src/parallel/types/task_spec_param.py">OutputSchema</a>) -> <a href="./src/parallel/types/task_run_result.py">TaskRunResult</a></code>
+- <code title="post /v1/tasks/runs">client.task_run.<a href="./src/parallel/resources/task_run.py">execute</a>(input, processor, output: Type[OutputT]) -> <a href="./src/parallel/types/parsed_task_run_result.py">ParsedTaskRunResult[OutputT]</a></code>
+# TaskGroup
+
+Types:
+
+```python
+from parallel.types import (
+    TaskGroup,
+    TaskGroupRunResponse,
+    TaskGroupStatus,
+    TaskGroupStatusEvent,
+    TaskGroupEventsResponse,
+    TaskGroupGetRunsResponse,
+)
+```
+
+Methods:
+
+- <code title="post /v1/tasks/groups">client.task_group.<a href="./src/parallel/resources/task_group.py">create</a>(\*\*<a href="src/parallel/types/task_group_create_params.py">params</a>) -> <a href="./src/parallel/types/task_group.py">TaskGroup</a></code>
+- <code title="get /v1/tasks/groups/{taskgroup_id}">client.task_group.<a href="./src/parallel/resources/task_group.py">retrieve</a>(task_group_id) -> <a href="./src/parallel/types/task_group.py">TaskGroup</a></code>
+- <code title="post /v1/tasks/groups/{taskgroup_id}/runs">client.task_group.<a href="./src/parallel/resources/task_group.py">add_runs</a>(task_group_id, \*\*<a href="src/parallel/types/task_group_add_runs_params.py">params</a>) -> <a href="./src/parallel/types/task_group_run_response.py">TaskGroupRunResponse</a></code>
+- <code title="get /v1/tasks/groups/{taskgroup_id}/events">client.task_group.<a href="./src/parallel/resources/task_group.py">events</a>(task_group_id, \*\*<a href="src/parallel/types/task_group_events_params.py">params</a>) -> <a href="./src/parallel/types/task_group_events_response.py">TaskGroupEventsResponse</a></code>
+- <code title="get /v1/tasks/groups/{taskgroup_id}/runs">client.task_group.<a href="./src/parallel/resources/task_group.py">get_runs</a>(task_group_id, \*\*<a href="src/parallel/types/task_group_get_runs_params.py">params</a>) -> <a href="./src/parallel/types/task_group_get_runs_response.py">TaskGroupGetRunsResponse</a></code>
+- <code title="get /v1/tasks/groups/{taskgroup_id}/runs/{run_id}">client.task_group.<a href="./src/parallel/resources/task_group.py">retrieve_run</a>(run_id, \*, task_group_id) -> <a href="./src/parallel/types/task_run.py">TaskRun</a></code>
+
+# Monitor
+
+Types:
+
+```python
+from parallel.types import (
+    AdvancedMonitorSettings,
+    CreateMonitorRequest,
+    Monitor,
+    MonitorCompletionEvent,
+    MonitorErrorEvent,
+    MonitorEventStreamEvent,
+    MonitorEventStreamResponseSettings,
+    MonitorEventStreamSettings,
+    MonitorSnapshotEvent,
+    MonitorSnapshotOutput,
+    MonitorSnapshotResponseSettings,
+    MonitorSnapshotSettings,
+    MonitorWebhook,
+    PaginatedMonitorEvents,
+    PaginatedMonitorResponse,
+    UpdateMonitorEventStreamSettings,
+    UpdateMonitorRequest,
+)
+```
+
+Methods:
+
+- <code title="post /v1/monitors">client.monitor.<a href="./src/parallel/resources/monitor.py">create</a>(\*\*<a href="src/parallel/types/monitor_create_params.py">params</a>) -> <a href="./src/parallel/types/monitor.py">Monitor</a></code>
+- <code title="get /v1/monitors/{monitor_id}">client.monitor.<a href="./src/parallel/resources/monitor.py">retrieve</a>(monitor_id) -> <a href="./src/parallel/types/monitor.py">Monitor</a></code>
+- <code title="post /v1/monitors/{monitor_id}/update">client.monitor.<a href="./src/parallel/resources/monitor.py">update</a>(monitor_id, \*\*<a href="src/parallel/types/monitor_update_params.py">params</a>) -> <a href="./src/parallel/types/monitor.py">Monitor</a></code>
+- <code title="get /v1/monitors">client.monitor.<a href="./src/parallel/resources/monitor.py">list</a>(\*\*<a href="src/parallel/types/monitor_list_params.py">params</a>) -> <a href="./src/parallel/types/paginated_monitor_response.py">PaginatedMonitorResponse</a></code>
+- <code title="post /v1/monitors/{monitor_id}/cancel">client.monitor.<a href="./src/parallel/resources/monitor.py">cancel</a>(monitor_id) -> <a href="./src/parallel/types/monitor.py">Monitor</a></code>
+- <code title="get /v1/monitors/{monitor_id}/events">client.monitor.<a href="./src/parallel/resources/monitor.py">events</a>(monitor_id, \*\*<a href="src/parallel/types/monitor_events_params.py">params</a>) -> <a href="./src/parallel/types/paginated_monitor_events.py">PaginatedMonitorEvents</a></code>
+- <code title="post /v1/monitors/{monitor_id}/trigger">client.monitor.<a href="./src/parallel/resources/monitor.py">trigger</a>(monitor_id) -> None</code>
+
+# [Beta](src/parallel/resources/beta/api.md)

{parallel_web-0.5.1 → parallel_web-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "parallel-web"
-version = "0.5.1"
+version = "0.6.0"
 description = "The official Python library for the Parallel API"
 dynamic = ["readme"]
 license = "MIT"
@@ -158,6 +158,11 @@ reportOverlappingOverload = false
 
 reportImportCycles = false
 reportPrivateUsage = false
+# Deprecation is a runtime concern; type-check warnings produce noise when the
+# breaking-change detector compares against pre-deprecation baseline tests.
+# Newly-generated tests already add a per-file `# pyright: reportDeprecated=false`
+# marker for deprecated resources, so this just promotes that to project-level.
+reportDeprecated = false
 
 [tool.mypy]
 pretty = true
@@ -169,7 +174,7 @@ show_error_codes = true
 #
 # We also exclude our `tests` as mypy doesn't always infer
 # types correctly and Pyright will still catch any type errors.
-exclude = ['src/parallel/_files.py', '_dev/.*.py', 'tests/.*']
+exclude = ["src/parallel/_files.py", "_dev/.*.py", "tests/.*"]
 
 strict_equality = true
 implicit_reexport = true

{parallel_web-0.5.1 → parallel_web-0.6.0}/src/parallel/_client.py

@@ -27,6 +27,7 @@ from ._types import (
 )
 from ._utils import (
     is_given,
+    is_mapping_t,
     maybe_transform,
     get_async_library,
     async_maybe_transform,
@@ -53,9 +54,11 @@ from .types.advanced_search_settings_param import AdvancedSearchSettingsParam
 from .types.advanced_extract_settings_param import AdvancedExtractSettingsParam
 
 if TYPE_CHECKING:
-    from .resources import beta, task_run
+    from .resources import beta, monitor, task_run, task_group
+    from .resources.monitor import MonitorResource, AsyncMonitorResource
     from .resources.task_run import TaskRunResource, AsyncTaskRunResource
     from .resources.beta.beta import BetaResource, AsyncBetaResource
+    from .resources.task_group import TaskGroupResource, AsyncTaskGroupResource
 
 __all__ = [
     "Timeout",
@@ -113,6 +116,15 @@ class Parallel(SyncAPIClient):
         if base_url is None:
             base_url = f"https://api.parallel.ai"
 
+        custom_headers_env = os.environ.get("PARALLEL_CUSTOM_HEADERS")
+        if custom_headers_env is not None:
+            parsed: dict[str, str] = {}
+            for line in custom_headers_env.split("\n"):
+                colon = line.find(":")
+                if colon >= 0:
+                    parsed[line[:colon].strip()] = line[colon + 1 :].strip()
+            default_headers = {**parsed, **(default_headers if is_mapping_t(default_headers) else {})}
+
         super().__init__(
             version=__version__,
             base_url=base_url,
@@ -132,7 +144,7 @@ class Parallel(SyncAPIClient):
         - Output metadata: citations, excerpts, reasoning, and confidence per field
 
         Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
-         - Submit hundreds or thousands of Tasks as a single group
+        - Submit hundreds or thousands of Tasks as a single group
         - Observe group progress and receive results as they complete
         - Real-time updates via Server-Sent Events (SSE)
         - Add tasks to an existing group while it is running
@@ -142,6 +154,38 @@ class Parallel(SyncAPIClient):
 
         return TaskRunResource(self)
 
+    @cached_property
+    def task_group(self) -> TaskGroupResource:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+
+        Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
+        - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        """
+        from .resources.task_group import TaskGroupResource
+
+        return TaskGroupResource(self)
+
+    @cached_property
+    def monitor(self) -> MonitorResource:
+        """The Monitor API watches the web for material changes on a fixed frequency.
+
+        Each monitor runs once on creation and then on its configured schedule, emitting events when meaningful changes are detected.
+        - `event_stream` monitors track a search query and emit an event for each new material change.
+        - `snapshot` monitors track a specific task run's output and emit an event when the output changes.
+
+        Results can be polled via the events endpoint or delivered via webhooks.
+        """
+        from .resources.monitor import MonitorResource
+
+        return MonitorResource(self)
+
     @cached_property
     def beta(self) -> BetaResource:
         from .resources.beta import BetaResource
@@ -464,6 +508,15 @@ class AsyncParallel(AsyncAPIClient):
         if base_url is None:
             base_url = f"https://api.parallel.ai"
 
+        custom_headers_env = os.environ.get("PARALLEL_CUSTOM_HEADERS")
+        if custom_headers_env is not None:
+            parsed: dict[str, str] = {}
+            for line in custom_headers_env.split("\n"):
+                colon = line.find(":")
+                if colon >= 0:
+                    parsed[line[:colon].strip()] = line[colon + 1 :].strip()
+            default_headers = {**parsed, **(default_headers if is_mapping_t(default_headers) else {})}
+
         super().__init__(
             version=__version__,
             base_url=base_url,
@@ -483,7 +536,7 @@ class AsyncParallel(AsyncAPIClient):
         - Output metadata: citations, excerpts, reasoning, and confidence per field
 
         Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
-         - Submit hundreds or thousands of Tasks as a single group
+        - Submit hundreds or thousands of Tasks as a single group
         - Observe group progress and receive results as they complete
         - Real-time updates via Server-Sent Events (SSE)
         - Add tasks to an existing group while it is running
@@ -493,6 +546,38 @@ class AsyncParallel(AsyncAPIClient):
 
         return AsyncTaskRunResource(self)
 
+    @cached_property
+    def task_group(self) -> AsyncTaskGroupResource:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+
+        Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
+        - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        """
+        from .resources.task_group import AsyncTaskGroupResource
+
+        return AsyncTaskGroupResource(self)
+
+    @cached_property
+    def monitor(self) -> AsyncMonitorResource:
+        """The Monitor API watches the web for material changes on a fixed frequency.
+
+        Each monitor runs once on creation and then on its configured schedule, emitting events when meaningful changes are detected.
+        - `event_stream` monitors track a search query and emit an event for each new material change.
+        - `snapshot` monitors track a specific task run's output and emit an event when the output changes.
+
+        Results can be polled via the events endpoint or delivered via webhooks.
+        """
+        from .resources.monitor import AsyncMonitorResource
+
+        return AsyncMonitorResource(self)
+
     @cached_property
     def beta(self) -> AsyncBetaResource:
         from .resources.beta import AsyncBetaResource
@@ -792,7 +877,7 @@ class ParallelWithRawResponse:
         - Output metadata: citations, excerpts, reasoning, and confidence per field
 
         Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
-         - Submit hundreds or thousands of Tasks as a single group
+        - Submit hundreds or thousands of Tasks as a single group
         - Observe group progress and receive results as they complete
         - Real-time updates via Server-Sent Events (SSE)
         - Add tasks to an existing group while it is running
@@ -802,6 +887,38 @@ class ParallelWithRawResponse:
 
         return TaskRunResourceWithRawResponse(self._client.task_run)
 
+    @cached_property
+    def task_group(self) -> task_group.TaskGroupResourceWithRawResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+
+        Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
+        - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        """
+        from .resources.task_group import TaskGroupResourceWithRawResponse
+
+        return TaskGroupResourceWithRawResponse(self._client.task_group)
+
+    @cached_property
+    def monitor(self) -> monitor.MonitorResourceWithRawResponse:
+        """The Monitor API watches the web for material changes on a fixed frequency.
+
+        Each monitor runs once on creation and then on its configured schedule, emitting events when meaningful changes are detected.
+        - `event_stream` monitors track a search query and emit an event for each new material change.
+        - `snapshot` monitors track a specific task run's output and emit an event when the output changes.
+
+        Results can be polled via the events endpoint or delivered via webhooks.
+        """
+        from .resources.monitor import MonitorResourceWithRawResponse
+
+        return MonitorResourceWithRawResponse(self._client.monitor)
+
     @cached_property
     def beta(self) -> beta.BetaResourceWithRawResponse:
         from .resources.beta import BetaResourceWithRawResponse
@@ -830,7 +947,7 @@ class AsyncParallelWithRawResponse:
         - Output metadata: citations, excerpts, reasoning, and confidence per field
 
         Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
-         - Submit hundreds or thousands of Tasks as a single group
+        - Submit hundreds or thousands of Tasks as a single group
         - Observe group progress and receive results as they complete
         - Real-time updates via Server-Sent Events (SSE)
         - Add tasks to an existing group while it is running
@@ -840,6 +957,38 @@ class AsyncParallelWithRawResponse:
 
         return AsyncTaskRunResourceWithRawResponse(self._client.task_run)
 
+    @cached_property
+    def task_group(self) -> task_group.AsyncTaskGroupResourceWithRawResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+
+        Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
+        - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        """
+        from .resources.task_group import AsyncTaskGroupResourceWithRawResponse
+
+        return AsyncTaskGroupResourceWithRawResponse(self._client.task_group)
+
+    @cached_property
+    def monitor(self) -> monitor.AsyncMonitorResourceWithRawResponse:
+        """The Monitor API watches the web for material changes on a fixed frequency.
+
+        Each monitor runs once on creation and then on its configured schedule, emitting events when meaningful changes are detected.
+        - `event_stream` monitors track a search query and emit an event for each new material change.
+        - `snapshot` monitors track a specific task run's output and emit an event when the output changes.
+
+        Results can be polled via the events endpoint or delivered via webhooks.
+        """
+        from .resources.monitor import AsyncMonitorResourceWithRawResponse
+
+        return AsyncMonitorResourceWithRawResponse(self._client.monitor)
+
     @cached_property
     def beta(self) -> beta.AsyncBetaResourceWithRawResponse:
         from .resources.beta import AsyncBetaResourceWithRawResponse
@@ -868,7 +1017,7 @@ class ParallelWithStreamedResponse:
         - Output metadata: citations, excerpts, reasoning, and confidence per field
 
         Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
-         - Submit hundreds or thousands of Tasks as a single group
+        - Submit hundreds or thousands of Tasks as a single group
         - Observe group progress and receive results as they complete
         - Real-time updates via Server-Sent Events (SSE)
         - Add tasks to an existing group while it is running
@@ -878,6 +1027,38 @@ class ParallelWithStreamedResponse:
 
         return TaskRunResourceWithStreamingResponse(self._client.task_run)
 
+    @cached_property
+    def task_group(self) -> task_group.TaskGroupResourceWithStreamingResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+
+        Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
+        - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        """
+        from .resources.task_group import TaskGroupResourceWithStreamingResponse
+
+        return TaskGroupResourceWithStreamingResponse(self._client.task_group)
+
+    @cached_property
+    def monitor(self) -> monitor.MonitorResourceWithStreamingResponse:
+        """The Monitor API watches the web for material changes on a fixed frequency.
+
+        Each monitor runs once on creation and then on its configured schedule, emitting events when meaningful changes are detected.
+        - `event_stream` monitors track a search query and emit an event for each new material change.
+        - `snapshot` monitors track a specific task run's output and emit an event when the output changes.
+
+        Results can be polled via the events endpoint or delivered via webhooks.
+        """
+        from .resources.monitor import MonitorResourceWithStreamingResponse
+
+        return MonitorResourceWithStreamingResponse(self._client.monitor)
+
     @cached_property
     def beta(self) -> beta.BetaResourceWithStreamingResponse:
         from .resources.beta import BetaResourceWithStreamingResponse
@@ -906,7 +1087,7 @@ class AsyncParallelWithStreamedResponse:
         - Output metadata: citations, excerpts, reasoning, and confidence per field
 
         Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
-         - Submit hundreds or thousands of Tasks as a single group
+        - Submit hundreds or thousands of Tasks as a single group
         - Observe group progress and receive results as they complete
         - Real-time updates via Server-Sent Events (SSE)
         - Add tasks to an existing group while it is running
@@ -916,6 +1097,38 @@ class AsyncParallelWithStreamedResponse:
 
         return AsyncTaskRunResourceWithStreamingResponse(self._client.task_run)
 
+    @cached_property
+    def task_group(self) -> task_group.AsyncTaskGroupResourceWithStreamingResponse:
+        """The Task API executes web research and extraction tasks.
+
+        Clients submit a natural-language objective with an optional input schema; the service plans retrieval, fetches relevant URLs, and returns outputs that conform to a provided or inferred JSON schema. Supports deep research style queries and can return rich structured JSON outputs. Processors trade-off between cost, latency, and quality. Each processor supports calibrated confidences.
+        - Output metadata: citations, excerpts, reasoning, and confidence per field
+
+        Task Groups enable batch execution of many independent Task runs with group-level monitoring and failure handling.
+        - Submit hundreds or thousands of Tasks as a single group
+        - Observe group progress and receive results as they complete
+        - Real-time updates via Server-Sent Events (SSE)
+        - Add tasks to an existing group while it is running
+        - Group-level retry and error aggregation
+        """
+        from .resources.task_group import AsyncTaskGroupResourceWithStreamingResponse
+
+        return AsyncTaskGroupResourceWithStreamingResponse(self._client.task_group)
+
+    @cached_property
+    def monitor(self) -> monitor.AsyncMonitorResourceWithStreamingResponse:
+        """The Monitor API watches the web for material changes on a fixed frequency.
+
+        Each monitor runs once on creation and then on its configured schedule, emitting events when meaningful changes are detected.
+        - `event_stream` monitors track a search query and emit an event for each new material change.
+        - `snapshot` monitors track a specific task run's output and emit an event when the output changes.
+
+        Results can be polled via the events endpoint or delivered via webhooks.
+        """
+        from .resources.monitor import AsyncMonitorResourceWithStreamingResponse
+
+        return AsyncMonitorResourceWithStreamingResponse(self._client.monitor)
+
     @cached_property
     def beta(self) -> beta.AsyncBetaResourceWithStreamingResponse:
         from .resources.beta import AsyncBetaResourceWithStreamingResponse

{parallel_web-0.5.1 → parallel_web-0.6.0}/src/parallel/_qs.py

@@ -2,17 +2,13 @@ from __future__ import annotations
 
 from typing import Any, List, Tuple, Union, Mapping, TypeVar
 from urllib.parse import parse_qs, urlencode
-from typing_extensions import Literal, get_args
+from typing_extensions import get_args
 
-from ._types import NotGiven, not_given
+from ._types import NotGiven, ArrayFormat, NestedFormat, not_given
 from ._utils import flatten
 
 _T = TypeVar("_T")
 
-
-ArrayFormat = Literal["comma", "repeat", "indices", "brackets"]
-NestedFormat = Literal["dots", "brackets"]
-
 PrimitiveData = Union[str, int, float, bool, None]
 # this should be Data = Union[PrimitiveData, "List[Data]", "Tuple[Data]", "Mapping[str, Data]"]
 # https://github.com/microsoft/pyright/issues/3555

{parallel_web-0.5.1 → parallel_web-0.6.0}/src/parallel/_types.py

@@ -47,6 +47,9 @@ AnyMapping = Mapping[str, object]
 ModelT = TypeVar("ModelT", bound=pydantic.BaseModel)
 _T = TypeVar("_T")
 
+ArrayFormat = Literal["comma", "repeat", "indices", "brackets"]
+NestedFormat = Literal["dots", "brackets"]
+
 
 # Approximates httpx internal ProxiesTypes and RequestFiles types
 # while adding support for `PathLike` instances