ogx_open_client 1.0.3.dev0__py3-none-any.whl

ogx_client/api_response.py

@@ -0,0 +1,21 @@
+"""API response object."""
+
+from __future__ import annotations
+from typing import Generic, Mapping, TypeVar
+from pydantic import Field, StrictInt, StrictBytes, BaseModel
+
+T = TypeVar("T")
+
+class ApiResponse(BaseModel, Generic[T]):
+    """
+    API response object
+    """
+
+    status_code: StrictInt = Field(description="HTTP status code")
+    headers: Mapping[str, str] | None = Field(None, description="HTTP headers")
+    data: T = Field(description="Deserialized data given the data type")
+    raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }

ogx_client/async_api_client.py

@@ -0,0 +1,203 @@
+# 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 asyncio
+
+from typing import Any
+import httpx
+from httpx import AsyncClient, Timeout
+
+from ogx_client.configuration import Configuration
+from ogx_client.async_api_response import AsyncApiResponse
+from ogx_client.async_stream import AsyncStream
+from ogx_client.exceptions import ApiException
+
+
+class AsyncApiClient:
+    """Async API client for OpenAPI client library builds.
+
+    This client handles asynchronous client-server communication using httpx.
+
+    :param configuration: Configuration object for this client
+    :param http_client: Optional httpx.AsyncClient instance
+    :param header_name: Optional header to pass when making calls to the API
+    :param header_value: Optional header value to pass when making calls to the API
+    :param cookie: Optional cookie to include in the header when making calls to the API
+    """
+
+    def __init__(
+        self,
+        configuration: Configuration | None = None,
+        http_client: AsyncClient | None = None,
+        header_name: str | None = None,
+        header_value: str | None = None,
+        cookie: str | None = None,
+    ) -> None:
+        # Use default configuration if none is provided
+        if configuration is None:
+            configuration = Configuration.get_default()
+        self.configuration = configuration
+
+        # Set up default headers
+        self.default_headers: dict[str, str] = {}
+        if header_name is not None and header_value is not None:
+            self.default_headers[header_name] = header_value
+
+        # Set default User-Agent
+        self.default_headers['User-Agent'] = 'OpenAPI-Generator/1.0.3.dev0/python'
+
+        self.cookie = cookie
+
+        # Create or use provided httpx AsyncClient
+        if http_client is not None:
+            self._client = http_client
+            self._client_provided = True
+        else:
+            # Build httpx client with configuration
+            timeout = Timeout(
+                timeout=configuration.timeout if hasattr(configuration, 'timeout') else 60.0
+            )
+
+            client_args = {
+                'timeout': timeout,
+                'headers': self.default_headers,
+                'verify': configuration.verify_ssl if hasattr(configuration, 'verify_ssl') else True,
+            }
+
+            if hasattr(configuration, 'host') and configuration.host:
+                client_args['base_url'] = configuration.host
+
+            if hasattr(configuration, 'ssl_ca_cert') and configuration.ssl_ca_cert:
+                client_args['verify'] = configuration.ssl_ca_cert
+
+            if hasattr(configuration, 'cert_file') and configuration.cert_file:
+                cert_tuple = (configuration.cert_file,)
+                if hasattr(configuration, 'key_file') and configuration.key_file:
+                    cert_tuple = (configuration.cert_file, configuration.key_file)
+                client_args['cert'] = cert_tuple
+
+            if hasattr(configuration, 'proxy') and configuration.proxy:
+                client_args['proxies'] = configuration.proxy
+
+            self._client = AsyncClient(**client_args)
+            self._client_provided = False
+
+    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 HTTP client."""
+        if not self._client_provided:
+            await self._client.aclose()
+
+    @property
+    def user_agent(self) -> str:
+        """User agent for this API client."""
+        return self.default_headers.get('User-Agent', '')
+
+    @user_agent.setter
+    def user_agent(self, value: str):
+        """Set the user agent."""
+        self.default_headers['User-Agent'] = value
+
+    def set_default_header(self, header_name: str, header_value: str):
+        """Set a default header."""
+        self.default_headers[header_name] = header_value
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        headers: dict[str, str] | None = None,
+        params: dict[str, Any] | None = None,
+        json: Any | None = None,
+        data: Any | None = None,
+        files: dict[str, Any] | None = None,
+        stream: bool = False,
+    ) -> AsyncApiResponse | AsyncStream:
+        """
+        Make an async HTTP request.
+
+        :param method: HTTP method (GET, POST, etc.)
+        :param url: Request URL
+        :param headers: Optional headers dict
+        :param params: Optional query parameters
+        :param json: Optional JSON body
+        :param data: Optional form data
+        :param files: Optional files to upload
+        :param stream: Whether to stream the response
+        :return: AsyncApiResponse or AsyncStream object
+        """
+        # Merge headers
+        request_headers = self.default_headers.copy()
+        if headers:
+            request_headers.update(headers)
+
+        # Add cookie if present
+        if self.cookie:
+            request_headers['Cookie'] = self.cookie
+
+        try:
+            response = await self._client.request(
+                method=method,
+                url=url,
+                headers=request_headers,
+                params=params,
+                json=json,
+                data=data,
+                files=files,
+            )
+
+            if stream:
+                return AsyncStream(response, self)
+            else:
+                return AsyncApiResponse(response)
+
+        except httpx.HTTPError as e:
+            raise ApiException(status=0, reason=str(e))
+
+    _default = None
+
+    @classmethod
+    def get_default(cls):
+        """Return new instance of AsyncApiClient.
+
+        This method returns a newly created instance based on the default constructor,
+        or returns a copy of the default AsyncApiClient.
+
+        :return: The AsyncApiClient object.
+        """
+        if cls._default is None:
+            cls._default = AsyncApiClient()
+        return cls._default
+
+    @classmethod
+    def set_default(cls, default):
+        """Set default instance of AsyncApiClient.
+
+        :param default: object of AsyncApiClient.
+        """
+        cls._default = default

ogx_client/async_api_response.py

@@ -0,0 +1,134 @@
+"""Async API response object."""
+
+from __future__ import annotations
+from typing import Generic, Mapping, TypeVar, AsyncIterator, Any
+import httpx
+
+T = TypeVar("T")
+
+
+class AsyncApiResponse(Generic[T]):
+    """
+    Async API response object
+    """
+
+    def __init__(self, response: httpx.Response) -> None:
+        """
+        Initialize AsyncApiResponse.
+
+        :param response: httpx.Response object
+        """
+        self._response = response
+        self._data: T | None = None
+        self._raw_data: bytes | None = None
+
+    @property
+    def status_code(self) -> int:
+        """HTTP status code."""
+        return self._response.status_code
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        """HTTP headers."""
+        return self._response.headers
+
+    @property
+    def raw_data(self) -> bytes:
+        """Raw data (HTTP response body)."""
+        if self._raw_data is None:
+            self._raw_data = self._response.content
+        return self._raw_data
+
+    async def read(self) -> bytes:
+        """
+        Asynchronously read and return binary response content.
+
+        :return: Response content as bytes
+        """
+        if self._raw_data is None:
+            self._raw_data = await self._response.aread()
+        return self._raw_data
+
+    async def text(self) -> str:
+        """
+        Asynchronously read and decode response content to a string.
+
+        :return: Response content as string
+        """
+        content = await self.read()
+        return content.decode(self._response.encoding or 'utf-8')
+
+    async def json(self) -> Any:
+        """
+        Asynchronously read and decode JSON response content.
+
+        :return: Decoded JSON object
+        """
+        return self._response.json()
+
+    async def parse(self, cast_to: type[T] = None) -> T:
+        """
+        Parse the response data.
+
+        :param cast_to: Optional type to cast the response to
+        :return: Parsed response data
+        """
+        if cast_to is None:
+            return await self.json()  # type: ignore
+
+        # Handle different response types
+        if cast_to == bytes:
+            return await self.read()  # type: ignore
+        elif cast_to == str:
+            return await self.text()  # type: ignore
+        else:
+            # Assume JSON response that can be parsed
+            json_data = await self.json()
+            if hasattr(cast_to, 'model_validate'):
+                # Pydantic model
+                return cast_to.model_validate(json_data)  # type: ignore
+            else:
+                return json_data  # type: ignore
+
+    async def close(self) -> None:
+        """
+        Asynchronously close the response and release the connection.
+        """
+        await self._response.aclose()
+
+    async def iter_bytes(self, chunk_size: int = 1024) -> AsyncIterator[bytes]:
+        """
+        Async iterator for byte chunks of response content.
+
+        :param chunk_size: Size of chunks to yield
+        :return: Async iterator of byte chunks
+        """
+        async for chunk in self._response.aiter_bytes(chunk_size=chunk_size):
+            yield chunk
+
+    async def iter_text(self, chunk_size: int = 1024) -> AsyncIterator[str]:
+        """
+        Async iterator for text chunks of response content.
+
+        :param chunk_size: Size of chunks to yield
+        :return: Async iterator of text chunks
+        """
+        async for chunk in self._response.aiter_text(chunk_size=chunk_size):
+            yield chunk
+
+    async def iter_lines(self) -> AsyncIterator[str]:
+        """
+        Async iterator yielding line chunks of response content.
+
+        :return: Async iterator of lines
+        """
+        async for line in self._response.aiter_lines():
+            yield line
+
+    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()

ogx_client/async_stream.py

@@ -0,0 +1,161 @@
+"""Async streaming response handler."""
+
+from __future__ import annotations
+from typing import TypeVar, Generic, AsyncIterator, Callable, Any, TYPE_CHECKING
+import json
+import httpx
+
+if TYPE_CHECKING:
+    from ogx_client.async_api_client import AsyncApiClient
+
+T = TypeVar("T")
+
+
+class AsyncStream(Generic[T]):
+    """
+    Async streaming response handler.
+
+    Handles asynchronous streaming responses, particularly for server-sent events (SSE).
+    """
+
+    def __init__(
+        self,
+        response: httpx.Response,
+        client: AsyncApiClient,
+        *,
+        cast_to: type[T] | None = None,
+        decoder: Callable[[str], T] | None = None,
+    ) -> None:
+        """
+        Initialize AsyncStream.
+
+        :param response: httpx.Response object with streaming enabled
+        :param client: AsyncApiClient instance
+        :param cast_to: Optional type to cast streamed data to
+        :param decoder: Optional custom decoder function
+        """
+        self._response = response
+        self._client = client
+        self._cast_to = cast_to
+        self._decoder = decoder or self._default_decoder
+        self._iterator: AsyncIterator[T] | None = None
+
+    def _default_decoder(self, data: str) -> Any:
+        """
+        Default decoder for streaming data.
+
+        :param data: Raw string data
+        :return: Decoded data
+        """
+        if not data:
+            return None
+
+        try:
+            json_data = json.loads(data)
+            if self._cast_to and hasattr(self._cast_to, 'model_validate'):
+                # Pydantic model
+                return self._cast_to.model_validate(json_data)
+            return json_data
+        except json.JSONDecodeError:
+            return data
+
+    async def __aiter__(self) -> AsyncIterator[T]:
+        """
+        Async iterator over stream items.
+
+        :return: Async iterator
+        """
+        async for item in self._iter_events():
+            if item is not None:
+                yield item
+
+    async def __anext__(self) -> T:
+        """
+        Get next item in stream.
+
+        :return: Next stream item
+        :raises StopAsyncIteration: When stream is exhausted
+        """
+        if self._iterator is None:
+            self._iterator = self._iter_events()
+        return await self._iterator.__anext__()
+
+    async def _iter_events(self) -> AsyncIterator[T]:
+        """
+        Iterate through server-sent events.
+
+        Parses SSE format and yields decoded events.
+
+        :return: Async iterator of decoded events
+        """
+        async for line in self._response.aiter_lines():
+            line = line.strip()
+
+            # Skip empty lines and comments
+            if not line or line.startswith(':'):
+                continue
+
+            # Parse SSE format
+            if line.startswith('data: '):
+                data = line[6:]  # Remove 'data: ' prefix
+
+                # Handle end of stream marker
+                if data == '[DONE]':
+                    break
+
+                # Decode and yield the data
+                decoded = self._decoder(data)
+                if decoded is not None:
+                    yield decoded
+
+    async def _iter_raw(self) -> AsyncIterator[bytes]:
+        """
+        Iterate over raw byte chunks.
+
+        :return: Async iterator of byte chunks
+        """
+        async for chunk in self._response.aiter_bytes():
+            yield chunk
+
+    async def _iter_text(self) -> AsyncIterator[str]:
+        """
+        Iterate over text chunks.
+
+        :return: Async iterator of text chunks
+        """
+        async for chunk in self._response.aiter_text():
+            yield chunk
+
+    async def close(self) -> None:
+        """
+        Close the async response connection.
+        """
+        await self._response.aclose()
+
+    async def __aenter__(self) -> AsyncStream[T]:
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> None:
+        """Async context manager exit."""
+        await self.close()
+
+    @property
+    def status_code(self) -> int:
+        """HTTP status code."""
+        return self._response.status_code
+
+    @property
+    def headers(self) -> httpx.Headers:
+        """HTTP headers."""
+        return self._response.headers
+
+    async def until_done(self) -> None:
+        """
+        Consume the entire stream until completion.
+
+        This is useful when you need to ensure the stream is fully consumed
+        but don't need to process the items.
+        """
+        async for _ in self:
+            pass