opperai 0.12.3__py3-none-any.whl

opperai/__init__.py

@@ -0,0 +1,52 @@
+# ruff: noqa: F401
+from opperai.core.spans._decorator import start_span, trace
+from opperai.functions.async_functions import AsyncFunctions
+from opperai.functions.decorator._decorator import fn, get_last_span_id
+from opperai.functions.functions import Functions
+from opperai.indexes.async_indexes import AsyncIndexes
+from opperai.indexes.indexes import Index, Indexes
+from opperai.spans.async_spans import AsyncSpans
+from opperai.spans.spans import Spans
+
+from .__version__ import __version__
+from ._client import AsyncClient, Client
+
+
+class Opper:
+    client: Client = None
+
+    def __init__(self, client: Client = None, api_key: str = None):
+        if client is not None:
+            if not isinstance(client, Client):
+                raise ValueError("Client must be an instance of Client")
+        if api_key is not None:
+            client = Client(api_key=api_key)
+        if client is None:
+            client = Client()
+
+        self.client: Client = client
+        self.functions: Functions = Functions(client)
+        self.indexes: Indexes = Indexes(client)
+        self.spans: Spans = Spans(client)  # deprecated
+        self.traces: Spans = self.spans
+        self.call = self.functions.call
+
+
+class AsyncOpper(Opper):
+    client: AsyncClient = None
+
+    def __init__(self, client: AsyncClient = None, api_key: str = None):
+        if client is not None:
+            if not isinstance(client, AsyncClient):
+                raise ValueError("Client must be an instance of AsyncClient")
+        if api_key is not None:
+            client = AsyncClient(api_key=api_key)
+        if client is None:
+            client = AsyncClient()
+
+        self.client: AsyncClient = client
+        self.functions: AsyncFunctions = AsyncFunctions(client)
+        self.indexes: AsyncIndexes = AsyncIndexes(client)
+        self.spans: AsyncSpans = AsyncSpans(client)  # deprecated
+        self.traces: AsyncSpans = self.spans
+        self.call = self.functions.call

opperai/__version__.py

@@ -0,0 +1,3 @@
+from importlib.metadata import version
+
+__version__ = version("opperai")

opperai/_client.py

@@ -0,0 +1,85 @@
+import os
+
+from opperai.core.datasets._async_datasets import AsyncDatasets
+from opperai.core.datasets._datasets import Datasets
+from opperai.core.functions._async_functions import AsyncFunctions
+from opperai.core.functions._functions import Functions
+from opperai.core.indexes._async_indexes import AsyncIndexes
+from opperai.core.indexes._indexes import Indexes
+from opperai.core.spans._async_spans import AsyncSpans
+from opperai.core.spans._spans import Spans
+
+from .core._http_clients import _async_http_client, _http_client
+
+DEFAULT_API_URL = "https://api.opper.ai"
+DEFAULT_TIMEOUT = 120
+
+
+class AsyncClient:
+    functions: AsyncFunctions = None
+    indexes: AsyncIndexes = None
+    spans: AsyncSpans = None
+    datasets: AsyncDatasets = None
+
+    def __init__(
+        self,
+        api_key: str = None,
+        api_url: str = None,
+        default_model: str = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ):
+        if api_key is None:
+            api_key = os.getenv("OPPER_API_KEY")
+            if api_key is None:
+                raise Exception(
+                    "API key is not provided and OPPER_API_KEY environment variable is not set."
+                )
+        if api_url is None:
+            api_url = os.getenv("OPPER_API_URL", DEFAULT_API_URL)
+        if default_model is None:
+            default_model = os.getenv("OPPER_DEFAULT_MODEL")
+
+        self.api_key = api_key
+        self.api_url = api_url
+        self.default_model = default_model
+
+        self.http_client = _async_http_client(api_key, api_url, timeout)
+        self.functions = AsyncFunctions(self.http_client, default_model=default_model)
+        self.indexes = AsyncIndexes(self.http_client)
+        self.spans = AsyncSpans(self.http_client)
+        self.datasets = AsyncDatasets(self.http_client)
+
+
+class Client:
+    functions: Functions
+    indexes: Indexes
+    spans: Spans
+    datasets: Datasets
+
+    def __init__(
+        self,
+        api_key: str = None,
+        api_url: str = None,
+        default_model: str = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ):
+        if api_key is None:
+            api_key = os.getenv("OPPER_API_KEY")
+            if api_key is None:
+                raise Exception(
+                    "API key is not provided and OPPER_API_KEY environment variable is not set."
+                )
+        if api_url is None:
+            api_url = os.getenv("OPPER_API_URL", DEFAULT_API_URL)
+        if default_model is None:
+            default_model = os.getenv("OPPER_DEFAULT_MODEL")
+
+        self.api_key = api_key
+        self.api_url = api_url
+        self.default_model = default_model
+
+        self.http_client = _http_client(api_key, api_url, timeout)
+        self.functions = Functions(self.http_client, default_model=default_model)
+        self.indexes = Indexes(self.http_client)
+        self.spans = Spans(self.http_client)
+        self.datasets = Datasets(self.http_client)

