parallel-web 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

parallel/types/beta/task_group.py

@@ -0,0 +1,24 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Union, Optional
+
+from pydantic import Field as FieldInfo
+
+from ..._models import BaseModel
+from .task_group_status import TaskGroupStatus
+
+__all__ = ["TaskGroup"]
+
+
+class TaskGroup(BaseModel):
+    created_at: Optional[str] = None
+    """Timestamp of the creation of the group, as an RFC 3339 string."""
+
+    status: TaskGroupStatus
+    """Status of a task group."""
+
+    task_group_id: str = FieldInfo(alias="taskgroup_id")
+    """ID of the group."""
+
+    metadata: Optional[Dict[str, Union[str, float, bool]]] = None
+    """User-provided metadata stored with the group."""

parallel/types/beta/task_group_add_runs_params.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List, Iterable, Optional
+from typing_extensions import Required, Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+from ..task_spec_param import TaskSpecParam
+from .parallel_beta_param import ParallelBetaParam
+from .beta_run_input_param import BetaRunInputParam
+
+__all__ = ["TaskGroupAddRunsParams"]
+
+
+class TaskGroupAddRunsParams(TypedDict, total=False):
+    inputs: Required[Iterable[BetaRunInputParam]]
+    """List of task runs to execute."""
+
+    default_task_spec: Optional[TaskSpecParam]
+    """Specification for a task.
+
+    Auto output schemas can be specified by setting `output_schema={"type":"auto"}`.
+    Not specifying a TaskSpec is the same as setting an auto output schema.
+
+    For convenience bare strings are also accepted as input or output schemas.
+    """
+
+    betas: Annotated[List[ParallelBetaParam], PropertyInfo(alias="parallel-beta")]
+    """Optional header to specify the beta version(s) to enable."""

parallel/types/beta/task_group_create_params.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, Union, Optional
+from typing_extensions import TypedDict
+
+__all__ = ["TaskGroupCreateParams"]
+
+
+class TaskGroupCreateParams(TypedDict, total=False):
+    metadata: Optional[Dict[str, Union[str, float, bool]]]
+    """User-provided metadata stored with the task group."""

parallel/types/beta/task_group_events_params.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+
+__all__ = ["TaskGroupEventsParams"]
+
+
+class TaskGroupEventsParams(TypedDict, total=False):
+    last_event_id: Optional[str]
+
+    api_timeout: Annotated[Optional[float], PropertyInfo(alias="timeout")]

parallel/types/beta/task_group_events_response.py

@@ -0,0 +1,28 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .error_event import ErrorEvent
+from .task_run_event import TaskRunEvent
+from .task_group_status import TaskGroupStatus
+
+__all__ = ["TaskGroupEventsResponse", "TaskGroupStatusEvent"]
+
+
+class TaskGroupStatusEvent(BaseModel):
+    event_id: str
+    """Cursor to resume the event stream."""
+
+    status: TaskGroupStatus
+    """Status of a task group."""
+
+    type: Literal["task_group_status"]
+    """Event type; always 'task_group_status'."""
+
+
+TaskGroupEventsResponse: TypeAlias = Annotated[
+    Union[TaskGroupStatusEvent, TaskRunEvent, ErrorEvent], PropertyInfo(discriminator="type")
+]

parallel/types/beta/task_group_get_runs_params.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Optional
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["TaskGroupGetRunsParams"]
+
+
+class TaskGroupGetRunsParams(TypedDict, total=False):
+    include_input: bool
+
+    include_output: bool
+
+    last_event_id: Optional[str]
+
+    status: Optional[Literal["queued", "action_required", "running", "completed", "failed", "cancelling", "cancelled"]]

parallel/types/beta/task_group_get_runs_response.py

@@ -0,0 +1,12 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from .error_event import ErrorEvent
+from .task_run_event import TaskRunEvent
+
+__all__ = ["TaskGroupGetRunsResponse"]
+
+TaskGroupGetRunsResponse: TypeAlias = Annotated[Union[TaskRunEvent, ErrorEvent], PropertyInfo(discriminator="type")]

parallel/types/beta/task_group_run_response.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+from .task_group_status import TaskGroupStatus
+
+__all__ = ["TaskGroupRunResponse"]
+
+
+class TaskGroupRunResponse(BaseModel):
+    event_cursor: Optional[str] = None
+    """
+    Cursor for these runs in the event stream at
+    taskgroup/events?last_event_id=<event_cursor>. Empty for the first runs in the
+    group.
+    """
+
+    run_cursor: Optional[str] = None
+    """
+    Cursor for these runs in the run stream at
+    taskgroup/runs?last_event_id=<run_cursor>. Empty for the first runs in the
+    group.
+    """
+
+    run_ids: List[str]
+    """IDs of the newly created runs."""
+
+    status: TaskGroupStatus
+    """Status of a task group."""

