parallel-web 0.1.0__py3-none-any.whl

parallel/lib/_parsing/_task_spec.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import Type, Union
+from typing_extensions import TypeGuard
+
+import pydantic
+
+from ..._types import NOT_GIVEN, NotGiven
+from ..._utils import is_str, is_dict, is_given
+from .._pydantic import to_json_schema, is_basemodel_type
+from ...types.task_spec_param import (
+    OutputT,
+    InputSchema,
+    OutputSchema,
+    TaskSpecParam,
+)
+from ...types.json_schema_param import JsonSchemaParam
+from ...types.text_schema_param import TextSchemaParam
+
+
+def is_json_schema_param(schema: object) -> TypeGuard[JsonSchemaParam]:
+    """Check if a schema is a JsonSchemaParam."""
+    if not is_dict(schema):
+        return False
+
+    if not set(schema.keys()).issubset(set(JsonSchemaParam.__annotations__.keys())):
+        return False
+
+    if not schema.get("type") == "json":
+        return False
+
+    return True
+
+
+def is_text_schema_param(schema: object) -> TypeGuard[TextSchemaParam]:
+    """Check if a schema is a TextSchemaParam."""
+    if not is_dict(schema):
+        return False
+
+    if not set(TextSchemaParam.__annotations__.keys()) == set(schema.keys()):
+        return False
+
+    if not schema.get("type") == "text":
+        return False
+
+    return is_str(schema.get("description"))
+
+
+def _is_schema_param(schema: object) -> TypeGuard[OutputSchema | InputSchema]:
+    """Check if a schema is an OutputSchema or InputSchema."""
+    if is_str(schema):
+        return True
+    return is_json_schema_param(schema) or is_text_schema_param(schema)
+
+
+def is_output_schema_param(output_schema: object) -> TypeGuard[OutputSchema]:
+    """Check if a schema is an OutputSchema."""
+    return _is_schema_param(output_schema)
+
+
+def is_input_schema_param(input_schema: object) -> TypeGuard[InputSchema]:
+    """Check if a schema is an InputSchema."""
+    return _is_schema_param(input_schema)
+
+
+def _to_json_schema_param(output_format: Type[pydantic.BaseModel]) -> JsonSchemaParam:
+    """Convert a pydantic basemodel to a JsonSchemaParam."""
+    return {"json_schema": to_json_schema(output_format), "type": "json"}
+
+
+def _generate_output_schema(output_format: OutputSchema | Type[OutputT]) -> OutputSchema:
+    """Generate an OutputSchema from an OutputSchema or a generic output type."""
+    if is_output_schema_param(output_format):
+        return output_format
+
+    if is_basemodel_type(output_format):
+        json_schema_param = _to_json_schema_param(output_format)
+        return json_schema_param
+
+    raise TypeError(f"Invalid output_type. Type: {type(output_format)}")
+
+
+def build_task_spec_param(
+    output_format: OutputSchema | Type[OutputT] | None | NotGiven,
+    _: Union[str, object],  # placeholder for input
+) -> TaskSpecParam | NotGiven:
+    """Build a TaskSpecParam from an OutputSchema or Type[OutputT] if provided."""
+    if not is_given(output_format) or output_format is None:
+        return NOT_GIVEN
+
+    # output format has type OutputSchema | Type[OutputT] here
+    output_schema = _generate_output_schema(output_format)  # type: ignore[arg-type]
+    return TaskSpecParam(output_schema=output_schema)

parallel/lib/_pydantic.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any
+from typing_extensions import TypeGuard
+
+import pydantic
+
+from .._compat import PYDANTIC_V2, model_json_schema
+
+
+def to_json_schema(
+    model: type[pydantic.BaseModel] | pydantic.TypeAdapter[Any],
+) -> dict[str, Any]:
+    """Convert a Pydantic model/type adapter to a JSON schema."""
+    if inspect.isclass(model) and is_basemodel_type(model):
+        return model_json_schema(model)
+
+    if PYDANTIC_V2 and isinstance(model, pydantic.TypeAdapter):
+        return model.json_schema()
+
+    raise TypeError(f"Non BaseModel types are only supported with Pydantic v2 - {model}")
+
+
+def is_basemodel_type(typ: type | object) -> TypeGuard[type[pydantic.BaseModel]]:
+    """Check if a type is a Pydantic BaseModel."""
+    if not inspect.isclass(typ):
+        return False
+    return issubclass(typ, pydantic.BaseModel)

parallel/lib/_time.py

@@ -0,0 +1,57 @@
+import time
+import contextlib
+from typing import Union, Iterator, NoReturn
+
+import httpx
+
+from .._types import NotGiven
+from .._constants import DEFAULT_TIMEOUT_SECONDS
+from .._exceptions import APIStatusError, APITimeoutError
+from .._utils._utils import is_given
+
+
+def prepare_timeout_float(timeout: Union[float, httpx.Timeout, None, NotGiven]) -> float:
+    """Create a simple float timeout for server responses from the provided timeout.
+
+    For httpx.Timeout, we only use the read timeout.
+    """
+    if isinstance(timeout, httpx.Timeout):
+        timeout = timeout.read
+
+    if not is_given(timeout) or timeout is None:
+        return DEFAULT_TIMEOUT_SECONDS
+
+    return timeout
+
+
+def _raise_timeout(run_id: str, exc: Union[Exception, None]) -> NoReturn:
+    raise TimeoutError(f"Fetching task run result for run id {run_id} timed out.") from exc
+
+
+@contextlib.contextmanager
+def timeout_retry_context(run_id: str, deadline: float) -> Iterator[None]:
+    """Context manager for handling timeouts and retries when fetching task run results.
+
+    Args:
+        run_id: The ID of the task run
+        deadline: The absolute time (monotonic) by which the operation must complete
+
+    Raises:
+        TimeoutError: If the deadline is reached
+        APIStatusError: For non-timeout API errors
+    """
+    exc: Union[Exception, None] = None
+    while time.monotonic() < deadline:
+        try:
+            yield
+            return
+        except APITimeoutError as e:
+            exc = e
+            continue
+        except APIStatusError as e:
+            # retry on timeouts from the API
+            if e.status_code == 408:
+                exc = e
+                continue
+            raise
+    _raise_timeout(run_id, exc)

parallel/resources/__init__.py

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .task_run import (
+    TaskRunResource,
+    AsyncTaskRunResource,
+    TaskRunResourceWithRawResponse,
+    AsyncTaskRunResourceWithRawResponse,
+    TaskRunResourceWithStreamingResponse,
+    AsyncTaskRunResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "TaskRunResource",
+    "AsyncTaskRunResource",
+    "TaskRunResourceWithRawResponse",
+    "AsyncTaskRunResourceWithRawResponse",
+    "TaskRunResourceWithStreamingResponse",
+    "AsyncTaskRunResourceWithStreamingResponse",
+]