opperai/core/_http_clients.py

@@ -0,0 +1,112 @@
+import json
+from http import HTTPStatus
+
+import httpx
+from httpx_sse import aconnect_sse, connect_sse
+from opperai import __version__
+from opperai.types import Errors
+from opperai.types.exceptions import (
+    ContentPolicyViolationError,
+    OpperTimeoutError,
+    RateLimitError,
+    RequestValidationError,
+    StructuredGenerationError,
+)
+
+
+def _prepare_error(response):
+    error = Errors.model_validate(response.json())
+    error = error.errors[0]
+    status_code = response.status_code
+
+    if status_code == HTTPStatus.BAD_REQUEST:
+        if error.type == "StructuredGenerationError":
+            raise StructuredGenerationError(error.message, error.detail)
+        if error.type == "ContentPolicyViolationError":
+            raise ContentPolicyViolationError(error.message, error.detail)
+    if status_code == HTTPStatus.UNPROCESSABLE_ENTITY:
+        if error.type == "RequestValidationError":
+            raise RequestValidationError(error.message, error.detail)
+    if status_code == HTTPStatus.TOO_MANY_REQUESTS:
+        if error.type == "RateLimitError":
+            raise RateLimitError(error.message, error.detail)
+
+
+class _async_http_client:
+    def __init__(self, api_key: str, api_url: str, timeout: float):
+        self.session = httpx.AsyncClient(
+            base_url=api_url,
+            headers={
+                "X-OPPER-API-KEY": f"{api_key}",
+                "User-Agent": f"opper-python/{__version__}",
+            },
+            timeout=httpx.Timeout(timeout),
+        )
+
+    async def do_request(self, method: str, path: str, **kwargs):
+        try:
+            response = await self.session.request(method, path, **kwargs)
+            if response.status_code >= 400:
+                _prepare_error(response)
+            return response
+        except httpx.TimeoutException as e:
+            raise OpperTimeoutError(
+                "request timed out",
+                "The request to the opper api timed out.",
+            ) from e
+
+    async def stream(self, method: str, path: str, **kwargs):
+        try:
+            async with aconnect_sse(
+                self.session,
+                method,
+                path,
+                **kwargs,
+            ) as event_source:
+                async for sse in event_source.aiter_sse():
+                    yield json.loads(sse.data)
+        except httpx.TimeoutException as e:
+            raise OpperTimeoutError(
+                "request timed out",
+                "The request to the opper api timed out.",
+            ) from e
+
+
+class _http_client:
+    def __init__(self, api_key: str, api_url: str, timeout):
+        self.session = httpx.Client(
+            base_url=api_url,
+            headers={
+                "X-OPPER-API-KEY": f"{api_key}",
+                "User-Agent": f"opper-python/{__version__}",
+            },
+            timeout=httpx.Timeout(timeout),
+        )
+
+    def do_request(self, method: str, path: str, **kwargs):
+        try:
+            response = self.session.request(method, path, **kwargs)
+            if response.status_code >= 400:
+                _prepare_error(response)
+            return response
+        except httpx.TimeoutException as e:
+            raise OpperTimeoutError(
+                "request timed out",
+                "The request to the opper api timed out.",
+            ) from e
+
+    def stream(self, method: str, path: str, **kwargs):
+        try:
+            with connect_sse(
+                self.session,
+                method,
+                path,
+                **kwargs,
+            ) as event_source:
+                for sse in event_source.iter_sse():
+                    yield json.loads(sse.data)
+        except httpx.TimeoutException as e:
+            raise OpperTimeoutError(
+                "request timed out",
+                "The request to the opper api timed out.",
+            ) from e

opperai/core/datasets/_async_datasets.py