parallel/types/beta/task_group_status.py

@@ -0,0 +1,27 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["TaskGroupStatus"]
+
+
+class TaskGroupStatus(BaseModel):
+    is_active: bool
+    """True if at least one run in the group is currently active, i.e.
+
+    status is one of {'cancelling', 'queued', 'running'}.
+    """
+
+    modified_at: Optional[str] = None
+    """Timestamp of the last status update to the group, as an RFC 3339 string."""
+
+    num_task_runs: int
+    """Number of task runs in the group."""
+
+    status_message: Optional[str] = None
+    """Human-readable status message for the group."""
+
+    task_run_status_counts: Dict[str, int]
+    """Number of task runs with each status."""

parallel/types/beta/task_run_create_params.py

@@ -0,0 +1,70 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Union, Iterable, Optional
+from typing_extensions import Required, Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+from .webhook_param import WebhookParam
+from ..task_spec_param import TaskSpecParam
+from .mcp_server_param import McpServerParam
+from .parallel_beta_param import ParallelBetaParam
+from ..shared_params.source_policy import SourcePolicy
+
+__all__ = ["TaskRunCreateParams"]
+
+
+class TaskRunCreateParams(TypedDict, total=False):
+    input: Required[Union[str, Dict[str, object]]]
+    """Input to the task, either text or a JSON object."""
+
+    processor: Required[str]
+    """Processor to use for the task."""
+
+    enable_events: Optional[bool]
+    """Controls tracking of task run execution progress.
+
+    When set to true, progress events are recorded and can be accessed via the
+    [Task Run events](https://platform.parallel.ai/api-reference) endpoint. When
+    false, no progress events are tracked. Note that progress tracking cannot be
+    enabled after a run has been created. The flag is set to true by default for
+    premium processors (pro and above). This feature is not available via the Python
+    SDK. To enable this feature in your API requests, specify the `parallel-beta`
+    header with `events-sse-2025-07-24` value.
+    """
+
+    mcp_servers: Optional[Iterable[McpServerParam]]
+    """
+    Optional list of MCP servers to use for the run. This feature is not available
+    via the Python SDK. To enable this feature in your API requests, specify the
+    `parallel-beta` header with `mcp-server-2025-07-17` value.
+    """
+
+    metadata: Optional[Dict[str, Union[str, float, bool]]]
+    """User-provided metadata stored with the run.
+
+    Keys and values must be strings with a maximum length of 16 and 512 characters
+    respectively.
+    """
+
+    source_policy: Optional[SourcePolicy]
+    """Source policy for web search results.
+
+    This policy governs which sources are allowed/disallowed in results.
+    """
+
+    task_spec: Optional[TaskSpecParam]
+    """Specification for a task.
+
+    Auto output schemas can be specified by setting `output_schema={"type":"auto"}`.
+    Not specifying a TaskSpec is the same as setting an auto output schema.
+
+    For convenience bare strings are also accepted as input or output schemas.
+    """
+
+    webhook: Optional[WebhookParam]
+    """Webhooks for Task Runs."""
+
+    betas: Annotated[List[ParallelBetaParam], PropertyInfo(alias="parallel-beta")]
+    """Optional header to specify the beta version(s) to enable."""

parallel/types/beta/task_run_event.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from ..task_run import TaskRun
+from .beta_run_input import BetaRunInput
+from ..task_run_json_output import TaskRunJsonOutput
+from ..task_run_text_output import TaskRunTextOutput
+
+__all__ = ["TaskRunEvent", "Output"]
+
+Output: TypeAlias = Annotated[Union[TaskRunTextOutput, TaskRunJsonOutput, None], PropertyInfo(discriminator="type")]
+
+
+class TaskRunEvent(BaseModel):
+    event_id: Optional[str] = None
+    """Cursor to resume the event stream. Always empty for non Task Group runs."""
+
+    run: TaskRun
+    """Status of a task run."""
+
+    type: Literal["task_run.state"]
+    """Event type; always 'task_run.state'."""
+
+    input: Optional[BetaRunInput] = None
+    """Task run input with additional beta fields."""
+
+    output: Optional[Output] = None
+    """Output from the run; included only if requested and if status == `completed`."""

parallel/types/beta/task_run_events_response.py

