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

arize/config.py

@@ -1,207 +1,418 @@
+"""SDK configuration and settings management for the Arize client."""
+
 import logging
 import os
 import sys
 import threading
 from dataclasses import dataclass, field, fields
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any
 
 from arize.constants.config import (
     DEFAULT_API_HOST,
+    DEFAULT_API_SCHEME,
     DEFAULT_ARIZE_DIRECTORY,
     DEFAULT_ENABLE_CACHING,
     DEFAULT_FLIGHT_HOST,
     DEFAULT_FLIGHT_PORT,
-    DEFAULT_FLIGHT_TRANSPORT_SCHEME,
-    DEFAULT_INSECURE,
+    DEFAULT_FLIGHT_SCHEME,
     DEFAULT_MAX_HTTP_PAYLOAD_SIZE_MB,
     DEFAULT_OTLP_HOST,
+    DEFAULT_OTLP_SCHEME,
     DEFAULT_PYARROW_MAX_CHUNKSIZE,
     DEFAULT_REQUEST_VERIFY,
     DEFAULT_STREAM_MAX_QUEUE_BOUND,
     DEFAULT_STREAM_MAX_WORKERS,
     ENV_API_HOST,
     ENV_API_KEY,
+    ENV_API_SCHEME,
     ENV_ARIZE_DIRECTORY,
     ENV_ENABLE_CACHING,
     ENV_FLIGHT_HOST,
     ENV_FLIGHT_PORT,
-    ENV_FLIGHT_TRANSPORT_SCHEME,
-    ENV_INSECURE,
+    ENV_FLIGHT_SCHEME,
     ENV_MAX_HTTP_PAYLOAD_SIZE_MB,
     ENV_OTLP_HOST,
+    ENV_OTLP_SCHEME,
     ENV_PYARROW_MAX_CHUNKSIZE,
+    ENV_REGION,
     ENV_REQUEST_VERIFY,
+    ENV_SINGLE_HOST,
+    ENV_SINGLE_PORT,
     ENV_STREAM_MAX_QUEUE_BOUND,
     ENV_STREAM_MAX_WORKERS,
 )
 from arize.constants.pyarrow import MAX_CHUNKSIZE
 from arize.exceptions.auth import MissingAPIKeyError
+from arize.regions import REGION_ENDPOINTS, Region
 from arize.version import __version__
 
 logger = logging.getLogger(__name__)
 
-
-def _parse_bool(val: bool | str | None) -> bool:
-    if isinstance(val, bool):
-        return val
-    return (val or "").strip().lower() in {"1", "true", "yes", "on"}
-
-
-def _api_key_factory() -> str:
-    return os.getenv(ENV_API_KEY, "")
-
-
-def _api_host_factory() -> str:
-    return os.getenv(ENV_API_HOST, DEFAULT_API_HOST)
-
-
-def _api_scheme_factory() -> str:
-    insecure = os.getenv(ENV_INSECURE, DEFAULT_INSECURE)
-    if insecure:
-        return "http"
-    return "https"
+PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+SENSITIVE_FIELD_MARKERS = ("key", "token", "secret")
+ALLOWED_HTTP_SCHEMES = {"http", "https"}
 
 
-def _flight_host_factory() -> str:
-    return os.getenv(ENV_FLIGHT_HOST, DEFAULT_FLIGHT_HOST)
+def _is_sensitive_field(name: str) -> bool:
+    n = name.lower()
+    return bool(any(k in n for k in SENSITIVE_FIELD_MARKERS))
 
 
-def _flight_port_factory() -> int:
-    return int(os.getenv(ENV_FLIGHT_PORT, DEFAULT_FLIGHT_PORT))
+def _mask_secret(secret: str, N: int = 4) -> str:
+    """Show first N chars then '***'; empty string if empty."""
+    if len(secret) == 0:
+        return ""
+    return f"{secret[:N]}***"
 
 
-def _flight_scheme_factory() -> str:
-    return os.getenv(
-        ENV_FLIGHT_TRANSPORT_SCHEME, DEFAULT_FLIGHT_TRANSPORT_SCHEME
-    )
+def _endpoint(scheme: str, base: str, path: str = "") -> str:
+    endpoint = scheme + "://" + base.rstrip("/")
+    if path:
+        endpoint += "/" + path.lstrip("/")
+    return endpoint
 
 
-def _pyarrow_max_chunksize() -> int:
-    max_chunksize = int(
-        os.getenv(ENV_PYARROW_MAX_CHUNKSIZE, DEFAULT_PYARROW_MAX_CHUNKSIZE)
-    )
-    if max_chunksize <= 0 or max_chunksize > MAX_CHUNKSIZE:
+def _env_http_scheme(name: str, default: str) -> str:
+    v = _env_str(name, default).lower()
+    if v not in ALLOWED_HTTP_SCHEMES:
         raise ValueError(
-            f"Pyarrow max_chunksize must be between 1 and {MAX_CHUNKSIZE}, got {max_chunksize}"
+            f"{name} must be one of {sorted(ALLOWED_HTTP_SCHEMES)}. Found {v!r}"
         )
