arize 8.0.0b1__py3-none-any.whl → 8.0.0b4__py3-none-any.whl

arize/experiments/types.py

@@ -11,6 +11,7 @@ from datetime import datetime, timezone
 from importlib.metadata import version
 from random import getrandbits
 from typing import (
+    NoReturn,
     cast,
 )
 
@@ -23,8 +24,6 @@ from arize.experiments.evaluators.types import (
 )
 
 ExperimentId = str
-# DatasetId= str
-# DatasetVersionId= str
 ExampleId = str
 RepetitionNumber = int
 ExperimentRunId = str
@@ -92,11 +91,13 @@ class Example:
     def from_dict(cls, obj: Mapping[str, object]) -> Example:
         """Create an Example instance from a dictionary."""
         return cls(
-            id=obj["id"],
-            input=obj["input"],
-            output=obj["output"],
-            metadata=obj.get("metadata") or {},
-            updated_at=obj["updated_at"],
+            id=cast("str", obj["id"]),
+            input=cast("Mapping[str, JSONSerializable]", obj["input"]),
+            output=cast("Mapping[str, JSONSerializable]", obj["output"]),
+            metadata=cast(
+                "Mapping[str, JSONSerializable]", obj.get("metadata") or {}
+            ),
+            updated_at=cast("datetime", obj["updated_at"]),
         )
 
     def __repr__(self) -> str:
