worqhat 3.9.0__py3-none-any.whl → 4.1.0__py3-none-any.whl

worqhat/_client.py

@@ -1,484 +0,0 @@
-# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-
-from __future__ import annotations
-
-import os
-from typing import Any, Mapping
-from typing_extensions import Self, override
-
-import httpx
-
-from . import _exceptions
-from ._qs import Querystring
-from ._types import (
-    Body,
-    Omit,
-    Query,
-    Headers,
-    Timeout,
-    NotGiven,
-    Transport,
-    ProxiesTypes,
-    RequestOptions,
-    not_given,
-)
-from ._utils import is_given, get_async_library
-from ._version import __version__
-from ._response import (
-    to_raw_response_wrapper,
-    to_streamed_response_wrapper,
-    async_to_raw_response_wrapper,
-    async_to_streamed_response_wrapper,
-)
-from .resources import flows, health, storage
-from ._streaming import Stream as Stream, AsyncStream as AsyncStream
-from ._exceptions import WorqhatError, APIStatusError
-from ._base_client import (
-    DEFAULT_MAX_RETRIES,
-    SyncAPIClient,
-    AsyncAPIClient,
-    make_request_options,
-)
-from .resources.db import db
-from .types.get_server_info_response import GetServerInfoResponse
-
-__all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Worqhat", "AsyncWorqhat", "Client", "AsyncClient"]
-
-
-class Worqhat(SyncAPIClient):
-    db: db.DBResource
-    health: health.HealthResource
-    flows: flows.FlowsResource
-    storage: storage.StorageResource
-    with_raw_response: WorqhatWithRawResponse
-    with_streaming_response: WorqhatWithStreamedResponse
-
-    # client options
-    api_key: str
-
-    def __init__(
-        self,
-        *,
-        api_key: str | None = None,
-        base_url: str | httpx.URL | None = None,
-        timeout: float | Timeout | None | NotGiven = not_given,
-        max_retries: int = DEFAULT_MAX_RETRIES,
-        default_headers: Mapping[str, str] | None = None,
-        default_query: Mapping[str, object] | None = None,
-        # Configure a custom httpx client.
-        # We provide a `DefaultHttpxClient` class that you can pass to retain the default values we use for `limits`, `timeout` & `follow_redirects`.
-        # See the [httpx documentation](https://www.python-httpx.org/api/#client) for more details.
-        http_client: httpx.Client | None = None,
-        # Enable or disable schema validation for data returned by the API.
-        # When enabled an error APIResponseValidationError is raised
-        # if the API responds with invalid data for the expected schema.
-        #
-        # This parameter may be removed or changed in the future.
-        # If you rely on this feature, please open a GitHub issue
-        # outlining your use-case to help us decide if it should be
-        # part of our public interface in the future.
-        _strict_response_validation: bool = False,
-    ) -> None:
-        """Construct a new synchronous Worqhat client instance.
-
-        This automatically infers the `api_key` argument from the `WORQHAT_API_KEY` environment variable if it is not provided.
-        """
-        if api_key is None:
-            api_key = os.environ.get("WORQHAT_API_KEY")
-        if api_key is None:
-            raise WorqhatError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the WORQHAT_API_KEY environment variable"
-            )
-        self.api_key = api_key
-
-        if base_url is None:
-            base_url = os.environ.get("WORQHAT_BASE_URL")
-        if base_url is None:
-            base_url = f"https://api.worqhat.com"
-
-        super().__init__(
-            version=__version__,
-            base_url=base_url,
-            max_retries=max_retries,
-            timeout=timeout,
-            http_client=http_client,
-            custom_headers=default_headers,
-            custom_query=default_query,
-            _strict_response_validation=_strict_response_validation,
-        )
-
-        self.db = db.DBResource(self)
-        self.health = health.HealthResource(self)
-        self.flows = flows.FlowsResource(self)
-        self.storage = storage.StorageResource(self)
-        self.with_raw_response = WorqhatWithRawResponse(self)
-        self.with_streaming_response = WorqhatWithStreamedResponse(self)
-
-    @property
-    @override
-    def qs(self) -> Querystring:
-        return Querystring(array_format="comma")
-
-    @property
-    @override
-    def auth_headers(self) -> dict[str, str]:
-        api_key = self.api_key
-        return {"Authorization": api_key}
-
-    @property
-    @override
-    def default_headers(self) -> dict[str, str | Omit]:
-        return {
-            **super().default_headers,
-            "X-Stainless-Async": "false",
-            **self._custom_headers,
-        }
-
-    def copy(
-        self,
-        *,
-        api_key: str | None = None,
-        base_url: str | httpx.URL | None = None,
-        timeout: float | Timeout | None | NotGiven = not_given,
-        http_client: httpx.Client | None = None,
-        max_retries: int | NotGiven = not_given,
-        default_headers: Mapping[str, str] | None = None,
-        set_default_headers: Mapping[str, str] | None = None,
-        default_query: Mapping[str, object] | None = None,
-        set_default_query: Mapping[str, object] | None = None,
-        _extra_kwargs: Mapping[str, Any] = {},
-    ) -> Self:
-        """
-        Create a new client instance re-using the same options given to the current client with optional overriding.
-        """
-        if default_headers is not None and set_default_headers is not None:
-            raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
-
-        if default_query is not None and set_default_query is not None:
-            raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
-
-        headers = self._custom_headers
-        if default_headers is not None:
-            headers = {**headers, **default_headers}
-        elif set_default_headers is not None:
-            headers = set_default_headers
-
-        params = self._custom_query
-        if default_query is not None:
-            params = {**params, **default_query}
-        elif set_default_query is not None:
-            params = set_default_query
-
-        http_client = http_client or self._client
-        return self.__class__(
-            api_key=api_key or self.api_key,
-            base_url=base_url or self.base_url,
-            timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
-            http_client=http_client,
-            max_retries=max_retries if is_given(max_retries) else self.max_retries,
-            default_headers=headers,
-            default_query=params,
-            **_extra_kwargs,
-        )
-
-    # Alias for `copy` for nicer inline usage, e.g.
-    # client.with_options(timeout=10).foo.create(...)
-    with_options = copy
-
-    def get_server_info(
-        self,
-        *,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> GetServerInfoResponse:
-        """Get basic server information and status"""
-        return self.get(
-            "/",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=GetServerInfoResponse,
-        )
-
-    @override
-    def _make_status_error(
-        self,
-        err_msg: str,
-        *,
-        body: object,
-        response: httpx.Response,
-    ) -> APIStatusError:
-        if response.status_code == 400:
-            return _exceptions.BadRequestError(err_msg, response=response, body=body)
-
-        if response.status_code == 401:
-            return _exceptions.AuthenticationError(err_msg, response=response, body=body)
-
-        if response.status_code == 403:
-            return _exceptions.PermissionDeniedError(err_msg, response=response, body=body)
-
-        if response.status_code == 404:
-            return _exceptions.NotFoundError(err_msg, response=response, body=body)
-
-        if response.status_code == 409:
-            return _exceptions.ConflictError(err_msg, response=response, body=body)
-
-        if response.status_code == 422:
-            return _exceptions.UnprocessableEntityError(err_msg, response=response, body=body)
-
-        if response.status_code == 429:
-            return _exceptions.RateLimitError(err_msg, response=response, body=body)
-
-        if response.status_code >= 500:
-            return _exceptions.InternalServerError(err_msg, response=response, body=body)
-        return APIStatusError(err_msg, response=response, body=body)
-
-
-class AsyncWorqhat(AsyncAPIClient):
-    db: db.AsyncDBResource
-    health: health.AsyncHealthResource
-    flows: flows.AsyncFlowsResource
-    storage: storage.AsyncStorageResource
-    with_raw_response: AsyncWorqhatWithRawResponse
-    with_streaming_response: AsyncWorqhatWithStreamedResponse
-
-    # client options
-    api_key: str
-
-    def __init__(
-        self,
-        *,
-        api_key: str | None = None,
-        base_url: str | httpx.URL | None = None,
-        timeout: float | Timeout | None | NotGiven = not_given,
-        max_retries: int = DEFAULT_MAX_RETRIES,
-        default_headers: Mapping[str, str] | None = None,
-        default_query: Mapping[str, object] | None = None,
-        # Configure a custom httpx client.
-        # We provide a `DefaultAsyncHttpxClient` class that you can pass to retain the default values we use for `limits`, `timeout` & `follow_redirects`.
-        # See the [httpx documentation](https://www.python-httpx.org/api/#asyncclient) for more details.
-        http_client: httpx.AsyncClient | None = None,
-        # Enable or disable schema validation for data returned by the API.
-        # When enabled an error APIResponseValidationError is raised
-        # if the API responds with invalid data for the expected schema.
-        #
-        # This parameter may be removed or changed in the future.
-        # If you rely on this feature, please open a GitHub issue
-        # outlining your use-case to help us decide if it should be
-        # part of our public interface in the future.
-        _strict_response_validation: bool = False,
-    ) -> None:
-        """Construct a new async AsyncWorqhat client instance.
-
-        This automatically infers the `api_key` argument from the `WORQHAT_API_KEY` environment variable if it is not provided.
-        """
-        if api_key is None:
-            api_key = os.environ.get("WORQHAT_API_KEY")
-        if api_key is None:
-            raise WorqhatError(
-                "The api_key client option must be set either by passing api_key to the client or by setting the WORQHAT_API_KEY environment variable"
-            )
-        self.api_key = api_key
-
-        if base_url is None:
-            base_url = os.environ.get("WORQHAT_BASE_URL")
-        if base_url is None:
-            base_url = f"https://api.worqhat.com"
-
-        super().__init__(
-            version=__version__,
-            base_url=base_url,
-            max_retries=max_retries,
-            timeout=timeout,
-            http_client=http_client,
-            custom_headers=default_headers,
-            custom_query=default_query,
-            _strict_response_validation=_strict_response_validation,
-        )
-
-        self.db = db.AsyncDBResource(self)
-        self.health = health.AsyncHealthResource(self)
-        self.flows = flows.AsyncFlowsResource(self)
-        self.storage = storage.AsyncStorageResource(self)
-        self.with_raw_response = AsyncWorqhatWithRawResponse(self)
-        self.with_streaming_response = AsyncWorqhatWithStreamedResponse(self)
-
-    @property
-    @override
-    def qs(self) -> Querystring:
-        return Querystring(array_format="comma")
-
-    @property
-    @override
-    def auth_headers(self) -> dict[str, str]:
-        api_key = self.api_key
-        return {"Authorization": api_key}
-
-    @property
-    @override
-    def default_headers(self) -> dict[str, str | Omit]:
-        return {
-            **super().default_headers,
-            "X-Stainless-Async": f"async:{get_async_library()}",
-            **self._custom_headers,
-        }
-
-    def copy(
-        self,
-        *,
-        api_key: str | None = None,
-        base_url: str | httpx.URL | None = None,
-        timeout: float | Timeout | None | NotGiven = not_given,
-        http_client: httpx.AsyncClient | None = None,
-        max_retries: int | NotGiven = not_given,
-        default_headers: Mapping[str, str] | None = None,
-        set_default_headers: Mapping[str, str] | None = None,
-        default_query: Mapping[str, object] | None = None,
-        set_default_query: Mapping[str, object] | None = None,
-        _extra_kwargs: Mapping[str, Any] = {},
-    ) -> Self:
-        """
-        Create a new client instance re-using the same options given to the current client with optional overriding.
-        """
-        if default_headers is not None and set_default_headers is not None:
-            raise ValueError("The `default_headers` and `set_default_headers` arguments are mutually exclusive")
-
-        if default_query is not None and set_default_query is not None:
-            raise ValueError("The `default_query` and `set_default_query` arguments are mutually exclusive")
-
-        headers = self._custom_headers
-        if default_headers is not None:
-            headers = {**headers, **default_headers}
-        elif set_default_headers is not None:
-            headers = set_default_headers
-
-        params = self._custom_query
-        if default_query is not None:
-            params = {**params, **default_query}
-        elif set_default_query is not None:
-            params = set_default_query
-
-        http_client = http_client or self._client
-        return self.__class__(
-            api_key=api_key or self.api_key,
-            base_url=base_url or self.base_url,
-            timeout=self.timeout if isinstance(timeout, NotGiven) else timeout,
-            http_client=http_client,
-            max_retries=max_retries if is_given(max_retries) else self.max_retries,
-            default_headers=headers,
-            default_query=params,
-            **_extra_kwargs,
-        )
-
-    # Alias for `copy` for nicer inline usage, e.g.
-    # client.with_options(timeout=10).foo.create(...)
-    with_options = copy
-
-    async def get_server_info(
-        self,
-        *,
-        # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs.
-        # The extra values given here take precedence over values defined on the client or passed to this method.
-        extra_headers: Headers | None = None,
-        extra_query: Query | None = None,
-        extra_body: Body | None = None,
-        timeout: float | httpx.Timeout | None | NotGiven = not_given,
-    ) -> GetServerInfoResponse:
-        """Get basic server information and status"""
-        return await self.get(
-            "/",
-            options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
-            ),
-            cast_to=GetServerInfoResponse,
-        )
-
-    @override
-    def _make_status_error(
-        self,
-        err_msg: str,
-        *,
-        body: object,
-        response: httpx.Response,
-    ) -> APIStatusError:
-        if response.status_code == 400:
-            return _exceptions.BadRequestError(err_msg, response=response, body=body)
-
-        if response.status_code == 401:
-            return _exceptions.AuthenticationError(err_msg, response=response, body=body)
-
-        if response.status_code == 403:
-            return _exceptions.PermissionDeniedError(err_msg, response=response, body=body)
-
-        if response.status_code == 404:
-            return _exceptions.NotFoundError(err_msg, response=response, body=body)
-
-        if response.status_code == 409:
-            return _exceptions.ConflictError(err_msg, response=response, body=body)
-
-        if response.status_code == 422:
-            return _exceptions.UnprocessableEntityError(err_msg, response=response, body=body)
-
-        if response.status_code == 429:
-            return _exceptions.RateLimitError(err_msg, response=response, body=body)
-
-        if response.status_code >= 500:
-            return _exceptions.InternalServerError(err_msg, response=response, body=body)
-        return APIStatusError(err_msg, response=response, body=body)
-
-
-class WorqhatWithRawResponse:
-    def __init__(self, client: Worqhat) -> None:
-        self.db = db.DBResourceWithRawResponse(client.db)
-        self.health = health.HealthResourceWithRawResponse(client.health)
-        self.flows = flows.FlowsResourceWithRawResponse(client.flows)
-        self.storage = storage.StorageResourceWithRawResponse(client.storage)
-
-        self.get_server_info = to_raw_response_wrapper(
-            client.get_server_info,
-        )
-
-
-class AsyncWorqhatWithRawResponse:
-    def __init__(self, client: AsyncWorqhat) -> None:
-        self.db = db.AsyncDBResourceWithRawResponse(client.db)
-        self.health = health.AsyncHealthResourceWithRawResponse(client.health)
-        self.flows = flows.AsyncFlowsResourceWithRawResponse(client.flows)
-        self.storage = storage.AsyncStorageResourceWithRawResponse(client.storage)
-
-        self.get_server_info = async_to_raw_response_wrapper(
-            client.get_server_info,
-        )
-
-
-class WorqhatWithStreamedResponse:
-    def __init__(self, client: Worqhat) -> None:
-        self.db = db.DBResourceWithStreamingResponse(client.db)
-        self.health = health.HealthResourceWithStreamingResponse(client.health)
-        self.flows = flows.FlowsResourceWithStreamingResponse(client.flows)
-        self.storage = storage.StorageResourceWithStreamingResponse(client.storage)
-
-        self.get_server_info = to_streamed_response_wrapper(
-            client.get_server_info,
-        )
-
-
-class AsyncWorqhatWithStreamedResponse:
-    def __init__(self, client: AsyncWorqhat) -> None:
-        self.db = db.AsyncDBResourceWithStreamingResponse(client.db)
-        self.health = health.AsyncHealthResourceWithStreamingResponse(client.health)
-        self.flows = flows.AsyncFlowsResourceWithStreamingResponse(client.flows)
-        self.storage = storage.AsyncStorageResourceWithStreamingResponse(client.storage)
-
-        self.get_server_info = async_to_streamed_response_wrapper(
-            client.get_server_info,
-        )
-
-
-Client = Worqhat
-
-AsyncClient = AsyncWorqhat