-    return max_chunksize
-
+    return v
 
-def _verify_factory() -> bool:
-    return _parse_bool(os.getenv(ENV_REQUEST_VERIFY, DEFAULT_REQUEST_VERIFY))
 
+def _env_str(
+    name: str,
+    default: str,
+    min_len: int | None = None,
+    max_len: int | None = None,
+) -> str:
+    val = os.getenv(name, default).strip()
 
-def _stream_max_workers_factory() -> int:
-    return int(os.getenv(ENV_STREAM_MAX_WORKERS, DEFAULT_STREAM_MAX_WORKERS))
-
-
-def _stream_max_queue_bound_factory() -> int:
-    return int(
-        os.getenv(ENV_STREAM_MAX_QUEUE_BOUND, DEFAULT_STREAM_MAX_QUEUE_BOUND)
-    )
-
-
-def _otlp_scheme_factory() -> str:
-    insecure = os.getenv(ENV_INSECURE, DEFAULT_INSECURE)
-    if insecure:
-        return "http"
-    return "https"
-
-
-def _otlp_host_factory() -> str:
-    return os.getenv(ENV_OTLP_HOST, DEFAULT_OTLP_HOST)
-
-
-def _max_http_payload_size_mb_factory() -> float:
-    return float(
-        os.getenv(
-            ENV_MAX_HTTP_PAYLOAD_SIZE_MB, DEFAULT_MAX_HTTP_PAYLOAD_SIZE_MB
+    if min_len is not None and len(val) < min_len:
+        raise ValueError(
+            f"The value of environment variable {name} must be at least {min_len} "
+            f"characters long. Found {len(val)} characters."
         )
-    )
-
-
-def _arize_dir_factory() -> str:
-    return os.getenv(ENV_ARIZE_DIRECTORY, DEFAULT_ARIZE_DIRECTORY)
+    if max_len is not None and len(val) > max_len:
+        raise ValueError(
+            f"The value of environment variable {name} must be at most {max_len} "
+            f"characters long. Found {len(val)} characters."
+        )
+    return val
+
+
+def _env_int(
+    name: str,
+    default: int,
+    min_val: int | None = None,
+    max_val: int | None = None,
+) -> int:
+    raw = os.getenv(name, default)
+    try:
+        val = int(raw)
+    except Exception as e:
+        raise ValueError(
+            f"Environment variable {name} must be an int. Found: {raw!r}"
+        ) from e
 
+    if min_val is not None and val < min_val:
+        raise ValueError(
+            f"The value of environment variable {name} must be at least {min_val}. Found {val}."
+        )
+    if max_val is not None and val > max_val:
+        raise ValueError(
+            f"The value of environment variable {name} must be at most {max_val}. Found {val}."
+        )
+    return val
+
+
+def _env_float(
+    name: str,
+    default: float,
+    min_val: float | None = None,
+    max_val: float | None = None,
+) -> float:
+    raw = os.getenv(name, default)
+    try:
+        val = float(raw)
+    except Exception as e:
+        raise ValueError(
+            f"Environment variable {name} must be a float. Found: {raw!r}"
+        ) from e
 
-def _enable_cache_factory() -> bool:
-    return _parse_bool(os.getenv(ENV_ENABLE_CACHING, DEFAULT_ENABLE_CACHING))
+    if min_val is not None and val < min_val:
+        raise ValueError(
+            f"The value of environment variable {name} must be at least {min_val}. Found {val}."
+        )
+    if max_val is not None and val > max_val:
+        raise ValueError(
+            f"The value of environment variable {name} must be at most {max_val}. Found {val}."
+        )
+    return val
 
 
-def _mask_secret(secret: str, N: int = 4) -> str:
-    """Show first N chars then '***'; empty string if empty."""
-    return f"{secret[:N]}***"
+def _env_bool(name: str, default: bool) -> bool:
+    return _parse_bool(os.getenv(name, str(default)))
 
 
-def _endpoint(scheme: str, base: str, path: str = "") -> str:
-    endpoint = scheme + "://" + base.rstrip("/")
-    if path:
-        endpoint += "/" + path.lstrip("/")
-    return endpoint
+def _parse_bool(val: bool | str | None) -> bool:
+    if isinstance(val, bool):
+        return val
+    return (val or "").strip().lower() in {"1", "true", "yes", "on"}
 
 
 @dataclass(frozen=True)
 class SDKConfiguration:
-    api_key: str = field(default_factory=_api_key_factory)
-    api_host: str = field(default_factory=_api_host_factory)
-    api_scheme: str = field(default_factory=_api_scheme_factory)
-    otlp_host: str = field(default_factory=_otlp_host_factory)
-    otlp_scheme: str = field(default_factory=_otlp_scheme_factory)
-    flight_server_host: str = field(default_factory=_flight_host_factory)
-    flight_server_port: int = field(default_factory=_flight_port_factory)
-    flight_scheme: str = field(default_factory=_flight_scheme_factory)
-    pyarrow_max_chunksize: int = field(default_factory=_pyarrow_max_chunksize)
-    request_verify: bool = field(default_factory=_verify_factory)
-    stream_max_workers: int = field(default_factory=_stream_max_workers_factory)
+    """Configuration for the Arize SDK with endpoint and authentication settings.
+
+    This class is used internally by ArizeClient to manage SDK configuration. It is not
+    recommended to use this class directly; users should interact with ArizeClient
+    instead.
+
+    Each configuration parameter follows this resolution order:
+        1. Explicit value passed to ArizeClient constructor (highest priority)
+        2. Environment variable value
+        3. Built-in default value (lowest priority)
+
+    Args:
+        api_key: Arize API key for authentication. Required.
+            Environment variable: ARIZE_API_KEY.
+            Default: None (must be provided via argument or environment variable).
+        api_host: API endpoint host.
+            Environment variable: ARIZE_API_HOST.
+            Default: "api.arize.com".
+        api_scheme: API endpoint scheme (http/https).
+            Environment variable: ARIZE_API_SCHEME.
+            Default: "https".
+        otlp_host: OTLP (OpenTelemetry Protocol) endpoint host.
+            Environment variable: ARIZE_OTLP_HOST.
+            Default: "otlp.arize.com".
+        otlp_scheme: OTLP endpoint scheme (http/https).
+            Environment variable: ARIZE_OTLP_SCHEME.
+            Default: "https".
+        flight_host: Apache Arrow Flight endpoint host.
+            Environment variable: ARIZE_FLIGHT_HOST.
+            Default: "flight.arize.com".
+        flight_port: Apache Arrow Flight endpoint port (1-65535).
+            Environment variable: ARIZE_FLIGHT_PORT.
+            Default: 443.
+        flight_scheme: Apache Arrow Flight endpoint scheme.
+            Environment variable: ARIZE_FLIGHT_SCHEME.
+            Default: "grpc+tls".
+        pyarrow_max_chunksize: Maximum chunk size for PyArrow operations (1 to MAX_CHUNKSIZE).
+            Environment variable: ARIZE_MAX_CHUNKSIZE.
+            Default: 10_000.
+        request_verify: Whether to verify SSL certificates for HTTP requests.
+            Environment variable: ARIZE_REQUEST_VERIFY.
+            Default: True.
+        stream_max_workers: Maximum number of worker threads for streaming operations (minimum: 1).
+            Environment variable: ARIZE_STREAM_MAX_WORKERS.
+            Default: 8.
+        stream_max_queue_bound: Maximum queue size for streaming operations (minimum: 1).
+            Environment variable: ARIZE_STREAM_MAX_QUEUE_BOUND.
+            Default: 5000.
+        max_http_payload_size_mb: Maximum HTTP payload size in megabytes (minimum: 1).
+            Environment variable: ARIZE_MAX_HTTP_PAYLOAD_SIZE_MB.
+            Default: 100.
+        arize_directory: Directory for Arize SDK files (cache, logs, etc.).
+            Environment variable: ARIZE_DIRECTORY.
+            Default: "~/.arize".
+        enable_caching: Whether to enable local caching.
+            Environment variable: ARIZE_ENABLE_CACHING.
+            Default: True.
+        region: Arize region (e.g., US_CENTRAL, EU_WEST). When specified, overrides
+            individual host/port settings.
+            Environment variable: ARIZE_REGION.
+            Default: Region.UNSPECIFIED.
+        single_host: Single host to use for all endpoints. Overrides individual host settings.
+            Environment variable: ARIZE_SINGLE_HOST.
+            Default: "" (not set).
+        single_port: Single port to use for all endpoints. Overrides individual port settings (0-65535).
+            Environment variable: ARIZE_SINGLE_PORT.
+            Default: 0 (not set).
+    """
+
+    api_key: str = field(
+        default_factory=lambda: _env_str(ENV_API_KEY, ""),
+    )
+    api_host: str = field(
+        default_factory=lambda: _env_str(ENV_API_HOST, DEFAULT_API_HOST)
+    )
+    api_scheme: str = field(
+        default_factory=lambda: _env_http_scheme(
+            ENV_API_SCHEME,
+            DEFAULT_API_SCHEME,
+        ),
+    )
+    otlp_host: str = field(
+        default_factory=lambda: _env_str(ENV_OTLP_HOST, DEFAULT_OTLP_HOST)
+    )
+    otlp_scheme: str = field(
+        default_factory=lambda: _env_http_scheme(
+            ENV_OTLP_SCHEME,
+            DEFAULT_OTLP_SCHEME,
+        ),
+    )
+    flight_host: str = field(
+        default_factory=lambda: _env_str(ENV_FLIGHT_HOST, DEFAULT_FLIGHT_HOST)
+    )
+    flight_port: int = field(
+        default_factory=lambda: _env_int(
+            ENV_FLIGHT_PORT, DEFAULT_FLIGHT_PORT, min_val=1, max_val=65535
+        )
+    )
+    flight_scheme: str = field(
+        default_factory=lambda: _env_str(
+            ENV_FLIGHT_SCHEME,
+            DEFAULT_FLIGHT_SCHEME,
+        ),
+    )
+    pyarrow_max_chunksize: int = field(
+        default_factory=lambda: _env_int(
+            ENV_PYARROW_MAX_CHUNKSIZE,
+            DEFAULT_PYARROW_MAX_CHUNKSIZE,
+            min_val=1,
+            max_val=MAX_CHUNKSIZE,
+        )
+    )
+    request_verify: bool = field(
+        default_factory=lambda: _env_bool(
+            ENV_REQUEST_VERIFY, DEFAULT_REQUEST_VERIFY
+        )
+    )
+    stream_max_workers: int = field(
+        default_factory=lambda: _env_int(
+            ENV_STREAM_MAX_WORKERS, DEFAULT_STREAM_MAX_WORKERS, min_val=1
+        )
+    )
     stream_max_queue_bound: int = field(
-        default_factory=_stream_max_queue_bound_factory
+        default_factory=lambda: _env_int(
+            ENV_STREAM_MAX_QUEUE_BOUND,
+            DEFAULT_STREAM_MAX_QUEUE_BOUND,
+            min_val=1,
+        )
     )
     max_http_payload_size_mb: float = field(
-        default_factory=_max_http_payload_size_mb_factory
+        default_factory=lambda: _env_float(
+            ENV_MAX_HTTP_PAYLOAD_SIZE_MB,
+            DEFAULT_MAX_HTTP_PAYLOAD_SIZE_MB,
+            min_val=1,
+        )
+    )
+    arize_directory: str = field(
+        default_factory=lambda: _env_str(
+            ENV_ARIZE_DIRECTORY, DEFAULT_ARIZE_DIRECTORY
+        )
+    )
+    enable_caching: bool = field(
+        default_factory=lambda: _env_bool(
+            ENV_ENABLE_CACHING, DEFAULT_ENABLE_CACHING
+        )
+    )
+    region: Region = field(
+        default_factory=lambda: Region(_env_str(ENV_REGION, ""))
+    )
+    single_host: str = field(
+        default_factory=lambda: _env_str(ENV_SINGLE_HOST, "")
+    )
+    single_port: int = field(
+        default_factory=lambda: _env_int(
+            ENV_SINGLE_PORT, 0, min_val=0, max_val=65535
+        )
     )
-    arize_direcory: str = field(default_factory=_arize_dir_factory)
-    enable_caching: bool = field(default_factory=_enable_cache_factory)
 
     # Private, excluded from comparisons & repr
-    _headers: Dict[str, str] = field(init=False, repr=False, compare=False)
     _gen_client: Any = field(default=None, repr=False, compare=False)
     _gen_lock: threading.Lock = field(
         default_factory=threading.Lock, repr=False, compare=False
     )
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
+        """Validate and configure SDK endpoints after initialization.
+
+        Raises:
+            MissingAPIKeyError: If API key is not provided.
+        """
         # Validate Configuration
         if not self.api_key:
             raise MissingAPIKeyError()
 
+        has_single_host = bool(self.single_host)
+        has_single_port = self.single_port != 0
+        has_region = self.region is not Region.UNSPECIFIED
+        if (has_single_host or has_single_port) and has_region:
+            logger.info(
+                "Multiple endpoint override options provided. Preference order is: "
+                "region > single_host/single_port > per-endpoint host/port."
+            )
+
+        # Single host override: if single_host is set, it overrides hosts
+        if has_single_host:
+            logger.info(
+                "Single host %r provided; overriding hosts configuration with single host.",
+                self.single_host,
+            )
+            object.__setattr__(self, "api_host", self.single_host)
+            object.__setattr__(self, "otlp_host", self.single_host)
+            object.__setattr__(self, "flight_host", self.single_host)
+
+        # Single port override: if single_port is set, it overrides ports
+        if has_single_port:
+            logger.info(
+                "Single port %s provided; overriding ports configuration with single port.",
+                self.single_port,
+            )
+            object.__setattr__(self, "flight_port", self.single_port)
+
+        # Region override: if region is set, it *always* wins over host/port fields
+        if has_region:
+            endpoints = REGION_ENDPOINTS[self.region]
+
+            # Override config (region trumps everything)
+            logger.info(
+                "Region %s provided; overriding hosts & ports configuration with region defaults.",
+                self.region.value,
+            )
+            object.__setattr__(self, "api_host", endpoints.api_host)
+            object.__setattr__(self, "otlp_host", endpoints.otlp_host)
+            object.__setattr__(self, "flight_host", endpoints.flight_host)
+            object.__setattr__(self, "flight_port", endpoints.flight_port)
+
     @property
     def cache_dir(self) -> str:
-        return str(Path(self.arize_direcory) / "cache")
+        """Return the path to the cache directory."""
+        return str(Path(self.arize_directory) / "cache")
 
     @property
     def api_url(self) -> str:
+        """Return the base API URL."""
         return _endpoint(self.api_scheme, self.api_host)
 
     @property
     def otlp_url(self) -> str:
+        """Return the OTLP endpoint URL."""
         return _endpoint(self.otlp_scheme, self.otlp_host, "/v1")
 
     @property
     def files_url(self) -> str:
+        """Return the files upload endpoint URL."""
         return _endpoint(self.api_scheme, self.api_host, "/v1/pandas_arrow")
 
     @property
     def records_url(self) -> str:
+        """Return the records logging endpoint URL."""
         return _endpoint(self.api_scheme, self.api_host, "/v1/log")
 
     @property
-    def headers(self) -> Dict[str, str]:
+    def headers(self) -> dict[str, str]:
+        """Return HTTP headers for API requests."""
         # Create base headers
         return {
             "authorization": self.api_key,
             "sdk-language": "python",
-            "language-version": get_python_version(),
+            "language-version": PYTHON_VERSION,
             "sdk-version": __version__,
             # "arize-space-id": self._space_id,
             # "arize-interface": "batch",
@@ -209,31 +420,34 @@ class SDKConfiguration:
         }
 
     @property
-    def headers_grpc(self) -> Dict[str, str]:
+    def headers_grpc(self) -> dict[str, str]:
+        """Return headers for gRPC requests."""
         return {
             "authorization": self.api_key,
             "Grpc-Metadata-sdk-language": "python",
-            "Grpc-Metadata-language-version": get_python_version(),
+            "Grpc-Metadata-language-version": PYTHON_VERSION,
             "Grpc-Metadata-sdk-version": __version__,
             # "Grpc-Metadata-arize-space-id": space_id,
             # "Grpc-Metadata-arize-interface": "stream",
         }
 
     def __repr__(self) -> str:
+        """Return a detailed string representation with masked sensitive fields."""
         # Dynamically build repr for all fields
         lines = [f"{self.__class__.__name__}("]
         for f in fields(self):
             if not f.repr:
                 continue
             val = getattr(self, f.name)
-            if f.name == "api_key":
+            if _is_sensitive_field(f.name):
                 val = _mask_secret(val, 6)
             lines.append(f"  {f.name}={val!r},")
         lines.append(")")
         return "\n".join(lines)
 
     # TODO(Kiko): This may not be well placed in this class
-    def get_generated_client(self):
+    def get_generated_client(self) -> object:
+        """Get or create the generated OpenAPI client instance."""
         # If already cached, return immediately
         if self._gen_client is not None:
             return self._gen_client
@@ -243,21 +457,15 @@ class SDKConfiguration:
             if self._gen_client is not None:
                 return self._gen_client
 
-            # Import lazily so extras can be enforced outside
+            # Import lazily so extra dependencies can be
+            # enforced outside the configuration class
             from arize._generated import api_client as gen
 
             cfg = gen.Configuration(host=self.api_url)
             if self.api_key:
-                cfg.api_key["ApiKeyAuth"] = self.api_key
+                cfg.access_token = self.api_key
             client = gen.ApiClient(cfg)
 
             # Bypass frozen to set the cache once
             object.__setattr__(self, "_gen_client", client)
             return client
-
-
-def get_python_version():
-    return (
-        f"{sys.version_info.major}.{sys.version_info.minor}."
-        f"{sys.version_info.micro}"
-    )

arize/constants/__init__.py

@@ -0,0 +1 @@
+"""Constants and configuration values used across the Arize SDK."""

arize/constants/config.py

@@ -1,28 +1,35 @@
+"""Configuration constants and environment variable names."""
+
 # Authentication
 ENV_API_KEY = "ARIZE_API_KEY"
 
 # Server configuration env vars
+ENV_REGION = "ARIZE_REGION"
 ENV_API_HOST = "ARIZE_API_HOST"
+ENV_API_SCHEME = "ARIZE_API_SCHEME"
 ENV_OTLP_HOST = "ARIZE_OTLP_HOST"
+ENV_OTLP_SCHEME = "ARIZE_OTLP_SCHEME"
 ENV_FLIGHT_HOST = "ARIZE_FLIGHT_HOST"
 ENV_FLIGHT_PORT = "ARIZE_FLIGHT_PORT"
-ENV_FLIGHT_TRANSPORT_SCHEME = "ARIZE_FLIGHT_TRANSPORT_SCHEME"
+ENV_FLIGHT_SCHEME = "ARIZE_FLIGHT_SCHEME"
+ENV_SINGLE_HOST = "ARIZE_SINGLE_HOST"
+ENV_SINGLE_PORT = "ARIZE_SINGLE_PORT"
 ENV_PYARROW_MAX_CHUNKSIZE = "ARIZE_MAX_CHUNKSIZE"
 ENV_REQUEST_VERIFY = "ARIZE_REQUEST_VERIFY"
-ENV_INSECURE = "ARIZE_INSECURE"
 ENV_MAX_HTTP_PAYLOAD_SIZE_MB = "ARIZE_MAX_HTTP_PAYLOAD_SIZE_MB"
 ENV_ARIZE_DIRECTORY = "ARIZE_DIRECTORY"
 ENV_ENABLE_CACHING = "ARIZE_ENABLE_CACHING"
 
 # Server configuration default values
 DEFAULT_API_HOST = "api.arize.com"  # NOTE: Must not prefix with https://
+DEFAULT_API_SCHEME = "https"
 DEFAULT_OTLP_HOST = "otlp.arize.com"  # NOTE: Must not prefix with https://
+DEFAULT_OTLP_SCHEME = "https"
 DEFAULT_FLIGHT_HOST = "flight.arize.com"  # NOTE: Must not prefix with https://
 DEFAULT_FLIGHT_PORT = 443
-DEFAULT_FLIGHT_TRANSPORT_SCHEME = "grpc+tls"
+DEFAULT_FLIGHT_SCHEME = "grpc+tls"
 DEFAULT_PYARROW_MAX_CHUNKSIZE = 10_000
 DEFAULT_REQUEST_VERIFY = True
-DEFAULT_INSECURE = False
 DEFAULT_MAX_HTTP_PAYLOAD_SIZE_MB = 100
 DEFAULT_ARIZE_DIRECTORY = "~/.arize"
 DEFAULT_ENABLE_CACHING = True

arize/constants/ml.py

@@ -1,3 +1,5 @@
+"""Machine learning constants and validation limits."""
+
 import json
 from pathlib import Path
 
@@ -30,7 +32,7 @@ MAX_PROMPT_TEMPLATE_VERSION_LENGTH_TRUNCATION = 50
 MAX_NUMBER_OF_EMBEDDINGS = 30
 MAX_EMBEDDING_DIMENSIONALITY = 20_000
 # # The maximum number of classes for multi class
-MAX_NUMBER_OF_MULTI_CLASS_CLASSES = 300
+MAX_NUMBER_OF_MULTI_CLASS_CLASSES = 500
 MAX_MULTI_CLASS_NAME_LENGTH = 100
 # The maximum number of references in embedding similarity search params
 MAX_NUMBER_OF_SIMILARITY_REFERENCES = 10
@@ -40,9 +42,9 @@ MAX_NUMBER_OF_SIMILARITY_REFERENCES = 10
 # GENERATED_LLM_PARAMS_JSON_COL = "arize_generated_llm_params_json"
 #
 # # reserved columns for LLM run metadata
-LLM_RUN_METADATA_TOTAL_TOKEN_COUNT_TAG_NAME = "total_token_count"
-LLM_RUN_METADATA_PROMPT_TOKEN_COUNT_TAG_NAME = "prompt_token_count"
-LLM_RUN_METADATA_RESPONSE_TOKEN_COUNT_TAG_NAME = "response_token_count"
+LLM_RUN_METADATA_TOTAL_TOKEN_COUNT_TAG_NAME = "total_token_count"  # noqa: S105
+LLM_RUN_METADATA_PROMPT_TOKEN_COUNT_TAG_NAME = "prompt_token_count"  # noqa: S105
+LLM_RUN_METADATA_RESPONSE_TOKEN_COUNT_TAG_NAME = "response_token_count"  # noqa: S105
 LLM_RUN_METADATA_RESPONSE_LATENCY_MS_TAG_NAME = "response_latency_ms"
 #
 # all reserved tags

arize/constants/openinference.py

@@ -1,3 +1,5 @@
+"""OpenInference semantic convention constants and attribute definitions."""
+
 import openinference.semconv.trace as oinf
 
 OPEN_INFERENCE_JSON_STR_TYPES = frozenset(

arize/constants/pyarrow.py

@@ -1 +1,3 @@
+"""PyArrow-related constants for data processing."""
+
 MAX_CHUNKSIZE = 100_000

arize/constants/spans.py

@@ -1,4 +1,6 @@
-# The defualt format used to parse datetime objects from strings
+"""Span-related constants and validation limits for tracing."""
+
+# The default format used to parse datetime objects from strings
 DEFAULT_DATETIME_FMT = "%Y-%m-%dT%H:%M:%S.%f+00:00"
 # Minumum/Maximum number of characters for span/trace/parent ids in spans
 SPAN_ID_MIN_STR_LENGTH = 12

arize/datasets/__init__.py

@@ -0,0 +1 @@
+"""Dataset management and validation utilities for the Arize SDK."""