relaxai 0.0.1__py3-none-any.whl → 0.17.0__py3-none-any.whl

relaxai/_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,
         )
 

relaxai/_client.py

@@ -12,7 +12,9 @@ from . import _exceptions
 from ._qs import Querystring
 from ._types import (
     NOT_GIVEN,
+    Body,
     Omit,
+    Query,
     Headers,
     Timeout,
     NotGiven,
@@ -22,13 +24,20 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import chat, health, models, embeddings
+from ._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from .resources import chat, models, embeddings
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
-from ._exceptions import APIStatusError
+from ._exceptions import RelaxaiError, APIStatusError
 from ._base_client import (
     DEFAULT_MAX_RETRIES,
     SyncAPIClient,
     AsyncAPIClient,
+    make_request_options,
 )
 
 __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Relaxai", "AsyncRelaxai", "Client", "AsyncClient"]
@@ -37,13 +46,12 @@ __all__ = ["Timeout", "Transport", "ProxiesTypes", "RequestOptions", "Relaxai",
 class Relaxai(SyncAPIClient):
     chat: chat.ChatResource
     embeddings: embeddings.EmbeddingsResource
-    health: health.HealthResource
     models: models.ModelsResource
     with_raw_response: RelaxaiWithRawResponse
     with_streaming_response: RelaxaiWithStreamedResponse
 
     # client options
-    api_key: str | None
+    api_key: str
 
     def __init__(
         self,
@@ -74,12 +82,16 @@ class Relaxai(SyncAPIClient):
         """
         if api_key is None:
             api_key = os.environ.get("RELAXAI_API_KEY")
+        if api_key is None:
+            raise RelaxaiError(
+                "The api_key client option must be set either by passing api_key to the client or by setting the RELAXAI_API_KEY environment variable"
+            )
         self.api_key = api_key
 
         if base_url is None:
             base_url = os.environ.get("RELAXAI_BASE_URL")
         if base_url is None:
-            base_url = f"/"
+            base_url = f"https://api.relax.ai"
 
         super().__init__(
             version=__version__,
@@ -94,7 +106,6 @@ class Relaxai(SyncAPIClient):
 
         self.chat = chat.ChatResource(self)
         self.embeddings = embeddings.EmbeddingsResource(self)
-        self.health = health.HealthResource(self)
         self.models = models.ModelsResource(self)
         self.with_raw_response = RelaxaiWithRawResponse(self)
         self.with_streaming_response = RelaxaiWithStreamedResponse(self)
@@ -108,8 +119,6 @@ class Relaxai(SyncAPIClient):
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
-        if api_key is None:
-            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -121,17 +130,6 @@ class Relaxai(SyncAPIClient):
             **self._custom_headers,
         }
 
-    @override
-    def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
-        if self.api_key and headers.get("Authorization"):
-            return
-        if isinstance(custom_headers.get("Authorization"), Omit):
-            return
-
-        raise TypeError(
-            '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"'
-        )
-
     def copy(
         self,
         *,
@@ -183,6 +181,25 @@ class Relaxai(SyncAPIClient):
     # client.with_options(timeout=10).foo.create(...)
     with_options = copy
 
+    def health(
+        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,
+    ) -> str:
+        """Check the health of the service."""
+        return self.get(
+            "/v1/health",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=str,
+        )
+
     @override
     def _make_status_error(
         self,
@@ -220,13 +237,12 @@ class Relaxai(SyncAPIClient):
 class AsyncRelaxai(AsyncAPIClient):
     chat: chat.AsyncChatResource
     embeddings: embeddings.AsyncEmbeddingsResource
-    health: health.AsyncHealthResource
     models: models.AsyncModelsResource
     with_raw_response: AsyncRelaxaiWithRawResponse
     with_streaming_response: AsyncRelaxaiWithStreamedResponse
 
     # client options
-    api_key: str | None
+    api_key: str
 
     def __init__(
         self,
@@ -257,12 +273,16 @@ class AsyncRelaxai(AsyncAPIClient):
         """
         if api_key is None:
             api_key = os.environ.get("RELAXAI_API_KEY")
+        if api_key is None:
+            raise RelaxaiError(
+                "The api_key client option must be set either by passing api_key to the client or by setting the RELAXAI_API_KEY environment variable"
+            )
         self.api_key = api_key
 
         if base_url is None:
             base_url = os.environ.get("RELAXAI_BASE_URL")
         if base_url is None:
-            base_url = f"/"
+            base_url = f"https://api.relax.ai"
 
         super().__init__(
             version=__version__,
@@ -277,7 +297,6 @@ class AsyncRelaxai(AsyncAPIClient):
 
         self.chat = chat.AsyncChatResource(self)
         self.embeddings = embeddings.AsyncEmbeddingsResource(self)
-        self.health = health.AsyncHealthResource(self)
         self.models = models.AsyncModelsResource(self)
         self.with_raw_response = AsyncRelaxaiWithRawResponse(self)
         self.with_streaming_response = AsyncRelaxaiWithStreamedResponse(self)
@@ -291,8 +310,6 @@ class AsyncRelaxai(AsyncAPIClient):
     @override
     def auth_headers(self) -> dict[str, str]:
         api_key = self.api_key
-        if api_key is None:
-            return {}
         return {"Authorization": f"Bearer {api_key}"}
 
     @property
@@ -304,17 +321,6 @@ class AsyncRelaxai(AsyncAPIClient):
             **self._custom_headers,
         }
 
-    @override
-    def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None:
-        if self.api_key and headers.get("Authorization"):
-            return
-        if isinstance(custom_headers.get("Authorization"), Omit):
-            return
-
-        raise TypeError(
-            '"Could not resolve authentication method. Expected the api_key to be set. Or for the `Authorization` headers to be explicitly omitted"'
-        )
-
     def copy(
         self,
         *,
@@ -366,6 +372,25 @@ class AsyncRelaxai(AsyncAPIClient):
     # client.with_options(timeout=10).foo.create(...)
     with_options = copy
 
+    async def health(
+        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,
+    ) -> str:
+        """Check the health of the service."""
+        return await self.get(
+            "/v1/health",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=str,
+        )
+
     @override
     def _make_status_error(
         self,
@@ -404,33 +429,45 @@ class RelaxaiWithRawResponse:
     def __init__(self, client: Relaxai) -> None:
         self.chat = chat.ChatResourceWithRawResponse(client.chat)
         self.embeddings = embeddings.EmbeddingsResourceWithRawResponse(client.embeddings)
-        self.health = health.HealthResourceWithRawResponse(client.health)
         self.models = models.ModelsResourceWithRawResponse(client.models)
 
+        self.health = to_raw_response_wrapper(
+            client.health,
+        )
+
 
 class AsyncRelaxaiWithRawResponse:
     def __init__(self, client: AsyncRelaxai) -> None:
         self.chat = chat.AsyncChatResourceWithRawResponse(client.chat)
         self.embeddings = embeddings.AsyncEmbeddingsResourceWithRawResponse(client.embeddings)
-        self.health = health.AsyncHealthResourceWithRawResponse(client.health)
         self.models = models.AsyncModelsResourceWithRawResponse(client.models)
 
+        self.health = async_to_raw_response_wrapper(
+            client.health,
+        )
+
 
 class RelaxaiWithStreamedResponse:
     def __init__(self, client: Relaxai) -> None:
         self.chat = chat.ChatResourceWithStreamingResponse(client.chat)
         self.embeddings = embeddings.EmbeddingsResourceWithStreamingResponse(client.embeddings)
-        self.health = health.HealthResourceWithStreamingResponse(client.health)
         self.models = models.ModelsResourceWithStreamingResponse(client.models)
 
+        self.health = to_streamed_response_wrapper(
+            client.health,
+        )
+
 
 class AsyncRelaxaiWithStreamedResponse:
     def __init__(self, client: AsyncRelaxai) -> None:
         self.chat = chat.AsyncChatResourceWithStreamingResponse(client.chat)
         self.embeddings = embeddings.AsyncEmbeddingsResourceWithStreamingResponse(client.embeddings)
-        self.health = health.AsyncHealthResourceWithStreamingResponse(client.health)
         self.models = models.AsyncModelsResourceWithStreamingResponse(client.models)
 
+        self.health = async_to_streamed_response_wrapper(
+            client.health,
+        )
+
 
 Client = Relaxai
 

relaxai/_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()
 

relaxai/_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)
 
@@ -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()

relaxai/_version.py

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

relaxai/resources/__init__.py

@@ -8,14 +8,6 @@ from .chat import (
     ChatResourceWithStreamingResponse,
     AsyncChatResourceWithStreamingResponse,
 )
-from .health import (
-    HealthResource,
-    AsyncHealthResource,
-    HealthResourceWithRawResponse,
-    AsyncHealthResourceWithRawResponse,
-    HealthResourceWithStreamingResponse,
-    AsyncHealthResourceWithStreamingResponse,
-)
 from .models import (
     ModelsResource,
     AsyncModelsResource,
@@ -46,12 +38,6 @@ __all__ = [
     "AsyncEmbeddingsResourceWithRawResponse",
     "EmbeddingsResourceWithStreamingResponse",
     "AsyncEmbeddingsResourceWithStreamingResponse",
-    "HealthResource",
-    "AsyncHealthResource",
-    "HealthResourceWithRawResponse",
-    "AsyncHealthResourceWithRawResponse",
-    "HealthResourceWithStreamingResponse",
-    "AsyncHealthResourceWithStreamingResponse",
     "ModelsResource",
     "AsyncModelsResource",
     "ModelsResourceWithRawResponse",

relaxai/resources/chat.py

@@ -18,9 +18,10 @@ from .._response import (
     async_to_streamed_response_wrapper,
 )
 from .._base_client import make_request_options
+from ..types.stream_options_param import StreamOptionsParam
+from ..types.chat_completion_response import ChatCompletionResponse
 from ..types.function_definition_param import FunctionDefinitionParam
 from ..types.chat_completion_message_param import ChatCompletionMessageParam
-from ..types.chat_create_completion_response import ChatCreateCompletionResponse
 
 __all__ = ["ChatResource", "AsyncChatResource"]
 
@@ -50,6 +51,7 @@ class ChatResource(SyncAPIResource):
         *,
         messages: Iterable[ChatCompletionMessageParam],
         model: str,
+        query_stream: bool | NotGiven = NOT_GIVEN,
         chat_template_kwargs: object | NotGiven = NOT_GIVEN,
         frequency_penalty: float | NotGiven = NOT_GIVEN,
         function_call: object | NotGiven = NOT_GIVEN,
@@ -68,25 +70,29 @@ class ChatResource(SyncAPIResource):
         seed: int | NotGiven = NOT_GIVEN,
         stop: List[str] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
-        stream: bool | NotGiven = NOT_GIVEN,
-        stream_options: chat_create_completion_params.StreamOptions | NotGiven = NOT_GIVEN,
+        body_stream: bool | NotGiven = NOT_GIVEN,
+        stream_options: StreamOptionsParam | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
         tool_choice: object | NotGiven = NOT_GIVEN,
         tools: Iterable[chat_create_completion_params.Tool] | NotGiven = NOT_GIVEN,
         top_logprobs: int | NotGiven = NOT_GIVEN,
         top_p: float | NotGiven = NOT_GIVEN,
         user: str | NotGiven = NOT_GIVEN,
+        web_search_options: chat_create_completion_params.WebSearchOptions | NotGiven = NOT_GIVEN,
         # 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,
-    ) -> ChatCreateCompletionResponse:
+    ) -> ChatCompletionResponse:
         """
         Creates a chat completion for the given model
 
         Args:
+          query_stream: If true, server responds as an SSE stream. Generators may produce an ergonomic
+              streaming method when this is set.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -119,7 +125,7 @@ class ChatResource(SyncAPIResource):
                     "seed": seed,
                     "stop": stop,
                     "store": store,
-                    "stream": stream,
+                    "body_stream": body_stream,
                     "stream_options": stream_options,
                     "temperature": temperature,
                     "tool_choice": tool_choice,
@@ -127,13 +133,20 @@ class ChatResource(SyncAPIResource):
                     "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "user": user,
+                    "web_search_options": web_search_options,
                 },
                 chat_create_completion_params.ChatCreateCompletionParams,
             ),
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=maybe_transform(
+                    {"query_stream": query_stream}, chat_create_completion_params.ChatCreateCompletionParams
+                ),
             ),
-            cast_to=ChatCreateCompletionResponse,
+            cast_to=ChatCompletionResponse,
         )
 
 
@@ -162,6 +175,7 @@ class AsyncChatResource(AsyncAPIResource):
         *,
         messages: Iterable[ChatCompletionMessageParam],
         model: str,
+        query_stream: bool | NotGiven = NOT_GIVEN,
         chat_template_kwargs: object | NotGiven = NOT_GIVEN,
         frequency_penalty: float | NotGiven = NOT_GIVEN,
         function_call: object | NotGiven = NOT_GIVEN,
@@ -180,25 +194,29 @@ class AsyncChatResource(AsyncAPIResource):
         seed: int | NotGiven = NOT_GIVEN,
         stop: List[str] | NotGiven = NOT_GIVEN,
         store: bool | NotGiven = NOT_GIVEN,
-        stream: bool | NotGiven = NOT_GIVEN,
-        stream_options: chat_create_completion_params.StreamOptions | NotGiven = NOT_GIVEN,
+        body_stream: bool | NotGiven = NOT_GIVEN,
+        stream_options: StreamOptionsParam | NotGiven = NOT_GIVEN,
         temperature: float | NotGiven = NOT_GIVEN,
         tool_choice: object | NotGiven = NOT_GIVEN,
         tools: Iterable[chat_create_completion_params.Tool] | NotGiven = NOT_GIVEN,
         top_logprobs: int | NotGiven = NOT_GIVEN,
         top_p: float | NotGiven = NOT_GIVEN,
         user: str | NotGiven = NOT_GIVEN,
+        web_search_options: chat_create_completion_params.WebSearchOptions | NotGiven = NOT_GIVEN,
         # 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,
-    ) -> ChatCreateCompletionResponse:
+    ) -> ChatCompletionResponse:
         """
         Creates a chat completion for the given model
 
         Args:
+          query_stream: If true, server responds as an SSE stream. Generators may produce an ergonomic
+              streaming method when this is set.
+
           extra_headers: Send extra headers
 
           extra_query: Add additional query parameters to the request
@@ -231,7 +249,7 @@ class AsyncChatResource(AsyncAPIResource):
                     "seed": seed,
                     "stop": stop,
                     "store": store,
-                    "stream": stream,
+                    "body_stream": body_stream,
                     "stream_options": stream_options,
                     "temperature": temperature,
                     "tool_choice": tool_choice,
@@ -239,13 +257,20 @@ class AsyncChatResource(AsyncAPIResource):
                     "top_logprobs": top_logprobs,
                     "top_p": top_p,
                     "user": user,
+                    "web_search_options": web_search_options,
                 },
                 chat_create_completion_params.ChatCreateCompletionParams,
             ),
             options=make_request_options(
-                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                query=await async_maybe_transform(
+                    {"query_stream": query_stream}, chat_create_completion_params.ChatCreateCompletionParams
+                ),
             ),
-            cast_to=ChatCreateCompletionResponse,
+            cast_to=ChatCompletionResponse,
         )