worqhat/_compat.py

@@ -1,219 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Union, Generic, TypeVar, Callable, cast, overload
-from datetime import date, datetime
-from typing_extensions import Self, Literal
-
-import pydantic
-from pydantic.fields import FieldInfo
-
-from ._types import IncEx, StrBytesIntFloat
-
-_T = TypeVar("_T")
-_ModelT = TypeVar("_ModelT", bound=pydantic.BaseModel)
-
-# --------------- Pydantic v2, v3 compatibility ---------------
-
-# Pyright incorrectly reports some of our functions as overriding a method when they don't
-# pyright: reportIncompatibleMethodOverride=false
-
-PYDANTIC_V1 = pydantic.VERSION.startswith("1.")
-
-if TYPE_CHECKING:
-
-    def parse_date(value: date | StrBytesIntFloat) -> date:  # noqa: ARG001
-        ...
-
-    def parse_datetime(value: Union[datetime, StrBytesIntFloat]) -> datetime:  # noqa: ARG001
-        ...
-
-    def get_args(t: type[Any]) -> tuple[Any, ...]:  # noqa: ARG001
-        ...
-
-    def is_union(tp: type[Any] | None) -> bool:  # noqa: ARG001
-        ...
-
-    def get_origin(t: type[Any]) -> type[Any] | None:  # noqa: ARG001
-        ...
-
-    def is_literal_type(type_: type[Any]) -> bool:  # noqa: ARG001
-        ...
-
-    def is_typeddict(type_: type[Any]) -> bool:  # noqa: ARG001
-        ...
-
-else:
-    # v1 re-exports
-    if PYDANTIC_V1:
-        from pydantic.typing import (
-            get_args as get_args,
-            is_union as is_union,
-            get_origin as get_origin,
-            is_typeddict as is_typeddict,
-            is_literal_type as is_literal_type,
-        )
-        from pydantic.datetime_parse import parse_date as parse_date, parse_datetime as parse_datetime
-    else:
-        from ._utils import (
-            get_args as get_args,
-            is_union as is_union,
-            get_origin as get_origin,
-            parse_date as parse_date,
-            is_typeddict as is_typeddict,
-            parse_datetime as parse_datetime,
-            is_literal_type as is_literal_type,
-        )
-
-
-# refactored config
-if TYPE_CHECKING:
-    from pydantic import ConfigDict as ConfigDict
-else:
-    if PYDANTIC_V1:
-        # TODO: provide an error message here?
-        ConfigDict = None
-    else:
-        from pydantic import ConfigDict as ConfigDict
-
-
-# renamed methods / properties
-def parse_obj(model: type[_ModelT], value: object) -> _ModelT:
-    if PYDANTIC_V1:
-        return cast(_ModelT, model.parse_obj(value))  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-    else:
-        return model.model_validate(value)
-
-
-def field_is_required(field: FieldInfo) -> bool:
-    if PYDANTIC_V1:
-        return field.required  # type: ignore
-    return field.is_required()
-
-
-def field_get_default(field: FieldInfo) -> Any:
-    value = field.get_default()
-    if PYDANTIC_V1:
-        return value
-    from pydantic_core import PydanticUndefined
-
-    if value == PydanticUndefined:
-        return None
-    return value
-
-
-def field_outer_type(field: FieldInfo) -> Any:
-    if PYDANTIC_V1:
-        return field.outer_type_  # type: ignore
-    return field.annotation
-
-
-def get_model_config(model: type[pydantic.BaseModel]) -> Any:
-    if PYDANTIC_V1:
-        return model.__config__  # type: ignore
-    return model.model_config
-
-
-def get_model_fields(model: type[pydantic.BaseModel]) -> dict[str, FieldInfo]:
-    if PYDANTIC_V1:
-        return model.__fields__  # type: ignore
-    return model.model_fields
-
-
-def model_copy(model: _ModelT, *, deep: bool = False) -> _ModelT:
-    if PYDANTIC_V1:
-        return model.copy(deep=deep)  # type: ignore
-    return model.model_copy(deep=deep)
-
-
-def model_json(model: pydantic.BaseModel, *, indent: int | None = None) -> str:
-    if PYDANTIC_V1:
-        return model.json(indent=indent)  # type: ignore
-    return model.model_dump_json(indent=indent)
-
-
-def model_dump(
-    model: pydantic.BaseModel,
-    *,
-    exclude: IncEx | None = None,
-    exclude_unset: bool = False,
-    exclude_defaults: bool = False,
-    warnings: bool = True,
-    mode: Literal["json", "python"] = "python",
-) -> dict[str, Any]:
-    if (not PYDANTIC_V1) or hasattr(model, "model_dump"):
-        return model.model_dump(
-            mode=mode,
-            exclude=exclude,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
-            # warnings are not supported in Pydantic v1
-            warnings=True if PYDANTIC_V1 else warnings,
-        )
-    return cast(
-        "dict[str, Any]",
-        model.dict(  # pyright: ignore[reportDeprecated, reportUnnecessaryCast]
-            exclude=exclude,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
-        ),
-    )
-
-
-def model_parse(model: type[_ModelT], data: Any) -> _ModelT:
-    if PYDANTIC_V1:
-        return model.parse_obj(data)  # pyright: ignore[reportDeprecated]
-    return model.model_validate(data)
-
-
-# generic models
-if TYPE_CHECKING:
-
-    class GenericModel(pydantic.BaseModel): ...
-
-else:
-    if PYDANTIC_V1:
-        import pydantic.generics
-
-        class GenericModel(pydantic.generics.GenericModel, pydantic.BaseModel): ...
-    else:
-        # there no longer needs to be a distinction in v2 but
-        # we still have to create our own subclass to avoid
-        # inconsistent MRO ordering errors
-        class GenericModel(pydantic.BaseModel): ...
-
-
-# cached properties
-if TYPE_CHECKING:
-    cached_property = property
-
-    # we define a separate type (copied from typeshed)
-    # that represents that `cached_property` is `set`able
-    # at runtime, which differs from `@property`.
-    #
-    # this is a separate type as editors likely special case
-    # `@property` and we don't want to cause issues just to have
-    # more helpful internal types.
-
-    class typed_cached_property(Generic[_T]):
-        func: Callable[[Any], _T]
-        attrname: str | None
-
-        def __init__(self, func: Callable[[Any], _T]) -> None: ...
-
-        @overload
-        def __get__(self, instance: None, owner: type[Any] | None = None) -> Self: ...
-
-        @overload
-        def __get__(self, instance: object, owner: type[Any] | None = None) -> _T: ...
-
-        def __get__(self, instance: object, owner: type[Any] | None = None) -> _T | Self:
-            raise NotImplementedError()
-
-        def __set_name__(self, owner: type[Any], name: str) -> None: ...
-
-        # __set__ is not defined at runtime, but @cached_property is designed to be settable
-        def __set__(self, instance: object, value: _T) -> None: ...
-else:
-    from functools import cached_property as cached_property
-
-    typed_cached_property = cached_property