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

parallel/__init__.py

@@ -36,7 +36,7 @@ from ._exceptions import (
     UnprocessableEntityError,
     APIResponseValidationError,
 )
-from ._base_client import DefaultHttpxClient, DefaultAsyncHttpxClient
+from ._base_client import DefaultHttpxClient, DefaultAioHttpClient, DefaultAsyncHttpxClient
 from ._utils._logs import setup_logging as _setup_logging
 
 __all__ = [
@@ -78,6 +78,7 @@ __all__ = [
     "DEFAULT_CONNECTION_LIMITS",
     "DefaultHttpxClient",
     "DefaultAsyncHttpxClient",
+    "DefaultAioHttpClient",
 ]
 
 if not _t.TYPE_CHECKING:

parallel/_base_client.py

@@ -529,6 +529,18 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
             # work around https://github.com/encode/httpx/discussions/2880
             kwargs["extensions"] = {"sni_hostname": prepared_url.host.replace("_", "-")}
 
+        is_body_allowed = options.method.lower() != "get"
+
+        if is_body_allowed:
+            if isinstance(json_data, bytes):
+                kwargs["content"] = json_data
+            else:
+                kwargs["json"] = json_data if is_given(json_data) else None
+            kwargs["files"] = files
+        else:
+            headers.pop("Content-Type", None)
+            kwargs.pop("data", None)
+
         # TODO: report this error to httpx
         return self._client.build_request(  # pyright: ignore[reportUnknownMemberType]
             headers=headers,
@@ -540,8 +552,6 @@ class BaseClient(Generic[_HttpxClientT, _DefaultStreamT]):
             # so that passing a `TypedDict` doesn't cause an error.
             # https://github.com/microsoft/pyright/issues/3526#event-6715453066
             params=self.qs.stringify(cast(Mapping[str, Any], params)) if params else None,
-            json=json_data if is_given(json_data) else None,
-            files=files,
             **kwargs,
         )
 
@@ -1289,6 +1299,24 @@ class _DefaultAsyncHttpxClient(httpx.AsyncClient):
         super().__init__(**kwargs)
 
 
+try:
+    import httpx_aiohttp
+except ImportError:
+
+    class _DefaultAioHttpClient(httpx.AsyncClient):
+        def __init__(self, **_kwargs: Any) -> None:
+            raise RuntimeError("To use the aiohttp client you must have installed the package with the `aiohttp` extra")
+else:
+
+    class _DefaultAioHttpClient(httpx_aiohttp.HttpxAiohttpClient):  # type: ignore
+        def __init__(self, **kwargs: Any) -> None:
+            kwargs.setdefault("timeout", DEFAULT_TIMEOUT)
+            kwargs.setdefault("limits", DEFAULT_CONNECTION_LIMITS)
+            kwargs.setdefault("follow_redirects", True)
+
+            super().__init__(**kwargs)
+
+
 if TYPE_CHECKING:
     DefaultAsyncHttpxClient = httpx.AsyncClient
     """An alias to `httpx.AsyncClient` that provides the same defaults that this SDK
@@ -1297,8 +1325,12 @@ if TYPE_CHECKING:
     This is useful because overriding the `http_client` with your own instance of
     `httpx.AsyncClient` will result in httpx's defaults being used, not ours.
     """
+
+    DefaultAioHttpClient = httpx.AsyncClient
+    """An alias to `httpx.AsyncClient` that changes the default HTTP transport to `aiohttp`."""
 else:
     DefaultAsyncHttpxClient = _DefaultAsyncHttpxClient
+    DefaultAioHttpClient = _DefaultAioHttpClient
 
 
 class AsyncHttpxClientWrapper(DefaultAsyncHttpxClient):

parallel/_client.py

@@ -29,6 +29,7 @@ from ._base_client import (
     SyncAPIClient,
     AsyncAPIClient,
 )
+from .resources.beta import beta
 
 __all__ = [
     "Timeout",
@@ -44,6 +45,7 @@ __all__ = [
 
 class Parallel(SyncAPIClient):
     task_run: task_run.TaskRunResource
+    beta: beta.BetaResource
     with_raw_response: ParallelWithRawResponse
     with_streaming_response: ParallelWithStreamedResponse
 
@@ -102,6 +104,7 @@ class Parallel(SyncAPIClient):
         )
 
         self.task_run = task_run.TaskRunResource(self)
+        self.beta = beta.BetaResource(self)
         self.with_raw_response = ParallelWithRawResponse(self)
         self.with_streaming_response = ParallelWithStreamedResponse(self)
 
@@ -212,6 +215,7 @@ class Parallel(SyncAPIClient):
 
 class AsyncParallel(AsyncAPIClient):
     task_run: task_run.AsyncTaskRunResource
+    beta: beta.AsyncBetaResource
     with_raw_response: AsyncParallelWithRawResponse
     with_streaming_response: AsyncParallelWithStreamedResponse
 
@@ -270,6 +274,7 @@ class AsyncParallel(AsyncAPIClient):
         )
 
         self.task_run = task_run.AsyncTaskRunResource(self)
+        self.beta = beta.AsyncBetaResource(self)
         self.with_raw_response = AsyncParallelWithRawResponse(self)
         self.with_streaming_response = AsyncParallelWithStreamedResponse(self)
 
@@ -381,21 +386,25 @@ class AsyncParallel(AsyncAPIClient):
 class ParallelWithRawResponse:
     def __init__(self, client: Parallel) -> None:
         self.task_run = task_run.TaskRunResourceWithRawResponse(client.task_run)
+        self.beta = beta.BetaResourceWithRawResponse(client.beta)
 
 
 class AsyncParallelWithRawResponse:
     def __init__(self, client: AsyncParallel) -> None:
         self.task_run = task_run.AsyncTaskRunResourceWithRawResponse(client.task_run)
+        self.beta = beta.AsyncBetaResourceWithRawResponse(client.beta)
 
 
 class ParallelWithStreamedResponse:
     def __init__(self, client: Parallel) -> None:
         self.task_run = task_run.TaskRunResourceWithStreamingResponse(client.task_run)
+        self.beta = beta.BetaResourceWithStreamingResponse(client.beta)
 
 
 class AsyncParallelWithStreamedResponse:
     def __init__(self, client: AsyncParallel) -> None:
         self.task_run = task_run.AsyncTaskRunResourceWithStreamingResponse(client.task_run)
+        self.beta = beta.AsyncBetaResourceWithStreamingResponse(client.beta)
 
 
 Client = Parallel

parallel/_compat.py

@@ -175,6 +175,7 @@ def model_json_schema(model: type[_ModelT]) -> dict[str, Any]:
         return model.model_json_schema()
     return model.schema()  # pyright: ignore[reportDeprecated]
 
+
 # generic models
 if TYPE_CHECKING:
 

parallel/_constants.py

@@ -5,6 +5,8 @@ import httpx
 RAW_RESPONSE_HEADER = "X-Stainless-Raw-Response"
 OVERRIDE_CAST_TO_HEADER = "____stainless_override_cast_to"
 
+# default timeout for execution requests which wait for results is 1 hour.
+DEFAULT_EXECUTE_TIMEOUT_SECONDS = 3600
 # default timeout for http requests is 10 minutes.
 DEFAULT_TIMEOUT_SECONDS = 600
 DEFAULT_TIMEOUT = httpx.Timeout(timeout=DEFAULT_TIMEOUT_SECONDS, connect=5.0)

parallel/_files.py

@@ -69,12 +69,12 @@ def _transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], _read_file_content(file[1]), *file[2:])
+        return (file[0], read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-def _read_file_content(file: FileContent) -> HttpxFileContent:
+def read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return pathlib.Path(file).read_bytes()
     return file
@@ -111,12 +111,12 @@ async def _async_transform_file(file: FileTypes) -> HttpxFileTypes:
         return file
 
     if is_tuple_t(file):
-        return (file[0], await _async_read_file_content(file[1]), *file[2:])
+        return (file[0], await async_read_file_content(file[1]), *file[2:])
 
     raise TypeError(f"Expected file types input to be a FileContent type or to be a tuple")
 
 
-async def _async_read_file_content(file: FileContent) -> HttpxFileContent:
+async def async_read_file_content(file: FileContent) -> HttpxFileContent:
     if isinstance(file, os.PathLike):
         return await anyio.Path(file).read_bytes()
 

parallel/_models.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import os
 import inspect
-from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, cast
+from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast
 from datetime import date, datetime
 from typing_extensions import (
+    List,
     Unpack,
     Literal,
     ClassVar,
@@ -207,14 +208,18 @@ class BaseModel(pydantic.BaseModel):
             else:
                 fields_values[name] = field_get_default(field)
 
+        extra_field_type = _get_extra_fields_type(__cls)
+
         _extra = {}
         for key, value in values.items():
             if key not in model_fields:
+                parsed = construct_type(value=value, type_=extra_field_type) if extra_field_type is not None else value
+
                 if PYDANTIC_V2:
-                    _extra[key] = value
+                    _extra[key] = parsed
                 else:
                     _fields_set.add(key)
-                    fields_values[key] = value
+                    fields_values[key] = parsed
 
         object.__setattr__(m, "__dict__", fields_values)
 
@@ -299,7 +304,7 @@ class BaseModel(pydantic.BaseModel):
                 exclude_none=exclude_none,
             )
 
-            return cast(dict[str, Any], json_safe(dumped)) if mode == "json" else dumped
+            return cast("dict[str, Any]", json_safe(dumped)) if mode == "json" else dumped
 
         @override
         def model_dump_json(
@@ -366,7 +371,24 @@ def _construct_field(value: object, field: FieldInfo, key: str) -> object:
     if type_ is None:
         raise RuntimeError(f"Unexpected field type is None for {key}")
 
-    return construct_type(value=value, type_=type_)
+    return construct_type(value=value, type_=type_, metadata=getattr(field, "metadata", None))
+
+
+def _get_extra_fields_type(cls: type[pydantic.BaseModel]) -> type | None:
+    if not PYDANTIC_V2:
+        # TODO
+        return None
+
+    schema = cls.__pydantic_core_schema__
+    if schema["type"] == "model":
+        fields = schema["schema"]
+        if fields["type"] == "model-fields":
+            extras = fields.get("extras_schema")
+            if extras and "cls" in extras:
+                # mypy can't narrow the type
+                return extras["cls"]  # type: ignore[no-any-return]
+
+    return None
 
 
 def is_basemodel(type_: type) -> bool:
@@ -420,7 +442,7 @@ def construct_type_unchecked(*, value: object, type_: type[_T]) -> _T:
     return cast(_T, construct_type(value=value, type_=type_))
 
 
-def construct_type(*, value: object, type_: object) -> object:
+def construct_type(*, value: object, type_: object, metadata: Optional[List[Any]] = None) -> object:
     """Loose coercion to the expected type with construction of nested values.
 
     If the given value does not match the expected type then it is returned as-is.
@@ -438,8 +460,10 @@ def construct_type(*, value: object, type_: object) -> object:
         type_ = type_.__value__  # type: ignore[unreachable]
 
     # unwrap `Annotated[T, ...]` -> `T`
-    if is_annotated_type(type_):
-        meta: tuple[Any, ...] = get_args(type_)[1:]
+    if metadata is not None and len(metadata) > 0:
+        meta: tuple[Any, ...] = tuple(metadata)
+    elif is_annotated_type(type_):
+        meta = get_args(type_)[1:]
         type_ = extract_type_arg(type_, 0)
     else:
         meta = tuple()

parallel/_types.py

@@ -13,10 +13,21 @@ from typing import (
     Mapping,
     TypeVar,
     Callable,
+    Iterator,
     Optional,
     Sequence,
 )
-from typing_extensions import Set, Literal, Protocol, TypeAlias, TypedDict, override, runtime_checkable
+from typing_extensions import (
+    Set,
+    Literal,
+    Protocol,
+    TypeAlias,
+    TypedDict,
+    SupportsIndex,
+    overload,
+    override,
+    runtime_checkable,
+)
 
 import httpx
 import pydantic
@@ -217,3 +228,26 @@ class _GenericAlias(Protocol):
 class HttpxSendArgs(TypedDict, total=False):
     auth: httpx.Auth
     follow_redirects: bool
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+
+
+if TYPE_CHECKING:
+    # This works because str.__contains__ does not accept object (either in typeshed or at runtime)
+    # https://github.com/hauntsaninja/useful_types/blob/5e9710f3875107d068e7679fd7fec9cfab0eff3b/useful_types/__init__.py#L285
+    class SequenceNotStr(Protocol[_T_co]):
+        @overload
+        def __getitem__(self, index: SupportsIndex, /) -> _T_co: ...
+        @overload
+        def __getitem__(self, index: slice, /) -> Sequence[_T_co]: ...
+        def __contains__(self, value: object, /) -> bool: ...
+        def __len__(self) -> int: ...
+        def __iter__(self) -> Iterator[_T_co]: ...
+        def index(self, value: Any, start: int = 0, stop: int = ..., /) -> int: ...
+        def count(self, value: Any, /) -> int: ...
+        def __reversed__(self) -> Iterator[_T_co]: ...
+else:
+    # just point this to a normal `Sequence` at runtime to avoid having to special case
+    # deserializing our custom sequence type
+    SequenceNotStr = Sequence

parallel/_utils/__init__.py

@@ -39,6 +39,7 @@ from ._typing import (
     extract_type_arg as extract_type_arg,
     is_iterable_type as is_iterable_type,
     is_required_type as is_required_type,
+    is_sequence_type as is_sequence_type,
     is_annotated_type as is_annotated_type,
     is_type_alias_type as is_type_alias_type,
     strip_annotated_type as strip_annotated_type,

parallel/_utils/_typing.py

@@ -26,6 +26,11 @@ def is_list_type(typ: type) -> bool:
     return (get_origin(typ) or typ) == list
 
 
+def is_sequence_type(typ: type) -> bool:
+    origin = get_origin(typ) or typ
+    return origin == typing_extensions.Sequence or origin == typing.Sequence or origin == _c_abc.Sequence
+
+
 def is_iterable_type(typ: type) -> bool:
     """If the given type is `typing.Iterable[T]`"""
     origin = get_origin(typ) or typ

parallel/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "parallel"
-__version__ = "0.1.2"  # x-release-please-version
+__version__ = "0.2.0"  # x-release-please-version

parallel/lib/_pydantic.py

@@ -26,6 +26,7 @@ def to_json_schema(
     schema["additionalProperties"] = False
     return schema
 
+
 def is_basemodel_type(model_type: object) -> TypeGuard[type[pydantic.BaseModel]]:
     """Check if a type is a Pydantic BaseModel to avoid using type: ignore."""
     return inspect.isclass(model_type) and issubclass(model_type, pydantic.BaseModel)

parallel/lib/_time.py

@@ -5,7 +5,7 @@ from typing import Union, Iterator, NoReturn
 import httpx
 
 from .._types import NotGiven
-from .._constants import DEFAULT_TIMEOUT_SECONDS
+from .._constants import DEFAULT_EXECUTE_TIMEOUT_SECONDS
 from .._exceptions import APIStatusError, APITimeoutError
 from .._utils._utils import is_given
 
@@ -19,7 +19,7 @@ def prepare_timeout_float(timeout: Union[float, httpx.Timeout, None, NotGiven])
         timeout = timeout.read
 
     if not is_given(timeout) or timeout is None:
-        return DEFAULT_TIMEOUT_SECONDS
+        return DEFAULT_EXECUTE_TIMEOUT_SECONDS
 
     return timeout
 

parallel/resources/__init__.py

@@ -1,5 +1,13 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
+from .beta import (
+    BetaResource,
+    AsyncBetaResource,
+    BetaResourceWithRawResponse,
+    AsyncBetaResourceWithRawResponse,
+    BetaResourceWithStreamingResponse,
+    AsyncBetaResourceWithStreamingResponse,
+)
 from .task_run import (
     TaskRunResource,
     AsyncTaskRunResource,
@@ -16,4 +24,10 @@ __all__ = [
     "AsyncTaskRunResourceWithRawResponse",
     "TaskRunResourceWithStreamingResponse",
     "AsyncTaskRunResourceWithStreamingResponse",
+    "BetaResource",
+    "AsyncBetaResource",
+    "BetaResourceWithRawResponse",
+    "AsyncBetaResourceWithRawResponse",
+    "BetaResourceWithStreamingResponse",
+    "AsyncBetaResourceWithStreamingResponse",
 ]

parallel/resources/beta/__init__.py

@@ -0,0 +1,47 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .beta import (
+    BetaResource,
+    AsyncBetaResource,
+    BetaResourceWithRawResponse,
+    AsyncBetaResourceWithRawResponse,
+    BetaResourceWithStreamingResponse,
+    AsyncBetaResourceWithStreamingResponse,
+)
+from .task_run import (
+    TaskRunResource,
+    AsyncTaskRunResource,
+    TaskRunResourceWithRawResponse,
+    AsyncTaskRunResourceWithRawResponse,
+    TaskRunResourceWithStreamingResponse,
+    AsyncTaskRunResourceWithStreamingResponse,
+)
+from .task_group import (
+    TaskGroupResource,
+    AsyncTaskGroupResource,
+    TaskGroupResourceWithRawResponse,
+    AsyncTaskGroupResourceWithRawResponse,
+    TaskGroupResourceWithStreamingResponse,
+    AsyncTaskGroupResourceWithStreamingResponse,
+)
+
+__all__ = [
+    "TaskRunResource",
+    "AsyncTaskRunResource",
+    "TaskRunResourceWithRawResponse",
+    "AsyncTaskRunResourceWithRawResponse",
+    "TaskRunResourceWithStreamingResponse",
+    "AsyncTaskRunResourceWithStreamingResponse",
+    "TaskGroupResource",
+    "AsyncTaskGroupResource",
+    "TaskGroupResourceWithRawResponse",
+    "AsyncTaskGroupResourceWithRawResponse",
+    "TaskGroupResourceWithStreamingResponse",
+    "AsyncTaskGroupResourceWithStreamingResponse",
+    "BetaResource",
+    "AsyncBetaResource",
+    "BetaResourceWithRawResponse",
+    "AsyncBetaResourceWithRawResponse",
+    "BetaResourceWithStreamingResponse",
+    "AsyncBetaResourceWithStreamingResponse",
+]