ogx_open_client 1.0.3.dev0__py3-none-any.whl

ogx_client/ogx_client.py

@@ -0,0 +1,309 @@
+# coding: utf-8
+
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+"""
+    OGX Specification - Stable & Experimental APIs
+
+    This is the specification of the OGX that provides                     a set of endpoints and their corresponding interfaces that are     tailored to                     best leverage Llama Models.      **🔗 COMBINED**: This specification includes both stable production-ready APIs     and experimental pre-release APIs. Use stable APIs for production deployments     and experimental APIs for testing new features.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import httpx
+import json
+
+from typing import Any, Mapping
+from ._version import __version__
+
+from ogx_client.api_client import ApiClient
+from ogx_client.async_api_client import AsyncApiClient
+from ogx_client.configuration import Configuration
+from ogx_client.api.admin_api import AdminApi
+from ogx_client.api.alpha_api import AlphaApi
+from ogx_client.api.batches_api import BatchesApi
+from ogx_client.api.chat_api import ChatApi
+from ogx_client.api.chat_completions_api import ChatCompletionsApi
+from ogx_client.api.completions_api import CompletionsApi
+from ogx_client.api.connectors_api import ConnectorsApi
+from ogx_client.api.conversations_api import ConversationsApi
+from ogx_client.api.embeddings_api import EmbeddingsApi
+from ogx_client.api.file_batches_api import FileBatchesApi
+from ogx_client.api.file_processors_api import FileProcessorsApi
+from ogx_client.api.files_api import FilesApi
+from ogx_client.api.inference_api import InferenceApi
+from ogx_client.api.input_items_api import InputItemsApi
+from ogx_client.api.inspect_api import InspectApi
+from ogx_client.api.interactions_api import InteractionsApi
+from ogx_client.api.items_api import ItemsApi
+from ogx_client.api.messages_api import MessagesApi
+from ogx_client.api.models_api import ModelsApi
+from ogx_client.api.openai_api import OpenaiApi
+from ogx_client.api.prompts_api import PromptsApi
+from ogx_client.api.providers_api import ProvidersApi
+from ogx_client.api.responses_api import ResponsesApi
+from ogx_client.api.routes_api import RoutesApi
+from ogx_client.api.tools_api import ToolsApi
+from ogx_client.api.vector_io_api import VectorIoApi
+from ogx_client.api.vector_stores_api import VectorStoresApi
+from ogx_client.api.vector_stores_files_api import VectorStoresFilesApi
+from ogx_client.api.versions_api import VersionsApi
+
+
+
+class OgxClient:
+    """
+    OGX unified client that provides access to all API endpoints.
+
+    This client creates instances of all available API classes and provides
+    them as attributes for easy access.
+
+    Example:
+        >>> from ogx_client import Configuration, OgxClient
+        >>>
+        >>> config = Configuration(host="http://localhost:8000")
+        >>> client = OgxClient(config)
+        >>>
+        >>> # Access specific APIs through the client
+        >>> client.admin  # Access AdminApi
+        
+    """
+
+    def __init__(
+        self,
+        configuration: Configuration | None = None,
+        header_name: str | None = None,
+        header_value: str | None = None,
+        cookie: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        provider_data: Mapping[str, Any] | None = None,
+        **kwargs,
+    ) -> None:
+        """
+        Initialize the OgxClient.
+
+        Args:
+            configuration: Configuration object or string URL. If string, creates Configuration with that host.
+                          If None, uses default configuration.
+            header_name: Optional header name for authentication.
+            header_value: Optional header value for authentication.
+            cookie: Optional cookie string for authentication.
+        """
+        # Handle string URL as configuration
+        if isinstance(configuration, str):
+            configuration = Configuration(host=configuration)
+        elif configuration is None:
+            if kwargs is not None and kwargs != {}:
+                configuration = Configuration(**kwargs)
+            else:
+                configuration = Configuration.get_default_copy()
+
+        self.configuration = configuration
+        self.base_url = self.configuration.base_url
+
+        # Create the API client
+        self.api_client = ApiClient(
+            configuration=configuration,
+            header_name=header_name,
+            header_value=header_value,
+            cookie=cookie,
+        )
+
+        # Store reference to parent client for _prepare_request hook
+        self.api_client._parent_client = self
+        if hasattr(self.api_client, 'rest_client'):
+            self.api_client.rest_client._parent_client = self
+        elif hasattr(self.api_client, '_client'):
+            self.api_client._client._parent_client = self
+
+        # Compatibility with stainless
+        custom_headers = default_headers or {}
+        custom_headers["X-OGX-Client-Version"] = __version__
+        if provider_data is not None:
+            custom_headers["X-OGX-Provider-Data"] = json.dumps(provider_data)
+
+        for header_k, header_v in custom_headers.items():
+            self.api_client.set_default_header(header_k, header_v)
+
+        # Initialize all API instances
+        self.admin = AdminApi(self.api_client)
+        self.alpha = AlphaApi(self.api_client)
+        self.batches = BatchesApi(self.api_client)
+        self.chat = ChatApi(self.api_client)
+        self.chat_completions = ChatCompletionsApi(self.api_client)
+        self.completions = CompletionsApi(self.api_client)
+        self.connectors = ConnectorsApi(self.api_client)
+        self.conversations = ConversationsApi(self.api_client)
+        self.embeddings = EmbeddingsApi(self.api_client)
+        self.file_batches = FileBatchesApi(self.api_client)
+        self.file_processors = FileProcessorsApi(self.api_client)
+        self.files = FilesApi(self.api_client)
+        self.inference = InferenceApi(self.api_client)
+        self.input_items = InputItemsApi(self.api_client)
+        self.inspect = InspectApi(self.api_client)
+        self.interactions = InteractionsApi(self.api_client)
+        self.items = ItemsApi(self.api_client)
+        self.messages = MessagesApi(self.api_client)
+        self.models = ModelsApi(self.api_client)
+        self.openai = OpenaiApi(self.api_client)
+        self.prompts = PromptsApi(self.api_client)
+        self.providers = ProvidersApi(self.api_client)
+        self.responses = ResponsesApi(self.api_client)
+        self.routes = RoutesApi(self.api_client)
+        self.tools = ToolsApi(self.api_client)
+        self.vector_io = VectorIoApi(self.api_client)
+        self.vector_stores = VectorStoresApi(self.api_client)
+        self.vector_stores_files = VectorStoresFilesApi(self.api_client)
+        self.versions = VersionsApi(self.api_client)
+
+        # Nested API structure
+        # Wire up parent-child API relationships
+        self.chat.chat_completions = self.chat_completions
+        self.chat.__dict__['completions'] = self.chat_completions
+        self.chat_completions.messages = self.messages
+        self.conversations.items = self.items
+        self.models.openai = self.openai
+        self.prompts.versions = self.versions
+        self.responses.input_items = self.input_items
+        self.vector_stores.file_batches = self.file_batches
+        self.vector_stores.vector_stores_files = self.vector_stores_files
+        self.vector_stores.__dict__['files'] = self.vector_stores_files
+        self.alpha.inference = self.inference
+        self.alpha.admin = self.admin
+        self.admin.connectors = self.connectors
+
+    def __enter__(self):
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Context manager exit."""
+        self.close()
+
+    def close(self):
+        """Close the API client and release resources."""
+        if hasattr(self, 'api_client'):
+            self.api_client.close()
+
+    def _prepare_request(self, request: httpx.Request) -> None:
+        return None
+
+
+class AsyncOgxClient:
+    """
+    Async OGX unified client that provides access to all API endpoints.
+
+    This async client creates instances of all available API classes and provides
+    them as attributes for easy access with async/await support.
+
+    Example:
+        >>> from ogx_client import Configuration, AsyncOgxClient
+        >>>
+        >>> config = Configuration(host="http://localhost:8000")
+        >>> async with AsyncOgxClient(config) as client:
+        >>>     # Access specific APIs through the client
+        >>>     await client.admin.some_method()  # Access AdminApi
+        
+    """
+
+    def __init__(
+        self,
+        configuration: Configuration | None = None,
+        header_name: str | None = None,
+        header_value: str | None = None,
+        cookie: str | None = None,
+        **kwargs,
+    ) -> None:
+        """
+        Initialize the AsyncOgxClient.
+
+        Args:
+            configuration: Configuration object or string URL. If string, creates Configuration with that host.
+                          If None, uses default configuration.
+            header_name: Optional header name for authentication.
+            header_value: Optional header value for authentication.
+            cookie: Optional cookie string for authentication.
+        """
+        # Handle string URL as configuration
+        if isinstance(configuration, str):
+            configuration = Configuration(host=configuration)
+        elif configuration is None:
+            if kwargs is not None and kwargs != {}:
+                configuration = Configuration(**kwargs)
+            else:
+                configuration = Configuration.get_default_copy()
+
+        self.configuration = configuration
+
+        # Create the async API client
+        self.api_client = AsyncApiClient(
+            configuration=configuration,
+            header_name=header_name,
+            header_value=header_value,
+            cookie=cookie,
+        )
+
+        # Store reference to parent client for _prepare_request hook
+        self.api_client._parent_client = self
+        if hasattr(self.api_client, 'rest_client'):
+            self.api_client.rest_client._parent_client = self
+        elif hasattr(self.api_client, '_client'):
+            self.api_client._client._parent_client = self
+
+        # Initialize all API instances
+        self.admin = AdminApi(self.api_client)
+        self.alpha = AlphaApi(self.api_client)
+        self.batches = BatchesApi(self.api_client)
+        self.chat = ChatApi(self.api_client)
+        self.chat_completions = ChatCompletionsApi(self.api_client)
+        self.completions = CompletionsApi(self.api_client)
+        self.connectors = ConnectorsApi(self.api_client)
+        self.conversations = ConversationsApi(self.api_client)
+        self.embeddings = EmbeddingsApi(self.api_client)
+        self.file_batches = FileBatchesApi(self.api_client)
+        self.file_processors = FileProcessorsApi(self.api_client)
+        self.files = FilesApi(self.api_client)
+        self.inference = InferenceApi(self.api_client)
+        self.input_items = InputItemsApi(self.api_client)
+        self.inspect = InspectApi(self.api_client)
+        self.interactions = InteractionsApi(self.api_client)
+        self.items = ItemsApi(self.api_client)
+        self.messages = MessagesApi(self.api_client)
+        self.models = ModelsApi(self.api_client)
+        self.openai = OpenaiApi(self.api_client)
+        self.prompts = PromptsApi(self.api_client)
+        self.providers = ProvidersApi(self.api_client)
+        self.responses = ResponsesApi(self.api_client)
+        self.routes = RoutesApi(self.api_client)
+        self.tools = ToolsApi(self.api_client)
+        self.vector_io = VectorIoApi(self.api_client)
+        self.vector_stores = VectorStoresApi(self.api_client)
+        self.vector_stores_files = VectorStoresFilesApi(self.api_client)
+        self.versions = VersionsApi(self.api_client)
+
+        # Nested API structure
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        """Async context manager exit."""
+        await self.close()
+
+    async def close(self):
+        """Close the async API client and release resources."""
+        if hasattr(self, 'api_client'):
+            await self.api_client.close()
+
+    async def _prepare_request(self, request: httpx.Request) -> None:
+        return None