@@ -0,0 +1,58 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, Annotated, TypeAlias
+
+from ..._utils import PropertyInfo
+from ..._models import BaseModel
+from .error_event import ErrorEvent
+from .task_run_event import TaskRunEvent
+
+__all__ = [
+    "TaskRunEventsResponse",
+    "TaskRunProgressStatsEvent",
+    "TaskRunProgressStatsEventSourceStats",
+    "TaskRunProgressMessageEvent",
+]
+
+
+class TaskRunProgressStatsEventSourceStats(BaseModel):
+    num_sources_considered: Optional[int] = None
+    """Number of sources considered in processing the task."""
+
+    num_sources_read: Optional[int] = None
+    """Number of sources read in processing the task."""
+
+    sources_read_sample: Optional[List[str]] = None
+    """A sample of URLs of sources read in processing the task."""
+
+
+class TaskRunProgressStatsEvent(BaseModel):
+    source_stats: TaskRunProgressStatsEventSourceStats
+    """Source stats for a task run."""
+
+    type: Literal["task_run.progress_stats"]
+    """Event type; always 'task_run.progress_stats'."""
+
+
+class TaskRunProgressMessageEvent(BaseModel):
+    message: str
+    """Progress update message."""
+
+    timestamp: Optional[str] = None
+    """Timestamp of the message."""
+
+    type: Literal[
+        "task_run.progress_msg.plan",
+        "task_run.progress_msg.search",
+        "task_run.progress_msg.result",
+        "task_run.progress_msg.tool_call",
+        "task_run.progress_msg.exec_status",
+    ]
+    """Event type; always starts with 'task_run.progress_msg'."""
+
+
+TaskRunEventsResponse: TypeAlias = Annotated[
+    Union[TaskRunProgressStatsEvent, TaskRunProgressMessageEvent, TaskRunEvent, ErrorEvent],
+    PropertyInfo(discriminator="type"),
+]

parallel/types/beta/task_run_result_params.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Annotated, TypedDict
+
+from ..._utils import PropertyInfo
+from .parallel_beta_param import ParallelBetaParam
+
+__all__ = ["TaskRunResultParams"]
+
+
+class TaskRunResultParams(TypedDict, total=False):
+    api_timeout: Annotated[int, PropertyInfo(alias="timeout")]
+
+    betas: Annotated[List[ParallelBetaParam], PropertyInfo(alias="parallel-beta")]
+    """Optional header to specify the beta version(s) to enable."""

parallel/types/beta/web_search_result.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List
+
+from ..._models import BaseModel
+
+__all__ = ["WebSearchResult"]
+
+
+class WebSearchResult(BaseModel):
+    excerpts: List[str]
+    """Text excerpts from the search result which are relevant to the request."""
+
+    title: str
+    """Title of the search result."""
+
+    url: str
+    """URL associated with the search result."""

parallel/types/beta/webhook.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["Webhook"]
+
+
+class Webhook(BaseModel):
+    url: str
+    """URL for the webhook."""
+
+    event_types: Optional[List[Literal["task_run.status"]]] = None
+    """Event types to send the webhook notifications for."""

parallel/types/beta/webhook_param.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import List
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["WebhookParam"]
+
+
+class WebhookParam(TypedDict, total=False):
+    url: Required[str]
+    """URL for the webhook."""
+
+    event_types: List[Literal["task_run.status"]]
+    """Event types to send the webhook notifications for."""

parallel/types/citation.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .._models import BaseModel
+
+__all__ = ["Citation"]
+
+
+class Citation(BaseModel):
+    url: str
+    """URL of the citation."""
+
+    excerpts: Optional[List[str]] = None
+    """Excerpts from the citation supporting the output.
+
+    Only certain processors provide excerpts.
+    """
+
+    title: Optional[str] = None
+    """Title of the citation."""

parallel/types/field_basis.py

@@ -0,0 +1,25 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .._models import BaseModel
+from .citation import Citation
+
+__all__ = ["FieldBasis"]
+
+
+class FieldBasis(BaseModel):
+    field: str
+    """Name of the output field."""
+
+    reasoning: str
+    """Reasoning for the output field."""
+
+    citations: Optional[List[Citation]] = None
+    """List of citations supporting the output field."""
+
+    confidence: Optional[str] = None
+    """Confidence level for the output field.
+
+    Only certain processors provide confidence levels.
+    """

parallel/types/json_schema.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["JsonSchema"]
+
+
+class JsonSchema(BaseModel):
+    json_schema: Dict[str, object]
+    """A JSON Schema object. Only a subset of JSON Schema is supported."""
+
+    type: Optional[Literal["json"]] = None
+    """The type of schema being defined. Always `json`."""

parallel/types/json_schema_param.py

@@ -2,13 +2,14 @@
 
 from __future__ import annotations
 
