relaxai 0.0.1__py3-none-any.whl

relaxai/resources/models.py

@@ -0,0 +1,214 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+import httpx
+
+from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven
+from .._compat import cached_property
+from .._resource import SyncAPIResource, AsyncAPIResource
+from .._response import (
+    to_raw_response_wrapper,
+    to_streamed_response_wrapper,
+    async_to_raw_response_wrapper,
+    async_to_streamed_response_wrapper,
+)
+from ..types.model import Model
+from .._base_client import make_request_options
+from ..types.model_list_response import ModelListResponse
+
+__all__ = ["ModelsResource", "AsyncModelsResource"]
+
+
+class ModelsResource(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> ModelsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/relax-ai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return ModelsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> ModelsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/relax-ai/python-sdk#with_streaming_response
+        """
+        return ModelsResourceWithStreamingResponse(self)
+
+    def retrieve(
+        self,
+        model: str,
+        *,
+        # 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,
+    ) -> Model:
+        """
+        Get the details of the given model
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not model:
+            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
+        return self._get(
+            f"/v1/models/{model}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Model,
+        )
+
+    def list(
+        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,
+    ) -> ModelListResponse:
+        """List all the available models"""
+        return self._get(
+            "/v1/models",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ModelListResponse,
+        )
+
+
+class AsyncModelsResource(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncModelsResourceWithRawResponse:
+        """
+        This property can be used as a prefix for any HTTP method call to return
+        the raw response object instead of the parsed content.
+
+        For more information, see https://www.github.com/relax-ai/python-sdk#accessing-raw-response-data-eg-headers
+        """
+        return AsyncModelsResourceWithRawResponse(self)
+
+    @cached_property
+    def with_streaming_response(self) -> AsyncModelsResourceWithStreamingResponse:
+        """
+        An alternative to `.with_raw_response` that doesn't eagerly read the response body.
+
+        For more information, see https://www.github.com/relax-ai/python-sdk#with_streaming_response
+        """
+        return AsyncModelsResourceWithStreamingResponse(self)
+
+    async def retrieve(
+        self,
+        model: str,
+        *,
+        # 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,
+    ) -> Model:
+        """
+        Get the details of the given model
+
+        Args:
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        if not model:
+            raise ValueError(f"Expected a non-empty value for `model` but received {model!r}")
+        return await self._get(
+            f"/v1/models/{model}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Model,
+        )
+
+    async def list(
+        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,
+    ) -> ModelListResponse:
+        """List all the available models"""
+        return await self._get(
+            "/v1/models",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=ModelListResponse,
+        )
+
+
+class ModelsResourceWithRawResponse:
+    def __init__(self, models: ModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = to_raw_response_wrapper(
+            models.retrieve,
+        )
+        self.list = to_raw_response_wrapper(
+            models.list,
+        )
+
+
+class AsyncModelsResourceWithRawResponse:
+    def __init__(self, models: AsyncModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = async_to_raw_response_wrapper(
+            models.retrieve,
+        )
+        self.list = async_to_raw_response_wrapper(
+            models.list,
+        )
+
+
+class ModelsResourceWithStreamingResponse:
+    def __init__(self, models: ModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = to_streamed_response_wrapper(
+            models.retrieve,
+        )
+        self.list = to_streamed_response_wrapper(
+            models.list,
+        )
+
+
+class AsyncModelsResourceWithStreamingResponse:
+    def __init__(self, models: AsyncModelsResource) -> None:
+        self._models = models
+
+        self.retrieve = async_to_streamed_response_wrapper(
+            models.retrieve,
+        )
+        self.list = async_to_streamed_response_wrapper(
+            models.list,
+        )

relaxai/types/__init__.py

@@ -0,0 +1,18 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from .model import Model as Model
+from .usage import Usage as Usage
+from .function_call import FunctionCall as FunctionCall
+from .function_call_param import FunctionCallParam as FunctionCallParam
+from .model_list_response import ModelListResponse as ModelListResponse
+from .health_check_response import HealthCheckResponse as HealthCheckResponse
+from .content_filter_results import ContentFilterResults as ContentFilterResults
+from .chat_completion_message import ChatCompletionMessage as ChatCompletionMessage
+from .embedding_create_params import EmbeddingCreateParams as EmbeddingCreateParams
+from .embedding_create_response import EmbeddingCreateResponse as EmbeddingCreateResponse
+from .function_definition_param import FunctionDefinitionParam as FunctionDefinitionParam
+from .chat_completion_message_param import ChatCompletionMessageParam as ChatCompletionMessageParam
+from .chat_create_completion_params import ChatCreateCompletionParams as ChatCreateCompletionParams
+from .chat_create_completion_response import ChatCreateCompletionResponse as ChatCreateCompletionResponse

relaxai/types/chat_completion_message.py

@@ -0,0 +1,54 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .function_call import FunctionCall
+
+__all__ = ["ChatCompletionMessage", "MultiContent", "MultiContentImageURL", "ToolCall"]
+
+
+class MultiContentImageURL(BaseModel):
+    detail: Optional[str] = None
+
+    url: Optional[str] = None
+
+
+class MultiContent(BaseModel):
+    image_url: Optional[MultiContentImageURL] = None
+
+    text: Optional[str] = None
+
+    type: Optional[str] = None
+
+
+class ToolCall(BaseModel):
+    function: FunctionCall
+
+    type: str
+
+    id: Optional[str] = None
+
+    index: Optional[int] = None
+
+
+class ChatCompletionMessage(BaseModel):
+    multi_content: List[MultiContent] = FieldInfo(alias="MultiContent")
+
+    role: str
+
+    content: Optional[str] = None
+
+    function_call: Optional[FunctionCall] = None
+
+    name: Optional[str] = None
+
+    reasoning_content: Optional[str] = None
+
+    refusal: Optional[str] = None
+
+    tool_call_id: Optional[str] = None
+
+    tool_calls: Optional[List[ToolCall]] = None

relaxai/types/chat_completion_message_param.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Iterable
+from typing_extensions import Required, Annotated, TypedDict
+
+from .._utils import PropertyInfo
+from .function_call_param import FunctionCallParam
+
+__all__ = ["ChatCompletionMessageParam", "MultiContent", "MultiContentImageURL", "ToolCall"]
+
+
+class MultiContentImageURL(TypedDict, total=False):
+    detail: str
+
+    url: str
+
+
+class MultiContent(TypedDict, total=False):
+    image_url: MultiContentImageURL
+
+    text: str
+
+    type: str
+
+
+class ToolCall(TypedDict, total=False):
+    function: Required[FunctionCallParam]
+
+    type: Required[str]
+
+    id: str
+
+    index: int
+
+
+class ChatCompletionMessageParam(TypedDict, total=False):
+    multi_content: Required[Annotated[Iterable[MultiContent], PropertyInfo(alias="MultiContent")]]
+
+    role: Required[str]
+
+    content: str
+
+    function_call: FunctionCallParam
+
+    name: str
+
+    reasoning_content: str
+
+    refusal: str
+
+    tool_call_id: str
+
+    tool_calls: Iterable[ToolCall]

relaxai/types/chat_create_completion_params.py

@@ -0,0 +1,106 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Dict, List, Iterable
+from typing_extensions import Required, TypedDict
+
+from .function_definition_param import FunctionDefinitionParam
+from .chat_completion_message_param import ChatCompletionMessageParam
+
+__all__ = [
+    "ChatCreateCompletionParams",
+    "Prediction",
+    "ResponseFormat",
+    "ResponseFormatJsonSchema",
+    "StreamOptions",
+    "Tool",
+]
+
+
+class ChatCreateCompletionParams(TypedDict, total=False):
+    messages: Required[Iterable[ChatCompletionMessageParam]]
+
+    model: Required[str]
+
+    chat_template_kwargs: object
+
+    frequency_penalty: float
+
+    function_call: object
+
+    functions: Iterable[FunctionDefinitionParam]
+
+    logit_bias: Dict[str, int]
+
+    logprobs: bool
+
+    max_completion_tokens: int
+
+    max_tokens: int
+
+    metadata: Dict[str, str]
+
+    n: int
+
+    parallel_tool_calls: object
+
+    prediction: Prediction
+
+    presence_penalty: float
+
+    reasoning_effort: str
+
+    response_format: ResponseFormat
+
+    seed: int
+
+    stop: List[str]
+
+    store: bool
+
+    stream: bool
+
+    stream_options: StreamOptions
+
+    temperature: float
+
+    tool_choice: object
+
+    tools: Iterable[Tool]
+
+    top_logprobs: int
+
+    top_p: float
+
+    user: str
+
+
+class Prediction(TypedDict, total=False):
+    content: Required[str]
+
+    type: Required[str]
+
+
+class ResponseFormatJsonSchema(TypedDict, total=False):
+    name: Required[str]
+
+    strict: Required[bool]
+
+    description: str
+
+
+class ResponseFormat(TypedDict, total=False):
+    json_schema: ResponseFormatJsonSchema
+
+    type: str
+
+
+class StreamOptions(TypedDict, total=False):
+    include_usage: bool
+
+
+class Tool(TypedDict, total=False):
+    type: Required[str]
+
+    function: FunctionDefinitionParam

relaxai/types/chat_create_completion_response.py

@@ -0,0 +1,79 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Optional
+
+from pydantic import Field as FieldInfo
+
+from .usage import Usage
+from .._models import BaseModel
+from .content_filter_results import ContentFilterResults
+from .chat_completion_message import ChatCompletionMessage
+
+__all__ = [
+    "ChatCreateCompletionResponse",
+    "Choice",
+    "ChoiceLogprobs",
+    "ChoiceLogprobsContent",
+    "ChoiceLogprobsContentTopLogprob",
+    "PromptFilterResult",
+]
+
+
+class ChoiceLogprobsContentTopLogprob(BaseModel):
+    token: str
+
+    logprob: float
+
+    bytes: Optional[str] = None
+
+
+class ChoiceLogprobsContent(BaseModel):
+    token: str
+
+    logprob: float
+
+    top_logprobs: List[ChoiceLogprobsContentTopLogprob]
+
+    bytes: Optional[str] = None
+
+
+class ChoiceLogprobs(BaseModel):
+    content: List[ChoiceLogprobsContent]
+
+
+class Choice(BaseModel):
+    finish_reason: str
+
+    index: int
+
+    message: ChatCompletionMessage
+
+    content_filter_results: Optional[ContentFilterResults] = None
+
+    logprobs: Optional[ChoiceLogprobs] = None
+
+
+class PromptFilterResult(BaseModel):
+    index: int
+
+    content_filter_results: Optional[ContentFilterResults] = None
+
+
+class ChatCreateCompletionResponse(BaseModel):
+    id: str
+
+    choices: List[Choice]
+
+    created: int
+
+    http_header: Dict[str, List[str]] = FieldInfo(alias="httpHeader")
+
+    model: str
+
+    object: str
+
+    system_fingerprint: str
+
+    usage: Usage
+
+    prompt_filter_results: Optional[List[PromptFilterResult]] = None

relaxai/types/content_filter_results.py

@@ -0,0 +1,57 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["ContentFilterResults", "Hate", "Jailbreak", "Profanity", "SelfHarm", "Sexual", "Violence"]
+
+
+class Hate(BaseModel):
+    filtered: bool
+
+    severity: Optional[str] = None
+
+
+class Jailbreak(BaseModel):
+    detected: bool
+
+    filtered: bool
+
+
+class Profanity(BaseModel):
+    detected: bool
+
+    filtered: bool
+
+
+class SelfHarm(BaseModel):
+    filtered: bool
+
+    severity: Optional[str] = None
+
+
+class Sexual(BaseModel):
+    filtered: bool
+
+    severity: Optional[str] = None
+
+
+class Violence(BaseModel):
+    filtered: bool
+
+    severity: Optional[str] = None
+
+
+class ContentFilterResults(BaseModel):
+    hate: Optional[Hate] = None
+
+    jailbreak: Optional[Jailbreak] = None
+
+    profanity: Optional[Profanity] = None
+
+    self_harm: Optional[SelfHarm] = None
+
+    sexual: Optional[Sexual] = None
+
+    violence: Optional[Violence] = None

relaxai/types/embedding_create_params.py

@@ -0,0 +1,19 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["EmbeddingCreateParams"]
+
+
+class EmbeddingCreateParams(TypedDict, total=False):
+    input: Required[object]
+
+    model: Required[str]
+
+    dimensions: int
+
+    encoding_format: str
+
+    user: str

relaxai/types/embedding_create_response.py

@@ -0,0 +1,30 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List
+
+from pydantic import Field as FieldInfo
+
+from .usage import Usage
+from .._models import BaseModel
+
+__all__ = ["EmbeddingCreateResponse", "Data"]
+
+
+class Data(BaseModel):
+    embedding: List[float]
+
+    index: int
+
+    object: str
+
+
+class EmbeddingCreateResponse(BaseModel):
+    data: List[Data]
+
+    http_header: Dict[str, List[str]] = FieldInfo(alias="httpHeader")
+
+    model: str
+
+    object: str
+
+    usage: Usage

relaxai/types/function_call.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["FunctionCall"]
+
+
+class FunctionCall(BaseModel):
+    arguments: Optional[str] = None
+
+    name: Optional[str] = None

relaxai/types/function_call_param.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 TypedDict
+
+__all__ = ["FunctionCallParam"]
+
+
+class FunctionCallParam(TypedDict, total=False):
+    arguments: str
+
+    name: str

relaxai/types/function_definition_param.py

@@ -0,0 +1,17 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["FunctionDefinitionParam"]
+
+
+class FunctionDefinitionParam(TypedDict, total=False):
+    name: Required[str]
+
+    parameters: Required[object]
+
+    description: str
+
+    strict: bool

relaxai/types/health_check_response.py

@@ -0,0 +1,7 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing_extensions import TypeAlias
+
+__all__ = ["HealthCheckResponse"]
+
+HealthCheckResponse: TypeAlias = str