arize-phoenix 3.19.4__py3-none-any.whl → 3.21.0__py3-none-any.whl

phoenix/inferences/schema.py

@@ -0,0 +1,151 @@
+import json
+from dataclasses import asdict, dataclass, replace
+from typing import Any, Dict, List, Mapping, Optional, Tuple, Union
+
+EmbeddingFeatures = Dict[str, "EmbeddingColumnNames"]
+SchemaFieldName = str
+SchemaFieldValue = Union[Optional[str], Optional[List[str]], Optional[EmbeddingFeatures]]
+
+MULTI_COLUMN_SCHEMA_FIELD_NAMES: Tuple[str, ...] = ("feature_column_names", "tag_column_names")
+SINGLE_COLUMN_SCHEMA_FIELD_NAMES: Tuple[str, ...] = (
+    "prediction_id_column_name",
+    "timestamp_column_name",
+    "prediction_label_column_name",
+    "prediction_score_column_name",
+    "actual_label_column_name",
+    "actual_score_column_name",
+)
+LLM_SCHEMA_FIELD_NAMES = ["prompt_column_names", "response_column_names"]
+
+
+@dataclass(frozen=True)
+class EmbeddingColumnNames(Dict[str, Any]):
+    """
+    A dataclass to hold the column names for the embedding features.
+    An embedding feature is a feature that is represented by a vector.
+    The vector is a representation of unstructured data, such as text or an image
+    """
+
+    vector_column_name: str
+    raw_data_column_name: Optional[str] = None
+    link_to_data_column_name: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class RetrievalEmbeddingColumnNames(EmbeddingColumnNames):
+    """
+    A relationship is a column that maps a prediction to another record.
+
+    Example
+    -------
+    For example, in context retrieval from a vector store, a query is
+    embedded and used to search for relevant records in a vector store.
+    In this case you would add a column to the dataset that maps the query
+    to the vector store records. E.x. [document_1, document_5, document_3]
+
+    A table view of the primary dataset could look like this:
+
+    | query | retrieved_document_ids | document_relevance_scores |
+    |-------|------------------------|---------------------------|
+    | ...   | [doc_1, doc_5, doc_3]  | [0.4567, 0.3456, 0.2345]  |
+    | ...   | [doc_1, doc_6, doc_2]  | [0.7890, 0.6789, 0.5678]  |
+    | ...   | [doc_1, doc_6, doc_9]  | [0.9012, 0.8901, 0.0123]  |
+
+
+    The corresponding vector store dataset would look like this:
+
+    |    id    | embedding_vector | document_text |
+    |----------|------------------|---------------|
+    | doc_1    | ...              | lorem ipsum   |
+    | doc_2    | ...              | lorem ipsum   |
+    | doc_3    | ...              | lorem ipsum   |
+
+
+    To declare this relationship in the schema, you would configure the schema as follows:
+
+    >>> schema = Schema(
+    ...     prompt_column_names=RetrievalEmbeddingColumnNames(
+    ...         context_retrieval_ids_column_name="retrieved_document_ids",
+    ...         context_retrieval_scores_column_name="document_relevance_scores",
+    ...     )
+    ...)
+    """
+
+    context_retrieval_ids_column_name: Optional[str] = None
+    context_retrieval_scores_column_name: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class Schema:
+    prediction_id_column_name: Optional[str] = None
+    id_column_name: Optional[str] = None  # Syntax sugar for prediction_id_column_name
+    timestamp_column_name: Optional[str] = None
+    feature_column_names: Optional[List[str]] = None
+    tag_column_names: Optional[List[str]] = None
+    prediction_label_column_name: Optional[str] = None
+    prediction_score_column_name: Optional[str] = None
+    actual_label_column_name: Optional[str] = None
+    actual_score_column_name: Optional[str] = None
+    prompt_column_names: Optional[Union[EmbeddingColumnNames, RetrievalEmbeddingColumnNames]] = None
+    response_column_names: Optional[Union[str, EmbeddingColumnNames]] = None
+    # document_column_names is used explicitly when the schema is used to capture a corpus
+    document_column_names: Optional[EmbeddingColumnNames] = None
+    embedding_feature_column_names: Optional[EmbeddingFeatures] = None
+    excluded_column_names: Optional[List[str]] = None
+
+    def __post_init__(self) -> None:
+        # re-map document_column_names to be in the prompt_column_names position
+        # This is a shortcut to leverage the same schema for model and corpus datasets
+        if self.document_column_names is not None:
+            object.__setattr__(self, "prompt_column_names", self.document_column_names)
+            object.__setattr__(self, "document_column_names", None)
+
+        if self.id_column_name is not None:
+            object.__setattr__(self, "prediction_id_column_name", self.id_column_name)
+            object.__setattr__(self, "id_column_name", None)
+
+    def replace(self, **changes: Any) -> "Schema":
+        return replace(self, **changes)
+
+    def asdict(self) -> Dict[str, str]:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        "Converts the schema to a dict for JSON serialization"
+        return json.dumps(asdict(self))
+
+    @classmethod
+    def from_json(cls, json_string: str) -> "Schema":
+        json_data = json.loads(json_string)
+
+        # parse embedding_feature_column_names
+        if json_data.get("embedding_feature_column_names") is not None:
+            embedding_feature_column_names = {}
+            for feature_name, column_names in json_data["embedding_feature_column_names"].items():
+                embedding_feature_column_names[feature_name] = EmbeddingColumnNames(
+                    vector_column_name=column_names["vector_column_name"],
+                    raw_data_column_name=column_names["raw_data_column_name"],
+                    link_to_data_column_name=column_names["link_to_data_column_name"],
+                )
+            json_data["embedding_feature_column_names"] = embedding_feature_column_names
+
+        # parse prompt_column_names
+        if (prompt := json_data.get("prompt_column_names")) is not None:
+            json_data["prompt_column_names"] = RetrievalEmbeddingColumnNames(
+                vector_column_name=prompt.get("vector_column_name"),
+                raw_data_column_name=prompt.get("raw_data_column_name"),
+                context_retrieval_ids_column_name=prompt.get("context_retrieval_ids_column_name"),
+                context_retrieval_scores_column_name=prompt.get(
+                    "context_retrieval_scores_column_name"
+                ),
+            )
+
+        # parse response_column_names
+        if isinstance(json_data.get("response_column_names"), Mapping):
+            response_column_names = EmbeddingColumnNames(
+                vector_column_name=json_data["response_column_names"]["vector_column_name"],
+                raw_data_column_name=json_data["response_column_names"]["raw_data_column_name"],
+            )
+            json_data["response_column_names"] = response_column_names
+
+        return cls(**json_data)