@@ -0,0 +1,68 @@
+from typing import List
+
+from opperai.core._http_clients import _async_http_client
+from opperai.types.datasets import (
+    DatasetEntry,
+    DatasetEntryResponse,
+    DatasetEntryUpdate,
+)
+from opperai.types.exceptions import APIError
+
+
+class AsyncDatasets:
+    def __init__(self, http_client: _async_http_client):
+        self.http_client = http_client
+
+    async def add(self, dataset_uuid: str, entry: DatasetEntry) -> str:
+        response = await self.http_client.do_request(
+            "POST",
+            f"/v1/datasets/{dataset_uuid}",
+            json=entry.model_dump(),
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to add entry with status {response.status_code}")
+        return response.json()
+
+    async def get_entries(
+        self, dataset_uuid: str, offset: int = 0, limit: int = 100
+    ) -> List[DatasetEntryResponse]:
+        response = await self.http_client.do_request(
+            "GET",
+            f"/v1/datasets/{dataset_uuid}/entries",
+            params={"offset": offset, "limit": limit},
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to get entries with status {response.status_code}")
+        return [DatasetEntryResponse.model_validate(item) for item in response.json()]
+
+    async def get_entry(
+        self, dataset_uuid: str, entry_uuid: str
+    ) -> DatasetEntryResponse:
+        response = await self.http_client.do_request(
+            "GET",
+            f"/v1/datasets/{dataset_uuid}/entries/{entry_uuid}",
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to get entry with status {response.status_code}")
+        return DatasetEntryResponse.model_validate(response.json())
+
+    async def update_entry(
+        self, dataset_uuid: str, entry_uuid: str, entry: DatasetEntryUpdate
+    ) -> DatasetEntryResponse:
+        response = await self.http_client.do_request(
+            "PUT",
+            f"/v1/datasets/{dataset_uuid}/entries/{entry_uuid}",
+            json=entry.model_dump(),
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to update entry with status {response.status_code}")
+        return DatasetEntryResponse.model_validate(response.json())
+
+    async def delete_entry(self, dataset_uuid: str, entry_uuid: str) -> bool:
+        response = await self.http_client.do_request(
+            "DELETE",
+            f"/v1/datasets/{dataset_uuid}/entries/{entry_uuid}",
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to delete entry with status {response.status_code}")
+        return response.json()

opperai/core/datasets/_datasets.py

@@ -0,0 +1,183 @@
+from typing import List
+
+from opperai.core._http_clients import _http_client
+from opperai.types.datasets import (
+    DatasetEntry,
+    DatasetEntryResponse,
+    DatasetEntryUpdate,
+)
+from opperai.types.exceptions import APIError
+
+
+class Datasets:
+    def __init__(self, http_client: _http_client):
+        self.http_client = http_client
+
+    def add(self, dataset_uuid: str, entry: DatasetEntry) -> str:
+        """Add an entry to a dataset
+
+        This method adds an entry to a specified dataset by its unique identifier. The entry is added to the dataset, making it part of the dataset's collection.
+
+        Args:
+            dataset_uuid (str): The unique identifier of the dataset.
+            entry (DatasetEntrySchema): The entry to be added to the dataset.
+
+        Returns:
+            str: The unique identifier of the added entry.
+
+        Raises:
+            APIError: If the entry addition fails due to an API error.
+
+        Examples:
+            >>> from opperai import Client
+            >>> from opperai.types.datasets import DatasetEntrySchema
+            >>> client = Client(api_key="your_api_key_here")
+            >>> entry = DatasetEntrySchema(input="Example input", output="Example output")
+            >>> entry_uuid = client.datasets.add(dataset_uuid="123", entry=entry)
+            >>> print(entry_uuid)
+            "456"
+
+        """
+        response = self.http_client.do_request(
+            "POST",
+            f"/v1/datasets/{dataset_uuid}",
+            json=entry.model_dump(),
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to add entry with status {response.status_code}")
+        return response.json()
+
+    def get_entries(
+        self, dataset_uuid: str, offset: int = 0, limit: int = 100
+    ) -> List[DatasetEntryResponse]:
+        """Get entries from a dataset
+
+        This method retrieves entries from a specified dataset by its unique identifier. The entries are returned based on the specified offset and limit.
+
+        Args:
+            dataset_uuid (str): The unique identifier of the dataset.
+            offset (int, optional): The offset for pagination. Defaults to 0.
+            limit (int, optional): The maximum number of entries to retrieve. Defaults to 100.
+
+        Returns:
+            List[DatasetEntryResponseSchema]: A list of DatasetEntryResponseSchema instances representing the entries in the dataset.
+
+        Raises:
+            APIError: If the retrieval fails due to an API error.
+
+        Examples:
+            >>> from opperai import Client
+            >>> client = Client(api_key="your_api_key_here")
+            >>> entries = client.datasets.get_entries(dataset_uuid="123", offset=0, limit=10)
+            >>> for entry in entries:
+            ...     print(entry)
+            DatasetEntryResponseSchema(uuid='456', input='Example input', output='Example output', ...)
+
+        """
+        response = self.http_client.do_request(
+            "GET",
+            f"/v1/datasets/{dataset_uuid}/entries",
+            params={"offset": offset, "limit": limit},
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to get entries with status {response.status_code}")
+        return [DatasetEntryResponse.model_validate(item) for item in response.json()]
+
+    def get_entry(self, dataset_uuid: str, entry_uuid: str) -> DatasetEntryResponse:
+        """Get a specific entry from a dataset
+
+        This method retrieves a specific entry from a specified dataset by its unique identifier.
+
+        Args:
+            dataset_uuid (str): The unique identifier of the dataset.
+            entry_uuid (str): The unique identifier of the entry.
+
+        Returns:
+            DatasetEntryResponseSchema: An instance of DatasetEntryResponseSchema representing the entry.
+
+        Raises:
+            APIError: If the retrieval fails due to an API error.
+
+        Examples:
+            >>> from opperai import Client
+            >>> client = Client(api_key="your_api_key_here")
+            >>> entry = client.datasets.get_entry(dataset_uuid="123", entry_uuid="456")
+            >>> print(entry)
+            DatasetEntryResponseSchema(uuid='456', input='Example input', output='Example output', ...)
+
+        """
+        response = self.http_client.do_request(
+            "GET",
+            f"/v1/datasets/{dataset_uuid}/entries/{entry_uuid}",
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to get entry with status {response.status_code}")
+        return DatasetEntryResponse.model_validate(response.json())
+
+    def update_entry(
+        self, dataset_uuid: str, entry_uuid: str, entry: DatasetEntryUpdate
+    ) -> DatasetEntryResponse:
+        """Update a specific entry in a dataset
+
+        This method updates a specific entry in a specified dataset by its unique identifier.
+
+        Args:
+            dataset_uuid (str): The unique identifier of the dataset.
+            entry_uuid (str): The unique identifier of the entry.
+            entry (DatasetEntryUpdateSchema): The updated entry data.
+
+        Returns:
+            DatasetEntryResponseSchema: An instance of DatasetEntryResponseSchema representing the updated entry.
+
+        Raises:
+            APIError: If the update fails due to an API error.
+
+        Examples:
+            >>> from opperai import Client
+            >>> from opperai.types.datasets import DatasetEntryUpdateSchema
+            >>> client = Client(api_key="your_api_key_here")
+            >>> updated_entry = DatasetEntryUpdateSchema(input="Updated input", output="Updated output")
+            >>> entry = client.datasets.update_entry(dataset_uuid="123", entry_uuid="456", entry=updated_entry)
+            >>> print(entry)
+            DatasetEntryResponseSchema(uuid='456', input='Updated input', output='Updated output', ...)
+
+        """
+        response = self.http_client.do_request(
+            "PUT",
+            f"/v1/datasets/{dataset_uuid}/entries/{entry_uuid}",
+            json=entry.model_dump(),
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to update entry with status {response.status_code}")
+        return DatasetEntryResponse.model_validate(response.json())
+
+    def delete_entry(self, dataset_uuid: str, entry_uuid: str) -> bool:
+        """Delete a specific entry from a dataset
+
+        This method deletes a specific entry from a specified dataset by its unique identifier.
+
+        Args:
+            dataset_uuid (str): The unique identifier of the dataset.
+            entry_uuid (str): The unique identifier of the entry.
+
+        Returns:
+            bool: True if the entry was successfully deleted, False otherwise.
+
+        Raises:
+            APIError: If the deletion fails due to an API error.
+
+        Examples:
+            >>> from opperai import Client
+            >>> client = Client(api_key="your_api_key_here")
+            >>> success = client.datasets.delete_entry(dataset_uuid="123", entry_uuid="456")
+            >>> print(success)
+            True
+
+        """
+        response = self.http_client.do_request(
+            "DELETE",
+            f"/v1/datasets/{dataset_uuid}/entries/{entry_uuid}",
+        )
+        if response.status_code != 200:
+            raise APIError(f"Failed to delete entry with status {response.status_code}")
+        return response.json()