ogx_client/rest.py

@@ -0,0 +1,255 @@
+# coding: utf-8
+
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+"""
+    OGX Specification - Stable & Experimental APIs
+
+    This is the specification of the OGX that provides                     a set of endpoints and their corresponding interfaces that are     tailored to                     best leverage Llama Models.      **🔗 COMBINED**: This specification includes both stable production-ready APIs     and experimental pre-release APIs. Use stable APIs for production deployments     and experimental APIs for testing new features.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+from __future__ import annotations
+
+import io
+import json
+import logging
+import re
+import ssl
+
+import httpx
+
+from ogx_client.exceptions import ApiException, ApiValueError
+
+logger = logging.getLogger(__name__)
+
+RESTResponseType = httpx.Response
+
+
+class RESTResponse(io.IOBase):
+
+    def __init__(self, resp) -> None:
+        self.response = resp
+        self.status = resp.status_code
+        self.reason = resp.reason_phrase
+        self.data = None
+
+    def read(self):
+        if self.data is None:
+            self.data = self.response.read()
+        return self.data
+
+    def getheaders(self):
+        """Returns a dictionary of the response headers."""
+        return self.response.headers
+
+    def getheader(self, name, default=None):
+        """Returns a given response header."""
+        return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+    def __init__(self, configuration) -> None:
+        self.configuration = configuration
+        self._client: httpx.Client | None = None
+
+        # Build SSL context
+        self.ssl_context = ssl.create_default_context(
+            cafile=configuration.ssl_ca_cert,
+            cadata=configuration.ca_cert_data,
+        )
+        if configuration.cert_file:
+            self.ssl_context.load_cert_chain(
+                configuration.cert_file, keyfile=configuration.key_file
+            )
+        if not configuration.verify_ssl:
+            self.ssl_context.check_hostname = False
+            self.ssl_context.verify_mode = ssl.CERT_NONE
+
+    def _create_client(self) -> httpx.Client:
+        """Create and configure httpx.Client instance."""
+        limits = httpx.Limits(
+            max_connections=self.configuration.connection_pool_maxsize
+        )
+
+        # Default timeout from config or 5 minutes
+        timeout = self.configuration.timeout if self.configuration.timeout is not None else 5 * 60
+
+        # Get http2 setting, default to False if not present
+        http2 = getattr(self.configuration, 'http2', False)
+
+        # Build proxy object with headers if configured
+        proxy = None
+        if self.configuration.proxy:
+            proxy = httpx.Proxy(
+                url=self.configuration.proxy,
+                headers=self.configuration.proxy_headers
+            )
+
+        # Wire retries to transport if configured
+        transport = None
+        if self.configuration.retries is not None:
+            transport = httpx.HTTPTransport(retries=self.configuration.retries)
+
+        try:
+            return httpx.Client(
+                limits=limits,
+                verify=self.ssl_context,
+                proxy=proxy,
+                transport=transport,
+                http2=http2,
+                timeout=timeout,
+                trust_env=True,
+                follow_redirects=getattr(self.configuration, 'follow_redirects', True),
+            )
+        except ImportError:
+            if http2:
+                raise ImportError(
+                    "HTTP/2 support requires the 'h2' package. "
+                    "Install it with: pip install h2"
+                )
+            raise
+
+    @property
+    def client(self) -> httpx.Client:
+        """Lazy initialization of httpx.Client."""
+        if self._client is None:
+            self._client = self._create_client()
+        return self._client
+
+    def close(self):
+        """Close the HTTP client and release resources."""
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+
+    def request(
+        self,
+        method,
+        url,
+        headers=None,
+        body=None,
+        post_params=None,
+        _request_timeout=None
+    ):
+        """Perform requests.
+
+        :param method: http request method
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body, for `application/json`
+        :param post_params: request post parameters,
+                            `application/x-www-form-urlencoded`
+                            and `multipart/form-data`
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        """
+        method = method.upper()
+        assert method in [
+            'GET',
+            'HEAD',
+            'DELETE',
+            'POST',
+            'PUT',
+            'PATCH',
+            'OPTIONS'
+        ]
+
+        if post_params and body:
+            raise ApiValueError(
+                "body parameter cannot be used with post_params parameter."
+            )
+
+        post_params = post_params or {}
+        headers = headers or {}
+
+        # Build request arguments
+        args = {
+            "method": method,
+            "url": url,
+            "headers": headers,
+        }
+
+        # Handle timeout
+        if _request_timeout is not None:
+            if isinstance(_request_timeout, (int, float)):
+                args["timeout"] = _request_timeout
+            elif isinstance(_request_timeout, tuple) and len(_request_timeout) == 2:
+                # httpx supports tuple timeout as (connect, read/write/pool)
+                args["timeout"] = httpx.Timeout(connect=_request_timeout[0], read=_request_timeout[1])
+
+        # Handle different content types
+        if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+            content_type = headers.get('Content-Type', '')
+
+            if not content_type or re.search('json', content_type, re.IGNORECASE):
+                # JSON content
+                if 'Content-Type' not in headers:
+                    headers['Content-Type'] = 'application/json'
+                if body is not None:
+                    args["json"] = body
+            elif content_type == 'application/x-www-form-urlencoded':
+                # Form-encoded
+                args["data"] = dict(post_params)
+            elif content_type == 'multipart/form-data':
+                # Multipart - let httpx set Content-Type with boundary
+                del headers['Content-Type']
+
+                files = []
+                data = {}
+                for param in post_params:
+                    k, v = param
+                    if isinstance(v, tuple) and len(v) == 3:
+                        # File tuple: (filename, file_content, content_type)
+                        files.append((k, v))
+                    else:
+                        # Regular field
+                        if isinstance(v, dict):
+                            v = json.dumps(v)
+                        elif isinstance(v, int):
+                            v = str(v)
+                        data[k] = v
+
+                if files:
+                    args["files"] = files
+                if data:
+                    args["data"] = data
+            elif isinstance(body, (str, bytes)):
+                # Raw body content
+                args["content"] = body
+            elif content_type.startswith('text/') and isinstance(body, bool):
+                # Boolean as text
+                request_body = "true" if body else "false"
+                args["content"] = request_body
+            else:
+                msg = """Cannot prepare a request message for provided
+                         arguments. Please check that your arguments match
+                         declared content type."""
+                raise ApiException(status=0, reason=msg)
+
+        request = self.client.build_request(**args)
+
+        # Call _prepare_request hook if parent client has it
+        if hasattr(self, '_parent_client') and self._parent_client is not None:
+            if hasattr(self._parent_client, '_prepare_request'):
+                self._parent_client._prepare_request(request)
+
+        try:
+            r = self.client.send(request, stream=True)
+        except httpx.HTTPStatusError as e:
+            raise ApiException(status=e.response.status_code, reason=str(e))
+        except httpx.RequestError as e:
+            raise ApiException(status=0, reason=str(e))
+
+        return RESTResponse(r)