+from typing import Dict
 from typing_extensions import Literal, Required, TypedDict
 
 __all__ = ["JsonSchemaParam"]
 
 
 class JsonSchemaParam(TypedDict, total=False):
-    json_schema: Required[object]
+    json_schema: Required[Dict[str, object]]
     """A JSON Schema object. Only a subset of JSON Schema is supported."""
 
     type: Literal["json"]

parallel/types/parsed_task_run_result.py

@@ -3,7 +3,9 @@ from typing import Union, Generic, TypeVar, Optional
 from pydantic import BaseModel
 
 from .._models import GenericModel
-from .task_run_result import TaskRunResult, OutputTaskRunJsonOutput, OutputTaskRunTextOutput
+from .task_run_result import TaskRunResult
+from .task_run_json_output import TaskRunJsonOutput
+from .task_run_text_output import TaskRunTextOutput
 
 ContentType = TypeVar("ContentType", bound=BaseModel)
 
@@ -14,16 +16,23 @@ ContentType = TypeVar("ContentType", bound=BaseModel)
 # pyright: reportIncompatibleVariableOverride=false
 
 
-class ParsedOutputTaskRunTextOutput(OutputTaskRunTextOutput, GenericModel, Generic[ContentType]):
+class ParsedTaskRunTextOutput(TaskRunTextOutput, GenericModel, Generic[ContentType]):
     parsed: None
     """The parsed output from the task run."""
 
 
-class ParsedOutputTaskRunJsonOutput(OutputTaskRunJsonOutput, GenericModel, Generic[ContentType]):
+class ParsedTaskRunJsonOutput(TaskRunJsonOutput, GenericModel, Generic[ContentType]):
     parsed: Optional[ContentType] = None
     """The parsed output from the task run."""
 
 
 class ParsedTaskRunResult(TaskRunResult, GenericModel, Generic[ContentType]):
-    output: Union[ParsedOutputTaskRunTextOutput[ContentType], ParsedOutputTaskRunJsonOutput[ContentType]]  # type: ignore[assignment]
+    output: Union[ParsedTaskRunTextOutput[ContentType], ParsedTaskRunJsonOutput[ContentType]]  # type: ignore[assignment]
     """The parsed output from the task run."""
+
+
+ParsedOutputTaskRunTextOutput = ParsedTaskRunTextOutput  # for backwards compatibility with v0.1.3
+"""This is deprecated, `ParsedTaskRunTextOutput` should be used instead"""
+
+ParsedOutputTaskRunJsonOutput = ParsedTaskRunJsonOutput  # for backwards compatibility with v0.1.3
+"""This is deprecated, `ParsedTaskRunJsonOutput` should be used instead"""

parallel/types/shared/__init__.py

@@ -0,0 +1,6 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .warning import Warning as Warning
+from .error_object import ErrorObject as ErrorObject
+from .source_policy import SourcePolicy as SourcePolicy
+from .error_response import ErrorResponse as ErrorResponse

parallel/types/shared/error_object.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["ErrorObject"]
+
+
+class ErrorObject(BaseModel):
+    message: str
+    """Human-readable message."""
+
+    ref_id: str
+    """Reference ID for the error."""
+
+    detail: Optional[Dict[str, object]] = None
+    """Optional detail supporting the error."""

parallel/types/shared/error_response.py

@@ -0,0 +1,16 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+from .error_object import ErrorObject
+
+__all__ = ["ErrorResponse"]
+
+
+class ErrorResponse(BaseModel):
+    error: ErrorObject
+    """An error message."""
+
+    type: Literal["error"]
+    """Always 'error'."""

parallel/types/shared/source_policy.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from ..._models import BaseModel
+
+__all__ = ["SourcePolicy"]
+
+
+class SourcePolicy(BaseModel):
+    exclude_domains: Optional[List[str]] = None
+    """List of domains to exclude from results.
+
+    If specified, sources from these domains will be excluded.
+    """
+
+    include_domains: Optional[List[str]] = None
+    """List of domains to restrict the results to.
+
+    If specified, only sources from these domains will be included.
+    """

parallel/types/shared/warning.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, Optional
+from typing_extensions import Literal
+
+from ..._models import BaseModel
+
+__all__ = ["Warning"]
+
+
+class Warning(BaseModel):
+    message: str
+    """Human-readable message."""
+
+    type: Literal["spec_validation_warning", "input_validation_warning", "warning"]
+    """Type of warning.
+
+    Note that adding new warning types is considered a backward-compatible change.
+    """
+
+    detail: Optional[Dict[str, object]] = None
+    """Optional detail supporting the warning."""

parallel/types/shared_params/__init__.py

@@ -0,0 +1,3 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .source_policy import SourcePolicy as SourcePolicy