parallel-web 0.1.0__py3-none-any.whl

parallel/types/parsed_task_run_result.py

@@ -0,0 +1,29 @@
+from typing import Union, Generic, TypeVar, Optional
+
+from pydantic import BaseModel
+
+from .._models import GenericModel
+from .task_run_result import TaskRunResult, OutputTaskRunJsonOutput, OutputTaskRunTextOutput
+
+ContentType = TypeVar("ContentType", bound=BaseModel)
+
+
+# we need to disable this check because we're overriding properties
+# with subclasses of their types which is technically unsound as
+# properties can be mutated.
+# pyright: reportIncompatibleVariableOverride=false
+
+
+class ParsedOutputTaskRunTextOutput(OutputTaskRunTextOutput, GenericModel, Generic[ContentType]):
+    parsed: None
+    """The parsed output from the task run."""
+
+
+class ParsedOutputTaskRunJsonOutput(OutputTaskRunJsonOutput, 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]
+    """The parsed output from the task run."""

parallel/types/task_run.py

@@ -0,0 +1,54 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["TaskRun", "Warning"]
+
+
+class Warning(BaseModel):
+    message: str
+    """Human-readable message."""
+
+    type: str
+    """Type of warning.
+
+    Note that adding new warning types is considered a backward-compatible change.
+    """
+
+    detail: Optional[object] = None
+    """Optional detail supporting the warning."""
+
+
+class TaskRun(BaseModel):
+    created_at: Optional[str] = None
+    """Timestamp of the creation of the task, as an RFC 3339 string."""
+
+    is_active: bool
+    """Whether the run is currently active; i.e.
+
+    status is one of {'queued', 'running', 'cancelling'}.
+    """
+
+    message: Optional[str] = None
+    """Human-readable status message for the run."""
+
+    modified_at: Optional[str] = None
+    """Timestamp of the last modification to the task, as an RFC 3339 string."""
+
+    processor: str
+    """Processor used for the run."""
+
+    run_id: str
+    """ID of the task run."""
+
+    status: Literal["queued", "action_required", "running", "completed", "failed", "cancelling", "cancelled"]
+    """Status of the run."""
+
+    metadata: Optional[Dict[str, Union[str, float, bool]]] = None
+    """User-provided metadata stored with the run."""
+
+    warnings: Optional[List[Warning]] = None
+    """Warnings for the run."""

parallel/types/task_run_create_params.py

@@ -0,0 +1,32 @@
+# 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 Required, TypedDict
+
+from .task_spec_param import TaskSpecParam
+
+__all__ = ["TaskRunCreateParams"]
+
+
+class TaskRunCreateParams(TypedDict, total=False):
+    input: Required[Union[str, object]]
+    """Input to the task, either text or a JSON object."""
+
+    processor: Required[str]
+    """Processor to use for the task."""
+
+    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.
+    """
+
+    task_spec: Optional[TaskSpecParam]
+    """Specification for a task.
+
+    For convenience we allow bare strings as input or output schemas, which is
+    equivalent to a text schema with the same description.
+    """

parallel/types/task_run_result.py

@@ -0,0 +1,122 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from typing_extensions import Literal, TypeAlias
+
+from .._models import BaseModel
+from .task_run import TaskRun
+
+__all__ = [
+    "TaskRunResult",
+    "Output",
+    "OutputTaskRunTextOutput",
+    "OutputTaskRunTextOutputBasis",
+    "OutputTaskRunTextOutputBasisCitation",
+    "OutputTaskRunJsonOutput",
+    "OutputTaskRunJsonOutputBasis",
+    "OutputTaskRunJsonOutputBasisCitation",
+]
+
+
+class OutputTaskRunTextOutputBasisCitation(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."""
+
+
+class OutputTaskRunTextOutputBasis(BaseModel):
+    field: str
+    """Name of the output field."""
+
+    reasoning: str
+    """Reasoning for the output field."""
+
+    citations: Optional[List[OutputTaskRunTextOutputBasisCitation]] = None
+    """List of citations supporting the output field."""
+
+    confidence: Optional[str] = None
+    """Confidence level for the output field.
+
+    Only certain processors provide confidence levels.
+    """
+
+
+class OutputTaskRunTextOutput(BaseModel):
+    basis: List[OutputTaskRunTextOutputBasis]
+    """Basis for the output. The basis has a single field 'output'."""
+
+    content: str
+    """Text output from the task."""
+
+    type: Literal["text"]
+    """
+    The type of output being returned, as determined by the output schema of the
+    task spec.
+    """
+
+
+class OutputTaskRunJsonOutputBasisCitation(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."""
+
+
+class OutputTaskRunJsonOutputBasis(BaseModel):
+    field: str
+    """Name of the output field."""
+
+    reasoning: str
+    """Reasoning for the output field."""
+
+    citations: Optional[List[OutputTaskRunJsonOutputBasisCitation]] = None
+    """List of citations supporting the output field."""
+
+    confidence: Optional[str] = None
+    """Confidence level for the output field.
+
+    Only certain processors provide confidence levels.
+    """
+
+
+class OutputTaskRunJsonOutput(BaseModel):
+    basis: List[OutputTaskRunJsonOutputBasis]
+    """Basis for each top-level field in the JSON output."""
+
+    content: object
+    """
+    Output from the task as a native JSON object, as determined by the output schema
+    of the task spec.
+    """
+
+    type: Literal["json"]
+    """
+    The type of output being returned, as determined by the output schema of the
+    task spec.
+    """
+
+
+Output: TypeAlias = Union[OutputTaskRunTextOutput, OutputTaskRunJsonOutput]
+
+
+class TaskRunResult(BaseModel):
+    output: Output
+    """Output from the task conforming to the output schema."""
+
+    run: TaskRun
+    """Status of a task."""

parallel/types/task_run_result_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_extensions import Annotated, TypedDict
+
+from .._utils import PropertyInfo
+
+__all__ = ["TaskRunResultParams"]
+
+
+class TaskRunResultParams(TypedDict, total=False):
+    api_timeout: Annotated[int, PropertyInfo(alias="timeout")]

parallel/types/task_spec_param.py

@@ -0,0 +1,35 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Optional
+from typing_extensions import TypeVar, Required, TypeAlias, TypedDict, NotRequired
+
+from pydantic import BaseModel
+
+from .json_schema_param import JsonSchemaParam
+from .text_schema_param import TextSchemaParam
+
+__all__ = ["TaskSpecParam", "OutputSchema", "InputSchema"]
+
+OutputSchema: TypeAlias = Union[JsonSchemaParam, TextSchemaParam, str]
+
+InputSchema: TypeAlias = Union[JsonSchemaParam, TextSchemaParam, str]
+
+OutputT = TypeVar("OutputT", bound=BaseModel)
+
+
+class TaskSpecParam(TypedDict, total=False):
+    output_schema: Required[OutputSchema]
+    """JSON schema or text fully describing the desired output from the task.
+
+    Descriptions of output fields will determine the form and content of the
+    response. A bare string is equivalent to a text schema with the same
+    description.
+    """
+
+    input_schema: NotRequired[Optional[InputSchema]]
+    """Optional JSON schema or text description of expected input to the task.
+
+    A bare string is equivalent to a text schema with the same description.
+    """

parallel/types/text_schema_param.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["TextSchemaParam"]
+
+
+class TextSchemaParam(TypedDict, total=False):
+    description: Required[str]
+    """A text description of the desired output from the task."""
+
+    type: Literal["text"]
+    """The type of schema being defined. Always `text`."""