aimlapi-sdk-python 2.8.1b0__py3-none-any.whl

aimlapi/__init__.py

@@ -0,0 +1,243 @@
+"""AI/ML API Python SDK.
+
+Overlay on top of the official `openai` client that provides
+an AIMLAPI-specific import path and default client.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import types as _types
+from typing import Any, Mapping
+
+import httpx
+import openai as _openai
+from openai import *  # noqa: F401, F403
+from openai._base_client import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
+from openai._client import Timeout
+
+from ._client import (
+    AIMLAPI,
+    AIMLAPIWithRawResponse,
+    AIMLAPIWithStreamedResponse,
+    AsyncAIMLAPI,
+    AsyncAIMLAPIWithRawResponse,
+    AsyncAIMLAPIWithStreamedResponse,
+    AsyncAzureAIMLAPI,
+    AsyncAzureAIMLAPIWithRawResponse,
+    AsyncAzureAIMLAPIWithStreamedResponse,
+    AsyncClient,
+    AzureAIMLAPI,
+    AzureAIMLAPIWithRawResponse,
+    AzureAIMLAPIWithStreamedResponse,
+    Client,
+)
+from ._client import DEFAULT_BASE_URL
+from ._version import __title__, __version__
+
+AzureOpenAI = AzureAIMLAPI
+AsyncAzureOpenAI = AsyncAzureAIMLAPI
+AzureClient = AzureAIMLAPI
+AsyncAzureClient = AsyncAzureAIMLAPI
+
+_API_KEY_ENV_VARS = ("AIML_API_KEY", "AIMLAPI_API_KEY")
+_BASE_URL_ENV_VARS = ("AIML_API_BASE", "AIMLAPI_API_BASE")
+
+
+def _first_env(*names: str) -> str | None:
+    for name in names:
+        value = os.environ.get(name)
+        if value:
+            return value
+    return None
+
+
+api_key: str | None = _first_env(*_API_KEY_ENV_VARS)
+organization: str | None = None
+project: str | None = None
+webhook_secret: str | None = None
+base_url: str | httpx.URL | None = _first_env(*_BASE_URL_ENV_VARS) or DEFAULT_BASE_URL
+websocket_base_url: str | httpx.URL | None = None
+timeout: float | Timeout | None = DEFAULT_TIMEOUT
+max_retries: int = DEFAULT_MAX_RETRIES
+default_headers: Mapping[str, str] | None = None
+default_query: Mapping[str, object] | None = None
+http_client: httpx.Client | None = None
+
+_default_client: AIMLAPI | None = None
+
+
+def _client_kwargs() -> dict[str, Any]:
+    kwargs: dict[str, Any] = {}
+    if api_key is not None:
+        kwargs["api_key"] = api_key
+    if organization is not None:
+        kwargs["organization"] = organization
+    if project is not None:
+        kwargs["project"] = project
+    if webhook_secret is not None:
+        kwargs["webhook_secret"] = webhook_secret
+    if base_url is not None:
+        kwargs["base_url"] = base_url
+    if websocket_base_url is not None:
+        kwargs["websocket_base_url"] = websocket_base_url
+    if timeout is not None:
+        kwargs["timeout"] = timeout
+    kwargs["max_retries"] = max_retries
+    if default_headers is not None:
+        kwargs["default_headers"] = default_headers
+    if default_query is not None:
+        kwargs["default_query"] = default_query
+    if http_client is not None:
+        kwargs["http_client"] = http_client
+    return kwargs
+
+
+def _reset_default_client() -> None:
+    global _default_client
+    _default_client = None
+
+
+def _set_config_value(name: str, value: Any) -> None:
+    globals()[name] = value
+    _reset_default_client()
+
+
+def _get_default_client() -> AIMLAPI:
+    global _default_client
+    if _default_client is None:
+        _default_client = AIMLAPI(**_client_kwargs())
+    return _default_client
+
+
+_openai_all = getattr(_openai, "__all__", None)
+if _openai_all is None:
+    _openai_all = [name for name in dir(_openai) if not name.startswith("_")]
+
+__all__ = list(
+    dict.fromkeys(
+        [
+            *_openai_all,
+            "__title__",
+            "__version__",
+            "AIMLAPI",
+            "AsyncAIMLAPI",
+            "AIMLAPIWithRawResponse",
+            "AsyncAIMLAPIWithRawResponse",
+            "AIMLAPIWithStreamedResponse",
+            "AsyncAIMLAPIWithStreamedResponse",
+            "Client",
+            "AsyncClient",
+            "AzureAIMLAPI",
+            "AsyncAzureAIMLAPI",
+            "AzureAIMLAPIWithRawResponse",
+            "AsyncAzureAIMLAPIWithRawResponse",
+            "AzureAIMLAPIWithStreamedResponse",
+            "AsyncAzureAIMLAPIWithStreamedResponse",
+            "AzureOpenAI",
+            "AsyncAzureOpenAI",
+            "AzureClient",
+            "AsyncAzureClient",
+            "api_key",
+            "organization",
+            "project",
+            "webhook_secret",
+            "base_url",
+            "websocket_base_url",
+            "timeout",
+            "max_retries",
+            "default_headers",
+            "default_query",
+            "http_client",
+        ]
+    )
+)
+
+
+def __dir__() -> list[str]:
+    return sorted(set(__all__))
+
+
+def __getattr__(name: str) -> Any:
+    if hasattr(_openai, name):
+        return getattr(_openai, name)
+
+    client = _get_default_client()
+    if hasattr(client, name):
+        return getattr(client, name)
+
+    raise AttributeError(f"module 'aimlapi' has no attribute {name!r}")
+
+
+_RESOURCE_PROXY_NAMES = (
+    "audio",
+    "beta",
+    "batches",
+    "chat",
+    "completions",
+    "containers",
+    "conversations",
+    "embeddings",
+    "evals",
+    "files",
+    "fine_tuning",
+    "images",
+    "models",
+    "moderations",
+    "realtime",
+    "responses",
+    "uploads",
+    "vector_stores",
+    "videos",
+    "webhooks",
+)
+
+_CONFIG_ATTRS = {
+    "api_key",
+    "organization",
+    "project",
+    "webhook_secret",
+    "base_url",
+    "websocket_base_url",
+    "timeout",
+    "max_retries",
+    "default_headers",
+    "default_query",
+    "http_client",
+}
+
+
+class _AIMLAPIModule(_types.ModuleType):
+    def __setattr__(self, name: str, value: Any) -> None:  # type: ignore[override]
+        if name in _CONFIG_ATTRS:
+            _set_config_value(name, value)
+        super().__setattr__(name, value)
+
+
+_module = sys.modules[__name__]
+if not isinstance(_module, _AIMLAPIModule):
+    _module.__class__ = _AIMLAPIModule
+
+
+class _ModuleResourceProxy:
+    __slots__ = ("_attr",)
+
+    def __init__(self, attr: str) -> None:
+        self._attr = attr
+
+    def __getattr__(self, name: str) -> Any:
+        resource = getattr(_get_default_client(), self._attr)
+        return getattr(resource, name)
+
+    def __repr__(self) -> str:
+        resource = getattr(_get_default_client(), self._attr)
+        return repr(resource)
+
+    def __dir__(self) -> list[str]:
+        resource = getattr(_get_default_client(), self._attr)
+        return sorted(set(dir(resource)))
+
+
+for _resource_name in _RESOURCE_PROXY_NAMES:
+    globals()[_resource_name] = _ModuleResourceProxy(_resource_name)

aimlapi/__main__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai.__main__ import *  # noqa: F401, F403

aimlapi/_client.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+import os
+from collections.abc import MutableMapping, Sequence
+from typing import Any, TYPE_CHECKING
+
+from typing_extensions import override
+
+from openai._client import (
+    OpenAI as _OpenAI,
+    AsyncOpenAI as _AsyncOpenAI,
+    OpenAIWithRawResponse as _OpenAIWithRawResponse,
+    AsyncOpenAIWithRawResponse as _AsyncOpenAIWithRawResponse,
+    OpenAIWithStreamedResponse as _OpenAIWithStreamedResponse,
+    AsyncOpenAIWithStreamedResponse as _AsyncOpenAIWithStreamedResponse,
+)
+from openai._models import FinalRequestOptions
+from openai._compat import cached_property
+from openai.lib.azure import AzureOpenAI as _AzureOpenAI, AsyncAzureOpenAI as _AsyncAzureOpenAI
+
+if TYPE_CHECKING:
+    from .resources.audio import Audio as _AimlAudio, AsyncAudio as _AimlAsyncAudio
+    from .resources.chat import Chat as _AimlChat, AsyncChat as _AimlAsyncChat
+    from .resources.images import Images as _AimlImages, AsyncImages as _AimlAsyncImages
+    from .resources.uploads import Uploads as _AimlUploads, AsyncUploads as _AimlAsyncUploads
+    from .resources.videos import Videos as _AimlVideos, AsyncVideos as _AimlAsyncVideos
+
+DEFAULT_BASE_URL = "https://api.aimlapi.com/v1"
+AZURE_DEFAULT_BASE_URL = "https://api.aimlapi.com/openai/"
+_API_KEY_ENV_VARS = ("AIML_API_KEY", "AIMLAPI_API_KEY")
+_BASE_URL_ENV_VARS = ("AIML_API_BASE", "AIMLAPI_API_BASE")
+AIMLAPI_HEADERS: dict[str, str] = {
+    "HTTP-Referer": "github.com/aimlapi/api-sdk-python",
+    "X-Title": "AI/ML API Python SDK (OpenAI)",
+}
+
+
+def _first_env(*names: str) -> str | None:
+    for name in names:
+        value = os.environ.get(name)
+        if value:
+            return value
+    return None
+
+
+def _apply_default_client_options(
+    kwargs: dict[str, Any],
+    *,
+    include_base_url: bool = True,
+    default_base_url: str = DEFAULT_BASE_URL,
+) -> None:
+    if kwargs.get("api_key") is None:
+        api_key = _first_env(*_API_KEY_ENV_VARS)
+        if api_key is not None:
+            kwargs["api_key"] = api_key
+
+    if include_base_url and kwargs.get("base_url") is None:
+        base_url = _first_env(*_BASE_URL_ENV_VARS) or default_base_url
+        kwargs["base_url"] = base_url
+
+    default_headers = kwargs.get("default_headers") or {}
+    kwargs["default_headers"] = {**default_headers, **AIMLAPI_HEADERS}
+
+
+def _scrub_schema_fields(value: object) -> None:
+    if isinstance(value, MutableMapping):
+        value.pop("title", None)
+        value.pop("$defs", None)
+        for child in value.values():
+            _scrub_schema_fields(child)
+        return
+
+    if isinstance(value, list):
+        for item in value:
+            _scrub_schema_fields(item)
+
+
+def _clean_tool_schemas(payload: object) -> None:
+    if not isinstance(payload, MutableMapping):
+        return
+
+    tools = payload.get("tools")
+    if not isinstance(tools, Sequence) or isinstance(tools, (str, bytes, bytearray)):
+        return
+
+    for tool in tools:
+        if not isinstance(tool, MutableMapping):
+            continue
+        function = tool.get("function")
+        if not isinstance(function, MutableMapping):
+            continue
+        function.pop("strict", None)
+
+        parameters = function.get("parameters")
+        if parameters is not None:
+            _scrub_schema_fields(parameters)
+
+
+def _prepare_tool_schemas(options: FinalRequestOptions) -> None:
+    _clean_tool_schemas(options.json_data)
+
+
+class _ToolSchemaCleanupMixin:
+    """Shared cleanup hook for AIMLAPI clients."""
+
+    @staticmethod
+    def _cleanup_request(options: FinalRequestOptions) -> None:
+        _prepare_tool_schemas(options)
+
+
+class AIMLAPI(_ToolSchemaCleanupMixin, _OpenAI):
+    """Synchronous client for the AIML API."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        _apply_default_client_options(kwargs)
+        super().__init__(*args, **kwargs)
+
+    @override
+    def _build_request(self, options: FinalRequestOptions, *, retries_taken: int = 0):
+        self._cleanup_request(options)
+        return super()._build_request(options, retries_taken=retries_taken)
+
+    @cached_property
+    def chat(self) -> "_AimlChat":
+        from .resources.chat import Chat as _AimlChatImpl
+
+        return _AimlChatImpl(self)
+
+    @cached_property
+    def responses(self):  # type: ignore[override]
+        from .resources.responses import Responses as _AimlResponsesImpl
+
+        return _AimlResponsesImpl(self)
+
+    @cached_property
+    def audio(self) -> "_AimlAudio":
+        from .resources.audio import Audio as _AimlAudioImpl
+
+        return _AimlAudioImpl(self)
+
+    @cached_property
+    def images(self) -> "_AimlImages":  # type: ignore[override]
+        from .resources.images import Images as _AimlImagesImpl
+
+        return _AimlImagesImpl(self)
+
+    @cached_property
+    def uploads(self) -> "_AimlUploads":
+        from .resources.uploads import Uploads as _AimlUploadsImpl
+
+        return _AimlUploadsImpl(self)
+
+    @cached_property
+    def videos(self) -> "_AimlVideos":
+        from .resources.videos import Videos as _AimlVideosImpl
+
+        return _AimlVideosImpl(self)
+
+
+class AsyncAIMLAPI(_ToolSchemaCleanupMixin, _AsyncOpenAI):
+    """Asynchronous client for the AIML API."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        _apply_default_client_options(kwargs)
+        super().__init__(*args, **kwargs)
+
+    @override
+    def _build_request(self, options: FinalRequestOptions, *, retries_taken: int = 0):
+        self._cleanup_request(options)
+        return super()._build_request(options, retries_taken=retries_taken)
+
+    @cached_property
+    def chat(self) -> "_AimlAsyncChat":
+        from .resources.chat import AsyncChat as _AimlAsyncChatImpl
+
+        return _AimlAsyncChatImpl(self)
+
+    @cached_property
+    def responses(self):  # type: ignore[override]
+        from .resources.responses import AsyncResponses as _AimlAsyncResponsesImpl
+
+        return _AimlAsyncResponsesImpl(self)
+
+    @cached_property
+    def audio(self) -> "_AimlAsyncAudio":
+        from .resources.audio import AsyncAudio as _AimlAsyncAudioImpl
+
+        return _AimlAsyncAudioImpl(self)
+
+    @cached_property
+    def images(self) -> "_AimlAsyncImages":  # type: ignore[override]
+        from .resources.images import AsyncImages as _AimlAsyncImagesImpl
+
+        return _AimlAsyncImagesImpl(self)
+
+    @cached_property
+    def uploads(self) -> "_AimlAsyncUploads":
+        from .resources.uploads import AsyncUploads as _AimlAsyncUploadsImpl
+
+        return _AimlAsyncUploadsImpl(self)
+
+    @cached_property
+    def videos(self) -> "_AimlAsyncVideos":
+        from .resources.videos import AsyncVideos as _AimlAsyncVideosImpl
+
+        return _AimlAsyncVideosImpl(self)
+
+
+class AzureAIMLAPI(_ToolSchemaCleanupMixin, _AzureOpenAI):
+    """Synchronous Azure client with AIMLAPI overrides."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        include_base_url = kwargs.get("azure_endpoint") is None
+        _apply_default_client_options(
+            kwargs,
+            include_base_url=include_base_url,
+            default_base_url=AZURE_DEFAULT_BASE_URL,
+        )
+        super().__init__(*args, **kwargs)
+
+    @override
+    def _build_request(self, options: FinalRequestOptions, *, retries_taken: int = 0):
+        self._cleanup_request(options)
+        return super()._build_request(options, retries_taken=retries_taken)
+
+    @cached_property
+    def chat(self) -> "_AimlChat":
+        from .resources.chat import Chat as _AimlChatImpl
+
+        return _AimlChatImpl(self)
+
+    @cached_property
+    def audio(self) -> "_AimlAudio":
+        from .resources.audio import Audio as _AimlAudioImpl
+
+        return _AimlAudioImpl(self)
+
+    @cached_property
+    def images(self) -> "_AimlImages":  # type: ignore[override]
+        from .resources.images import Images as _AimlImagesImpl
+
+        return _AimlImagesImpl(self)
+
+    @cached_property
+    def uploads(self) -> "_AimlUploads":
+        from .resources.uploads import Uploads as _AimlUploadsImpl
+
+        return _AimlUploadsImpl(self)
+
+    @cached_property
+    def videos(self) -> "_AimlVideos":
+        from .resources.videos import Videos as _AimlVideosImpl
+
+        return _AimlVideosImpl(self)
+
+
+class AsyncAzureAIMLAPI(_ToolSchemaCleanupMixin, _AsyncAzureOpenAI):
+    """Asynchronous Azure client with AIMLAPI overrides."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        include_base_url = kwargs.get("azure_endpoint") is None
+        _apply_default_client_options(
+            kwargs,
+            include_base_url=include_base_url,
+            default_base_url=AZURE_DEFAULT_BASE_URL,
+        )
+        super().__init__(*args, **kwargs)
+
+    @override
+    def _build_request(self, options: FinalRequestOptions, *, retries_taken: int = 0):
+        self._cleanup_request(options)
+        return super()._build_request(options, retries_taken=retries_taken)
+
+    @cached_property
+    def chat(self) -> "_AimlAsyncChat":
+        from .resources.chat import AsyncChat as _AimlAsyncChatImpl
+
+        return _AimlAsyncChatImpl(self)
+
+    @cached_property
+    def audio(self) -> "_AimlAsyncAudio":
+        from .resources.audio import AsyncAudio as _AimlAsyncAudioImpl
+
+        return _AimlAsyncAudioImpl(self)
+
+    @cached_property
+    def images(self) -> "_AimlAsyncImages":  # type: ignore[override]
+        from .resources.images import AsyncImages as _AimlAsyncImagesImpl
+
+        return _AimlAsyncImagesImpl(self)
+
+    @cached_property
+    def uploads(self) -> "_AimlAsyncUploads":
+        from .resources.uploads import AsyncUploads as _AimlAsyncUploadsImpl
+
+        return _AimlAsyncUploadsImpl(self)
+
+    @cached_property
+    def videos(self) -> "_AimlAsyncVideos":
+        from .resources.videos import AsyncVideos as _AimlAsyncVideosImpl
+
+        return _AimlAsyncVideosImpl(self)
+
+
+class AIMLAPIWithRawResponse(_OpenAIWithRawResponse):
+    _client: AIMLAPI
+
+    def __init__(self, client: AIMLAPI) -> None:
+        super().__init__(client)
+
+
+class AsyncAIMLAPIWithRawResponse(_AsyncOpenAIWithRawResponse):
+    _client: AsyncAIMLAPI
+
+    def __init__(self, client: AsyncAIMLAPI) -> None:
+        super().__init__(client)
+
+
+class AIMLAPIWithStreamedResponse(_OpenAIWithStreamedResponse):
+    _client: AIMLAPI
+
+    def __init__(self, client: AIMLAPI) -> None:
+        super().__init__(client)
+
+
+class AsyncAIMLAPIWithStreamedResponse(_AsyncOpenAIWithStreamedResponse):
+    _client: AsyncAIMLAPI
+
+    def __init__(self, client: AsyncAIMLAPI) -> None:
+        super().__init__(client)
+
+
+class AzureAIMLAPIWithRawResponse(_OpenAIWithRawResponse):
+    _client: AzureAIMLAPI
+
+    def __init__(self, client: AzureAIMLAPI) -> None:
+        super().__init__(client)
+
+
+class AsyncAzureAIMLAPIWithRawResponse(_AsyncOpenAIWithRawResponse):
+    _client: AsyncAzureAIMLAPI
+
+    def __init__(self, client: AsyncAzureAIMLAPI) -> None:
+        super().__init__(client)
+
+
+class AzureAIMLAPIWithStreamedResponse(_OpenAIWithStreamedResponse):
+    _client: AzureAIMLAPI
+
+    def __init__(self, client: AzureAIMLAPI) -> None:
+        super().__init__(client)
+
+
+class AsyncAzureAIMLAPIWithStreamedResponse(_AsyncOpenAIWithStreamedResponse):
+    _client: AsyncAzureAIMLAPI
+
+    def __init__(self, client: AsyncAzureAIMLAPI) -> None:
+        super().__init__(client)
+
+
+Client = AIMLAPI
+AsyncClient = AsyncAIMLAPI
+
+# Backwards-compatible aliases.
+OpenAI = AIMLAPI
+AsyncOpenAI = AsyncAIMLAPI
+AzureOpenAI = AzureAIMLAPI
+AsyncAzureOpenAI = AsyncAzureAIMLAPI

aimlapi/_utils/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils import *  # noqa: F401, F403

aimlapi/_utils/_compat.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._compat import *  # noqa: F401, F403

aimlapi/_utils/_datetime_parse.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._datetime_parse import *  # noqa: F401, F403

aimlapi/_utils/_logs.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._logs import *  # noqa: F401, F403

aimlapi/_utils/_proxy.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._proxy import *  # noqa: F401, F403

aimlapi/_utils/_reflection.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._reflection import *  # noqa: F401, F403

aimlapi/_utils/_resources_proxy.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._resources_proxy import *  # noqa: F401, F403

aimlapi/_utils/_streams.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._streams import *  # noqa: F401, F403

aimlapi/_utils/_sync.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._sync import *  # noqa: F401, F403

aimlapi/_utils/_transform.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._transform import *  # noqa: F401, F403

aimlapi/_utils/_typing.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._typing import *  # noqa: F401, F403

aimlapi/_utils/_utils.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai._utils._utils import *  # noqa: F401, F403

aimlapi/_version.py

@@ -0,0 +1,9 @@
+"""
+Version information for the AI/ML API package.
+
+This project is a fork of the OpenAI Python SDK, and the __version__
+value follows the same versioning scheme for compatibility.
+"""
+
+__title__ = "aimlapi"
+__version__ = "2.8.1"  # x-release-please-version

aimlapi/cli/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai.cli import *  # noqa: F401, F403

aimlapi/cli/_api/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai.cli._api import *  # noqa: F401, F403

aimlapi/cli/_api/_main.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from openai.cli._api._main import *  # noqa: F401, F403