arize 8.0.0a22__py3-none-any.whl → 8.0.0b0__py3-none-any.whl

arize/pre_releases.py

@@ -0,0 +1,44 @@
+"""Pre-release feature management and gating for the Arize SDK."""
+
+import functools
+import logging
+from collections.abc import Callable
+from enum import StrEnum
+
+from arize.version import __version__
+
+logger = logging.getLogger(__name__)
+
+
+class ReleaseStage(StrEnum):
+    """Enum representing the release stage of API features."""
+
+    ALPHA = "alpha"
+    BETA = "beta"
+
+
+_WARNED: set[str] = set()
+
+
+def _format_prerelease_message(*, key: str, stage: ReleaseStage) -> str:
+    article = "an" if stage is ReleaseStage.ALPHA else "a"
+    return (
+        f"[{stage.upper()}] {key} is {article} {stage} API "
+        f"in Arize SDK v{__version__} and may change without notice."
+    )
+
+
+def prerelease_endpoint(*, stage: ReleaseStage, key: str) -> object:
+    """Decorate a method to emit a prerelease warning via logging once per process."""
+
+    def deco(fn: Callable[..., object]) -> object:
+        @functools.wraps(fn)
+        def wrapper(*args: object, **kwargs: object) -> object:
+            if key not in _WARNED:
+                _WARNED.add(key)
+                logger.warning(_format_prerelease_message(key=key, stage=stage))
+            return fn(*args, **kwargs)
+
+        return wrapper
+
+    return deco

arize/projects/__init__.py

@@ -0,0 +1 @@
+"""Project management and operations for the Arize platform."""

arize/projects/client.py

@@ -0,0 +1,134 @@
+"""Client implementation for managing projects in the Arize platform."""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from arize.pre_releases import ReleaseStage, prerelease_endpoint
+
+if TYPE_CHECKING:
+    from arize._generated.api_client import models
+    from arize.config import SDKConfiguration
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectsClient:
+    """Client for managing Arize projects and project-level operations.
+
+    This class is primarily intended for internal use within the SDK. Users are
+    highly encouraged to access resource-specific functionality via
+    :class:`arize.ArizeClient`.
+
+    The projects client is a thin wrapper around the generated REST API client,
+    using the shared generated API client owned by
+    :class:`arize.config.SDKConfiguration`.
+    """
+
+    def __init__(self, *, sdk_config: SDKConfiguration) -> None:
+        """
+        Args:
+            sdk_config: Resolved SDK configuration.
+        """  # noqa: D205, D212
+        self._sdk_config = sdk_config
+
+        # Import at runtime so it's still lazy and extras-gated by the parent
+        from arize._generated import api_client as gen
+
+        # Use the shared generated client from the config
+        self._api = gen.ProjectsApi(self._sdk_config.get_generated_client())
+
+    @prerelease_endpoint(key="projects.list", stage=ReleaseStage.BETA)
+    def list(
+        self,
+        *,
+        space_id: str | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> models.ProjectsList200Response:
+        """List projects the user has access to.
+
+        This endpoint supports cursor-based pagination. When provided, `space_id`
+        filters results to a particular space.
+
+        Args:
+            space_id: Optional space ID to filter results.
+            limit: Maximum number of projects to return. The server may enforce
+                an upper bound.
+            cursor: Opaque pagination cursor from a previous response.
+
+        Returns:
+            A paginated project list response from the Arize REST API.
+
+        Raises:
+            arize._generated.api_client.exceptions.ApiException: If the API request fails.
+        """
+        return self._api.projects_list(
+            space_id=space_id,
+            limit=limit,
+            cursor=cursor,
+        )
+
+    @prerelease_endpoint(key="projects.create", stage=ReleaseStage.BETA)
+    def create(
+        self,
+        *,
+        name: str,
+        space_id: str,
+    ) -> models.Project:
+        """Create a new project.
+
+        Project names must be unique within the target space.
+
+        Args:
+            name: Project name (must be unique within `space_id`).
+            space_id: Space ID to create the project in.
+
+        Returns:
+            The created project object.
+
+        Raises:
+            arize._generated.api_client.exceptions.ApiException: If the API request fails
+                (for example, due to invalid input or a uniqueness conflict).
+        """
+        from arize._generated import api_client as gen
+
+        body = gen.ProjectsCreateRequest(
+            name=name,
+            space_id=space_id,
+        )
+        return self._api.projects_create(projects_create_request=body)
+
+    @prerelease_endpoint(key="projects.get", stage=ReleaseStage.BETA)
+    def get(self, *, project_id: str) -> models.Project:
+        """Get a project by ID.
+
+        Args:
+            project_id: Project ID.
+
+        Returns:
+            The project object.
+
+        Raises:
+            arize._generated.api_client.exceptions.ApiException: If the API request fails
+                (for example, project not found).
+        """
+        return self._api.projects_get(project_id=project_id)
+
+    @prerelease_endpoint(key="projects.delete", stage=ReleaseStage.BETA)
+    def delete(self, *, project_id: str) -> None:
+        """Delete a project by ID.
+
+        This operation is irreversible.
+
+        Args:
+            project_id: Project ID.
+
+        Returns: This method returns None on success (common empty 204 response)
+
+        Raises:
+            arize._generated.api_client.exceptions.ApiException: If the API request fails
+                (for example, project not found or insufficient permissions).
+        """
+        return self._api.projects_delete(project_id=project_id)

arize/regions.py

@@ -0,0 +1,40 @@
+"""Region definitions and configuration for Arize deployment zones."""
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+from arize.constants.config import DEFAULT_FLIGHT_PORT
+
+
+class Region(StrEnum):
+    """Enum representing available Arize deployment regions."""
+
+    US_CENTRAL_1 = "us-central-1a"
+    EU_WEST_1 = "eu-west-1a"
+    CA_CENTRAL_1 = "ca-central-1a"
+    US_EAST_1 = "us-east-1b"
+    UNSPECIFIED = ""
+
+
+@dataclass(frozen=True)
+class RegionEndpoints:
+    """Container for region-specific API endpoint hostnames and ports."""
+
+    api_host: str
+    otlp_host: str
+    flight_host: str
+    flight_port: int
+
+
+def _get_region_endpoints(region: Region) -> RegionEndpoints:
+    return RegionEndpoints(
+        api_host=f"api.{region}.arize.com",
+        otlp_host=f"otlp.{region}.arize.com",
+        flight_host=f"flight.{region}.arize.com",
+        flight_port=DEFAULT_FLIGHT_PORT,
+    )
+
+
+REGION_ENDPOINTS: dict[Region, RegionEndpoints] = {
+    r: _get_region_endpoints(r) for r in Region if r != Region.UNSPECIFIED
+}

arize/spans/__init__.py

@@ -0,0 +1 @@
+"""LLM tracing spans functionality for the Arize SDK."""