phoenix/server/app.py

@@ -142,6 +142,10 @@ async def version(_: Request) -> PlainTextResponse:
     return PlainTextResponse(f"{phoenix.__version__}")
 
 
+async def check_healthz(_: Request) -> PlainTextResponse:
+    return PlainTextResponse("OK")
+
+
 def create_app(
     export_path: Path,
     model: Model,
@@ -193,6 +197,7 @@ def create_app(
         )
         + [
             Route("/arize_phoenix_version", version),
+            Route("/healthz", check_healthz),
             Route(
                 "/exports",
                 type(

phoenix/server/main.py

@@ -19,8 +19,8 @@ from phoenix.config import (
 )
 from phoenix.core.model_schema_adapter import create_model_from_datasets
 from phoenix.core.traces import Traces
-from phoenix.datasets.dataset import EMPTY_DATASET, Dataset
-from phoenix.datasets.fixtures import FIXTURES, get_datasets
+from phoenix.inferences.fixtures import FIXTURES, get_datasets
+from phoenix.inferences.inferences import EMPTY_INFERENCES, Inferences
 from phoenix.pointcloud.umap_parameters import (
     DEFAULT_MIN_DIST,
     DEFAULT_N_NEIGHBORS,
@@ -114,9 +114,9 @@ if __name__ == "__main__":
     trace_dataset_name: Optional[str] = None
     simulate_streaming: Optional[bool] = None
 
-    primary_dataset: Dataset = EMPTY_DATASET
-    reference_dataset: Optional[Dataset] = None
-    corpus_dataset: Optional[Dataset] = None
+    primary_dataset: Inferences = EMPTY_INFERENCES
+    reference_dataset: Optional[Inferences] = None
+    corpus_dataset: Optional[Inferences] = None
 
     # automatically remove the pid file when the process is being gracefully terminated
     atexit.register(_remove_pid_file)
@@ -158,14 +158,14 @@ if __name__ == "__main__":
         primary_dataset_name = args.primary
         reference_dataset_name = args.reference
         corpus_dataset_name = args.corpus
-        primary_dataset = Dataset.from_name(primary_dataset_name)
+        primary_dataset = Inferences.from_name(primary_dataset_name)
         reference_dataset = (
-            Dataset.from_name(reference_dataset_name)
+            Inferences.from_name(reference_dataset_name)
             if reference_dataset_name is not None
             else None
         )
         corpus_dataset = (
-            None if corpus_dataset_name is None else Dataset.from_name(corpus_dataset_name)
+            None if corpus_dataset_name is None else Inferences.from_name(corpus_dataset_name)
         )
     elif args.command == "fixture":
         fixture_name = args.fixture

phoenix/session/evaluation.py

@@ -1,5 +1,5 @@
 """
-A set of **highly experimental** helper functions to
+A set of helper functions to
   - extract spans from Phoenix for evaluation
     - explode retrieved documents from (horizontal) lists to a (vertical) series
       indexed by `context.span_id` and `document_position`
@@ -73,7 +73,6 @@ def _extract_subject_id_from_index(
     value: Union[str, Sequence[Any]],
 ) -> pb.Evaluation.SubjectId:
     """
-    (**Highly Experimental**)
     Returns `SubjectId` given the format of `index_names`. Allowed formats are:
         - DocumentRetrievalId
             - index_names=["context.span_id", "document_position"]

phoenix/session/session.py

@@ -36,7 +36,7 @@ from phoenix.config import (
 )
 from phoenix.core.model_schema_adapter import create_model_from_datasets
 from phoenix.core.traces import Traces
-from phoenix.datasets.dataset import EMPTY_DATASET, Dataset
+from phoenix.inferences.inferences import EMPTY_INFERENCES, Inferences
 from phoenix.pointcloud.umap_parameters import get_umap_parameters
 from phoenix.server.app import create_app
 from phoenix.server.thread_server import ThreadServer
@@ -104,9 +104,9 @@ class Session(TraceDataExtractor, ABC):
 
     def __init__(
         self,
-        primary_dataset: Dataset,
-        reference_dataset: Optional[Dataset] = None,
-        corpus_dataset: Optional[Dataset] = None,
+        primary_dataset: Inferences,
+        reference_dataset: Optional[Inferences] = None,
+        corpus_dataset: Optional[Inferences] = None,
         trace_dataset: Optional[TraceDataset] = None,
         default_umap_parameters: Optional[Mapping[str, Any]] = None,
         host: Optional[str] = None,
@@ -194,9 +194,9 @@ _session: Optional[Session] = None
 class ProcessSession(Session):
     def __init__(
         self,
-        primary_dataset: Dataset,
-        reference_dataset: Optional[Dataset] = None,
-        corpus_dataset: Optional[Dataset] = None,
+        primary_dataset: Inferences,
+        reference_dataset: Optional[Inferences] = None,
+        corpus_dataset: Optional[Inferences] = None,
         trace_dataset: Optional[TraceDataset] = None,
         default_umap_parameters: Optional[Mapping[str, Any]] = None,
         host: Optional[str] = None,
@@ -215,9 +215,9 @@ class ProcessSession(Session):
             notebook_env=notebook_env,
         )
         primary_dataset.to_disc()
-        if isinstance(reference_dataset, Dataset):
+        if isinstance(reference_dataset, Inferences):
             reference_dataset.to_disc()
-        if isinstance(corpus_dataset, Dataset):
+        if isinstance(corpus_dataset, Inferences):
             corpus_dataset.to_disc()
         if isinstance(trace_dataset, TraceDataset):
             trace_dataset.to_disc()
@@ -284,9 +284,9 @@ class ProcessSession(Session):
 class ThreadSession(Session):
     def __init__(
         self,
-        primary_dataset: Dataset,
-        reference_dataset: Optional[Dataset] = None,
-        corpus_dataset: Optional[Dataset] = None,
+        primary_dataset: Inferences,
+        reference_dataset: Optional[Inferences] = None,
+        corpus_dataset: Optional[Inferences] = None,
         trace_dataset: Optional[TraceDataset] = None,
         default_umap_parameters: Optional[Mapping[str, Any]] = None,
         host: Optional[str] = None,
@@ -424,9 +424,9 @@ class ThreadSession(Session):
 
 
 def launch_app(
-    primary: Optional[Dataset] = None,
-    reference: Optional[Dataset] = None,
-    corpus: Optional[Dataset] = None,
+    primary: Optional[Inferences] = None,
+    reference: Optional[Inferences] = None,
+    corpus: Optional[Inferences] = None,
     trace: Optional[TraceDataset] = None,
     default_umap_parameters: Optional[Mapping[str, Any]] = None,
     host: Optional[str] = None,
@@ -447,7 +447,7 @@ def launch_app(
     corpus : Dataset, optional
         The dataset containing corpus for LLM context retrieval.
     trace: TraceDataset, optional
-        **Experimental** The trace dataset containing the trace data.
+        The trace dataset containing the trace data.
     host: str, optional
         The host on which the server runs. It can also be set using environment
         variable `PHOENIX_HOST`, otherwise it defaults to `127.0.0.1`.
@@ -473,17 +473,17 @@ def launch_app(
     Examples
     --------
     >>> import phoenix as px
-    >>> # construct a dataset to analyze
-    >>> dataset = px.Dataset(...)
-    >>> session = px.launch_app(dataset)
+    >>> # construct an inference set to analyze
+    >>> inferences = px.Inferences(...)
+    >>> session = px.launch_app(inferences)
     """
     global _session
 
-    # Stopgap solution to allow the app to run without a primary dataset
+    # Stopgap solution to allow the app to run without a primary inferences
     if primary is None:
-        # Dummy dataset
-        # TODO: pass through the lack of a primary dataset to the app
-        primary = EMPTY_DATASET
+        # Dummy inferences
+        # TODO: pass through the lack of a primary inferences to the app
+        primary = EMPTY_INFERENCES
 
     if _session is not None and _session.active:
         logger.warning(

phoenix/utilities/deprecation.py

@@ -0,0 +1,30 @@
+import functools
+import warnings
+from typing import Any, Callable, Type, TypeVar
+
+GenericClass = TypeVar("GenericClass", bound=Type[Any])
+CallableType = TypeVar("CallableType", bound=Callable[..., Any])
+
+
+def deprecated_class(message: str) -> Callable[[GenericClass], GenericClass]:
+    def decorator(original_class: GenericClass) -> GenericClass:
+        @functools.wraps(original_class)
+        def new_class(*args: Any, **kwargs: Any) -> Any:
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+            return original_class(*args, **kwargs)
+
+        return new_class  # type: ignore
+
+    return decorator
+
+
+def deprecated(message: str) -> Callable[[CallableType], CallableType]:
+    def decorator(original_func: CallableType) -> CallableType:
+        @functools.wraps(original_func)
+        def new_func(*args: Any, **kwargs: Any) -> Any:
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+            return original_func(*args, **kwargs)
+
+        return new_func  # type: ignore
+
+    return decorator

phoenix/version.py

@@ -1 +1 @@
-__version__ = "3.19.4"
+__version__ = "3.21.0"