@@ -150,7 +151,7 @@ def _make_read_only(
     return obj
 
 
-class _ReadOnly(ObjectProxy):  # type: ignore[misc]
+class _ReadOnly(ObjectProxy):
     def __setitem__(self, *args: object, **kwargs: object) -> object:
         raise NotImplementedError
 
@@ -229,15 +230,15 @@ class ExperimentRun:
     def from_dict(cls, obj: Mapping[str, object]) -> ExperimentRun:
         """Create an ExperimentRun instance from a dictionary."""
         return cls(
-            start_time=obj["start_time"],
-            end_time=obj["end_time"],
-            experiment_id=obj["experiment_id"],
-            dataset_example_id=obj["dataset_example_id"],
-            repetition_number=obj.get("repetition_number") or 1,
-            output=_make_read_only(obj.get("output")),
-            error=obj.get("error"),
-            id=obj["id"],
-            trace_id=obj.get("trace_id"),
+            start_time=cast("datetime", obj["start_time"]),
+            end_time=cast("datetime", obj["end_time"]),
+            experiment_id=cast("str", obj["experiment_id"]),
+            dataset_example_id=cast("str", obj["dataset_example_id"]),
+            repetition_number=cast("int", obj.get("repetition_number") or 1),
+            output=cast("JSONSerializable", _make_read_only(obj.get("output"))),
+            error=cast("str | None", obj.get("error")),
+            id=cast("str", obj["id"]),
+            trace_id=cast("str | None", obj.get("trace_id")),
         )
 
     def __post_init__(self) -> None:
@@ -263,9 +264,9 @@ class ExperimentEvaluationRun:
         name: The name of the evaluation run.
         annotator_kind: The kind of annotator used in the evaluation run.
         error: The error message if the evaluation run failed.
-        result (Optional[EvaluationResult]): The result of the evaluation run.
+        result (EvaluationResult | :obj:`None`): The result of the evaluation run.
         id (str): The unique identifier for the evaluation run.
-        trace_id (Optional[TraceId]): The trace identifier for the evaluation run.
+        trace_id (TraceId | :obj:`None`): The trace identifier for the evaluation run.
     """
 
     experiment_run_id: ExperimentRunId
@@ -282,15 +283,17 @@ class ExperimentEvaluationRun:
     def from_dict(cls, obj: Mapping[str, object]) -> ExperimentEvaluationRun:
         """Create an ExperimentEvaluationRun instance from a dictionary."""
         return cls(
-            experiment_run_id=obj["experiment_run_id"],
-            start_time=obj["start_time"],
-            end_time=obj["end_time"],
-            name=obj["name"],
-            annotator_kind=obj["annotator_kind"],
-            error=obj.get("error"),
-            result=EvaluationResult.from_dict(obj.get("result")),
-            id=obj["id"],
-            trace_id=obj.get("trace_id"),
+            experiment_run_id=cast("str", obj["experiment_run_id"]),
+            start_time=cast("datetime", obj["start_time"]),
+            end_time=cast("datetime", obj["end_time"]),
+            name=cast("str", obj["name"]),
+            annotator_kind=cast("str", obj["annotator_kind"]),
+            error=cast("str | None", obj.get("error")),
+            result=EvaluationResult.from_dict(
+                cast("Mapping[str, object] | None", obj.get("result"))
+            ),
+            id=cast("str", obj["id"]),
+            trace_id=cast("str | None", obj.get("trace_id")),
         )
 
     def __post_init__(self) -> None:
@@ -336,7 +339,7 @@ class _HasStats:
             text = self.stats.__str__()
         else:
             text = self.stats.to_markdown(index=False)
-        return f"{self.title}\n{'-' * len(self.title)}\n" + text  # type: ignore
+        return f"{self.title}\n{'-' * len(self.title)}\n" + text
 
 
 @dataclass(frozen=True)
@@ -380,7 +383,7 @@ class _TaskSummary(_HasStats):
         return summary
 
     @classmethod
-    def __new__(cls, *args: object, **kwargs: object) -> object:
+    def __new__(cls, *args: object, **kwargs: object) -> NoReturn:
         # Direct instantiation by users is discouraged.
         raise NotImplementedError
 
@@ -398,7 +401,7 @@ def _top_string(s: pd.Series, length: int = 100) -> str | None:
 
 @dataclass
 class ExperimentTaskFieldNames:
-    """Column names for mapping experiment task results in a DataFrame.
+    """Column names for mapping experiment task results in a :class:`pandas.DataFrame`.
 
     Args:
         example_id: Name of column containing example IDs.

arize/logging.py

@@ -6,8 +6,11 @@ import json
 import logging
 import os
 import sys
-from collections.abc import Iterable, Mapping
-from typing import Any, ClassVar
+from collections.abc import Iterable, Mapping, MutableMapping
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    import requests
 
 from arize.config import _parse_bool
 from arize.constants.config import (
@@ -34,9 +37,18 @@ class CtxAdapter(logging.LoggerAdapter):
     """LoggerAdapter that merges bound context with per-call extras safely."""
 
     def process(
-        self, msg: object, kwargs: dict[str, object]
-    ) -> tuple[object, dict[str, object]]:
-        """Process the logging call by merging bound and call extras."""
+        self, msg: object, kwargs: MutableMapping[str, Any]
+    ) -> tuple[object, MutableMapping[str, Any]]:
+        """Process the logging call by merging bound and call extras.
+
+        Args:
+            msg: The log message to process.
+            kwargs: Keyword arguments from the logging call, may include 'extra' dict.
+
+        Returns:
+            tuple[object, dict[str, object]]: A tuple of (message, modified_kwargs) with
+                merged extra context.
+        """
         call_extra = _coerce_mapping(kwargs.pop("extra", None))
         bound_extra = _coerce_mapping(self.extra)
         merged = (
@@ -49,13 +61,24 @@ class CtxAdapter(logging.LoggerAdapter):
         return msg, kwargs
 
     def with_extra(self, **more: object) -> CtxAdapter:
-        """Return a copy of this adapter with additional bound extras."""
+        """Return a copy of this adapter with additional bound extras.
+
+        Args:
+            **more: Additional key-value pairs to merge into the bound extras.
+
+        Returns:
+            CtxAdapter: A new adapter instance with merged extra context.
+        """
         base = _coerce_mapping(self.extra)
         base.update(_coerce_mapping(more))
         return type(self)(self.logger, base)
 
     def without_extra(self) -> CtxAdapter:
-        """Return a copy of this adapter with *no* bound extras."""
+        """Return a copy of this adapter with *no* bound extras.
+
+        Returns:
+            CtxAdapter: A new adapter instance without any bound extra context.
+        """
         return type(self)(self.logger, None)
 
 
@@ -86,7 +109,14 @@ class CustomLogFormatter(logging.Formatter):
         super().__init__(fmt=fmt)
 
     def format(self, record: logging.LogRecord) -> str:
-        """Format the log record with color based on log level."""
+        """Format the log record with color based on log level.
+
+        Args:
+            record: The log record to format.
+
+        Returns:
+            str: Formatted and color-coded log message with any extra fields appended.
+        """
         # Build the base message without any color.
         base = super().format(record)
 
@@ -113,31 +143,22 @@ class JsonFormatter(logging.Formatter):
     """Minimal JSON formatter (one JSON object per line)."""
 
     # fields to skip copying from record.__dict__
-    _skip: ClassVar[set[str]] = {
-        # "name",
-        # "msg",
-        # "args",
-        # "levelname",
-        # "levelno",
-        # "pathname",
-        # "filename",
-        # "module",
-        # "exc_info",
-        # "exc_text",
-        # "stack_info",
-        # "lineno",
-        # "funcName",
-        # "created",
-        # "msecs",
-        # "relativeCreated",
-        # "thread",
-        # "threadName",
-        # "processName",
-        # "process",
-    }
+    _skip: ClassVar[set[str]] = set()
+    # Potential fields to skip:
+    # "name", "msg", "args", "levelname", "levelno", "pathname",
+    # "filename", "module", "exc_info", "exc_text", "stack_info",
+    # "lineno", "funcName", "created", "msecs", "relativeCreated",
+    # "thread", "threadName", "processName", "process"
 
     def format(self, record: logging.LogRecord) -> str:
-        """Format the log record as a JSON string."""
+        """Format the log record as a JSON string.
+
+        Args:
+            record: The log record to format.
+
+        Returns:
+            str: JSON-formatted log message as a single line with all fields and extras.
+        """
         payload: dict[str, object] = {
             # "time": self.formatTime(record, datefmt="%Y-%m-%dT%H:%M:%S%z"),
             # "logger": record.name,
@@ -259,7 +280,7 @@ def log_a_list(values: Iterable[Any] | None, join_word: str) -> str:
     """Format a list of values into a human-readable string with a joining word.
 
     Args:
-        values: An iterable of values to format, or None.
+        values: An iterable of values to format, or :obj:`None`.
         join_word: The word to use before the last item (e.g., "and", "or").
 
     Returns:
@@ -277,7 +298,7 @@ def log_a_list(values: Iterable[Any] | None, join_word: str) -> str:
     )
 
 
-def get_arize_project_url(response: object) -> str:
+def get_arize_project_url(response: requests.Response) -> str:
     """Extract the Arize project URL from an API response.
 
     Args: