arize-phoenix 3.16.1__py3-none-any.whl → 7.7.0__py3-none-any.whl

phoenix/experiments/utils.py

@@ -0,0 +1,25 @@
+import functools
+from collections.abc import Callable
+from typing import Any
+
+from phoenix.config import get_web_base_url
+
+
+def get_experiment_url(*, dataset_id: str, experiment_id: str) -> str:
+    return f"{get_web_base_url()}datasets/{dataset_id}/compare?experimentId={experiment_id}"
+
+
+def get_dataset_experiments_url(*, dataset_id: str) -> str:
+    return f"{get_web_base_url()}datasets/{dataset_id}/experiments"
+
+
+def get_func_name(fn: Callable[..., Any]) -> str:
+    """
+    Makes a best-effort attempt to get the name of the function.
+    """
+
+    if isinstance(fn, functools.partial):
+        return fn.func.__qualname__
+    if hasattr(fn, "__qualname__") and not fn.__qualname__.endswith("<lambda>"):
+        return fn.__qualname__.split(".<locals>.")[-1]
+    return str(fn)

phoenix/{datasets → inferences}/errors.py

@@ -1,5 +1,6 @@
 from abc import abstractmethod
-from typing import Any, Iterable, List, Union
+from collections.abc import Iterable
+from typing import Any, Union
 
 
 class ValidationError(Exception):
@@ -57,8 +58,8 @@ class InvalidSchemaError(ValidationError):
 class DatasetError(Exception):
     """An error raised when the dataset is invalid or incomplete"""
 
-    def __init__(self, errors: Union[ValidationError, List[ValidationError]]):
-        self.errors: List[ValidationError] = errors if isinstance(errors, list) else [errors]
+    def __init__(self, errors: Union[ValidationError, list[ValidationError]]):
+        self.errors: list[ValidationError] = errors if isinstance(errors, list) else [errors]
 
     def __str__(self) -> str:
         return "\n".join(map(str, self.errors))
@@ -142,7 +143,7 @@ class EmbeddingVectorSizeMismatch(ValidationError):
     vector lengths"""
 
     def __init__(
-        self, embedding_feature_name: str, vector_column_name: str, vector_lengths: List[int]
+        self, embedding_feature_name: str, vector_column_name: str, vector_lengths: list[int]
     ) -> None:
         self.embedding_feature_name = embedding_feature_name
         self.vector_column_name = vector_column_name
@@ -238,5 +239,5 @@ class MissingTimestampColumnName(ValidationError):
 class SchemaError(Exception):
     """An error raised when the Schema is invalid or incomplete"""
 
-    def __init__(self, errors: Union[ValidationError, List[ValidationError]]):
+    def __init__(self, errors: Union[ValidationError, list[ValidationError]]):
         self.errors = errors

phoenix/{datasets → inferences}/fixtures.py

@@ -1,17 +1,18 @@
 import json
 import logging
+from collections.abc import Iterator
 from dataclasses import dataclass, replace
 from enum import Enum, auto
 from pathlib import Path
-from typing import Iterator, NamedTuple, Optional, Tuple
+from typing import NamedTuple, Optional
 from urllib import request
 from urllib.parse import quote, urljoin
 
 from pandas import read_parquet
 
-from phoenix.config import DATASET_DIR
-from phoenix.datasets.dataset import Dataset
-from phoenix.datasets.schema import (
+from phoenix.config import INFERENCES_DIR
+from phoenix.inferences.inferences import Inferences
+from phoenix.inferences.schema import (
     EmbeddingColumnNames,
     RetrievalEmbeddingColumnNames,
     Schema,
@@ -20,7 +21,7 @@ from phoenix.datasets.schema import (
 logger = logging.getLogger(__name__)
 
 
-class DatasetRole(Enum):
+class InferencesRole(Enum):
     PRIMARY = auto()
     REFERENCE = auto()
     CORPUS = auto()
@@ -39,11 +40,11 @@ class Fixture:
     corpus_file_name: Optional[str] = None
     corpus_schema: Optional[Schema] = None
 
-    def paths(self) -> Iterator[Tuple[DatasetRole, Path]]:
+    def paths(self) -> Iterator[tuple[InferencesRole, Path]]:
         return (
             (role, Path(self.prefix) / name)
             for role, name in zip(
-                DatasetRole,
+                InferencesRole,
                 (
                     self.primary_file_name,
                     self.reference_file_name,
@@ -397,7 +398,7 @@ wikipedia_fixture = Fixture(
     corpus_file_name="corpus.parquet",
 )
 
-FIXTURES: Tuple[Fixture, ...] = (
+FIXTURES: tuple[Fixture, ...] = (
     sentiment_classification_language_drift_fixture,
     image_classification_fixture,
     fashion_mnist_fixture,
@@ -413,47 +414,53 @@ FIXTURES: Tuple[Fixture, ...] = (
 NAME_TO_FIXTURE = {fixture.name: fixture for fixture in FIXTURES}
 
 
-def get_datasets(
+def get_inferences(
     fixture_name: str,
     no_internet: bool = False,
-) -> Tuple[Dataset, Optional[Dataset], Optional[Dataset]]:
+) -> tuple[Inferences, Optional[Inferences], Optional[Inferences]]:
     """
-    Downloads primary and reference datasets for a fixture if they are not found
+    Downloads primary and reference inferences for a fixture if they are not found
     locally.
     """
-    fixture = _get_fixture_by_name(fixture_name=fixture_name)
+    fixture = get_fixture_by_name(fixture_name=fixture_name)
     if no_internet:
-        paths = {role: DATASET_DIR / path for role, path in fixture.paths()}
+        paths = {role: INFERENCES_DIR / path for role, path in fixture.paths()}
     else:
-        paths = dict(_download(fixture, DATASET_DIR))
-    primary_dataset = Dataset(
-        read_parquet(paths[DatasetRole.PRIMARY]),
+        paths = dict(_download(fixture, INFERENCES_DIR))
+    primary_inferences = Inferences(
+        read_parquet(paths[InferencesRole.PRIMARY]),
         fixture.primary_schema,
         "production",
     )
-    reference_dataset = None
+    reference_inferences = None
     if fixture.reference_file_name is not None:
-        reference_dataset = Dataset(
-            read_parquet(paths[DatasetRole.REFERENCE]),
-            fixture.reference_schema
-            if fixture.reference_schema is not None
-            else fixture.primary_schema,
+        reference_inferences = Inferences(
+            read_parquet(paths[InferencesRole.REFERENCE]),
+            (
+                fixture.reference_schema
+                if fixture.reference_schema is not None
+                else fixture.primary_schema
+            ),
             "training",
         )
-    corpus_dataset = None
+    corpus_inferences = None
     if fixture.corpus_file_name is not None:
-        corpus_dataset = Dataset(
-            read_parquet(paths[DatasetRole.CORPUS]),
+        corpus_inferences = Inferences(
+            read_parquet(paths[InferencesRole.CORPUS]),
             fixture.corpus_schema,
             "knowledge_base",
         )
-    return primary_dataset, reference_dataset, corpus_dataset
+    return primary_inferences, reference_inferences, corpus_inferences
 
 
-def _get_fixture_by_name(fixture_name: str) -> Fixture:
+def get_fixture_by_name(fixture_name: str) -> Fixture:
     """
-    Returns the fixture whose name matches the input name. Raises a ValueError
-    if the input fixture name does not match any known fixture names.
+    Returns the fixture whose name matches the input name.
+
+    Raises
+    ------
+    ValueError
+        if the input fixture name does not match any known fixture names.
     """
     if fixture_name not in NAME_TO_FIXTURE:
         valid_fixture_names = ", ".join(NAME_TO_FIXTURE.keys())
@@ -462,17 +469,17 @@ def _get_fixture_by_name(fixture_name: str) -> Fixture:
 
 
 @dataclass
-class ExampleDatasets:
+class ExampleInferences:
     """
     A primary and optional reference dataset pair.
     """
 
-    primary: Dataset
-    reference: Optional[Dataset] = None
-    corpus: Optional[Dataset] = None
+    primary: Inferences
+    reference: Optional[Inferences] = None
+    corpus: Optional[Inferences] = None
 
 
-def load_example(use_case: str) -> ExampleDatasets:
+def load_example(use_case: str) -> ExampleInferences:
     """
     Loads an example primary and reference dataset for a given use-case.
 
@@ -495,15 +502,15 @@ def load_example(use_case: str) -> ExampleDatasets:
             reference).
 
     """
-    fixture = _get_fixture_by_name(use_case)
-    primary_dataset, reference_dataset, corpus_dataset = get_datasets(use_case)
+    fixture = get_fixture_by_name(use_case)
+    primary_inferences, reference_inferences, corpus_inferences = get_inferences(use_case)
     print(f"📥 Loaded {use_case} example datasets.")
     print("ℹ️ About this use-case:")
     print(fixture.description)
-    return ExampleDatasets(
-        primary=primary_dataset,
-        reference=reference_dataset,
-        corpus=corpus_dataset,
+    return ExampleInferences(
+        primary=primary_inferences,
+        reference=reference_inferences,
+        corpus=corpus_inferences,
     )
 
 
@@ -544,7 +551,7 @@ class GCSAssets(NamedTuple):
         )
 
 
-def _download(fixture: Fixture, location: Path) -> Iterator[Tuple[DatasetRole, Path]]:
+def _download(fixture: Fixture, location: Path) -> Iterator[tuple[InferencesRole, Path]]:
     for role, path in fixture.paths():
         yield role, GCSAssets().metadata(path).save_artifact(location)
 
@@ -556,5 +563,5 @@ if __name__ == "__main__":
     for fixture in FIXTURES:
         start_time = time.time()
         print(f"getting {fixture.name}", end="...")
-        dict(_download(fixture, DATASET_DIR))
+        dict(_download(fixture, INFERENCES_DIR))
         print(f"done ({time.time() - start_time:.2f}s)")

phoenix/{datasets/dataset.py → inferences/inferences.py}

@@ -5,7 +5,7 @@ from copy import deepcopy
 from dataclasses import dataclass, fields, replace
 from enum import Enum
 from itertools import groupby
-from typing import Any, Dict, List, Optional, Set, Tuple, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -15,8 +15,9 @@ from pandas.api.types import (
 )
 from typing_extensions import TypeAlias
 
-from phoenix.config import DATASET_DIR, GENERATED_DATASET_NAME_PREFIX
+from phoenix.config import GENERATED_INFERENCES_NAME_PREFIX, INFERENCES_DIR
 from phoenix.datetime_utils import normalize_timestamps
+from phoenix.utilities.deprecation import deprecated
 
 from . import errors as err
 from .schema import (
@@ -30,7 +31,7 @@ from .schema import (
     SchemaFieldName,
     SchemaFieldValue,
 )
-from .validation import validate_dataset_inputs
+from .validation import validate_inferences_inputs
 
 logger = logging.getLogger(__name__)
 
@@ -38,10 +39,16 @@ logger = logging.getLogger(__name__)
 SchemaLike: TypeAlias = Any
 
 
-class Dataset:
+class Inferences:
     """
     A dataset to use for analysis using phoenix.
-    Used to construct a phoenix session via px.launch_app
+    Used to construct a phoenix session via px.launch_app.
+
+    Typical usage example::
+
+        primary_inferences = px.Inferences(
+            dataframe=production_dataframe, schema=schema, name="primary"
+        )
 
     Parameters
     ----------
@@ -61,7 +68,15 @@ class Dataset:
 
     Examples
     --------
-    >>> primary_dataset = px.Dataset(dataframe=production_dataframe, schema=schema, name="primary")
+    Define inferences ds from a pandas dataframe df and a schema object schema by running::
+
+        ds = px.Inferences(df, schema)
+
+    Alternatively, provide a name for the inferences that will appear in the application::
+
+        ds = px.Inferences(df, schema, name="training")
+
+    ds is then passed as the primary or reference argument to launch_app.
     """
 
     _data_file_name: str = "data.parquet"
@@ -78,7 +93,7 @@ class Dataset:
         # allow for schema like objects
         if not isinstance(schema, Schema):
             schema = _get_schema_from_unknown_schema_param(schema)
-        errors = validate_dataset_inputs(
+        errors = validate_inferences_inputs(
             dataframe=dataframe,
             schema=schema,
         )
@@ -92,7 +107,7 @@ class Dataset:
         self.__dataframe: DataFrame = dataframe
         self.__schema: Schema = schema
         self.__name: str = (
-            name if name is not None else f"{GENERATED_DATASET_NAME_PREFIX}{str(uuid.uuid4())}"
+            name if name is not None else f"{GENERATED_INFERENCES_NAME_PREFIX}{str(uuid.uuid4())}"
         )
         self._is_empty = self.dataframe.empty
         logger.info(f"""Dataset: {self.__name} initialized""")
@@ -113,19 +128,33 @@ class Dataset:
         return self.__name
 
     @classmethod
-    def from_name(cls, name: str) -> "Dataset":
+    def from_name(cls, name: str) -> "Inferences":
         """Retrieves a dataset by name from the file system"""
-        directory = DATASET_DIR / name
+        directory = INFERENCES_DIR / name
         df = read_parquet(directory / cls._data_file_name)
         with open(directory / cls._schema_file_name) as schema_file:
             schema_json = schema_file.read()
         schema = Schema.from_json(schema_json)
         return cls(df, schema, name)
 
+    def to_disc(self) -> None:
+        """writes the data and schema to disc"""
+        directory = INFERENCES_DIR / self.name
+        directory.mkdir(parents=True, exist_ok=True)
+        self.dataframe.to_parquet(
+            directory / self._data_file_name,
+            allow_truncated_timestamps=True,
+            coerce_timestamps="ms",
+        )
+        schema_json_data = self.schema.to_json()
+        with open(directory / self._schema_file_name, "w+") as schema_file:
+            schema_file.write(schema_json_data)
+
     @classmethod
-    def from_open_inference(cls, dataframe: DataFrame) -> "Dataset":
+    @deprecated("Inferences.from_open_inference is deprecated and will be removed.")
+    def from_open_inference(cls, dataframe: DataFrame) -> "Inferences":
         schema = Schema()
-        column_renaming: Dict[str, str] = {}
+        column_renaming: dict[str, str] = {}
         for group_name, group in groupby(
             sorted(
                 map(_parse_open_inference_column_name, dataframe.columns),
@@ -276,21 +305,53 @@ class Dataset:
             schema,
         )
 
-    def to_disc(self) -> None:
-        """writes the data and schema to disc"""
-        directory = DATASET_DIR / self.name
-        directory.mkdir(parents=True, exist_ok=True)
-        self.dataframe.to_parquet(
-            directory / self._data_file_name,
-            allow_truncated_timestamps=True,
-            coerce_timestamps="ms",
+
+class OpenInferenceCategory(Enum):
+    id = "id"
+    timestamp = "timestamp"
+    feature = "feature"
+    tag = "tag"
+    prediction = "prediction"
+    actual = "actual"
+
+
+class OpenInferenceSpecifier(Enum):
+    default = ""
+    score = "score"
+    label = "label"
+    embedding = "embedding"
+    raw_data = "raw_data"
+    link_to_data = "link_to_data"
+    retrieved_document_ids = "retrieved_document_ids"
+    retrieved_document_scores = "retrieved_document_scores"
+
+
+@dataclass(frozen=True)
+class _OpenInferenceColumnName:
+    full_name: str
+    category: OpenInferenceCategory
+    data_type: str
+    specifier: OpenInferenceSpecifier = OpenInferenceSpecifier.default
+    name: str = ""
+
+
+def _parse_open_inference_column_name(column_name: str) -> _OpenInferenceColumnName:
+    pattern = (
+        r"^:(?P<category>\w+)\.(?P<data_type>\[\w+\]|\w+)(\.(?P<specifier>\w+))?:(?P<name>.*)?$"
+    )
+    if match := re.match(pattern, column_name):
+        extract = match.groupdict(default="")
+        return _OpenInferenceColumnName(
+            full_name=column_name,
+            category=OpenInferenceCategory(extract.get("category", "").lower()),
+            data_type=extract.get("data_type", "").lower(),
+            specifier=OpenInferenceSpecifier(extract.get("specifier", "").lower()),
+            name=extract.get("name", ""),
         )
-        schema_json_data = self.schema.to_json()
-        with open(directory / self._schema_file_name, "w+") as schema_file:
-            schema_file.write(schema_json_data)
+    raise ValueError(f"Invalid format for column name: {column_name}")
 
 
-def _parse_dataframe_and_schema(dataframe: DataFrame, schema: Schema) -> Tuple[DataFrame, Schema]:
+def _parse_dataframe_and_schema(dataframe: DataFrame, schema: Schema) -> tuple[DataFrame, Schema]:
     """
     Parses a dataframe according to a schema, infers feature columns names when
     they are not explicitly provided, and removes excluded column names from
@@ -303,12 +364,12 @@ def _parse_dataframe_and_schema(dataframe: DataFrame, schema: Schema) -> Tuple[D
     names present in the dataframe but not included in any other schema fields.
     """
 
-    unseen_excluded_column_names: Set[str] = (
+    unseen_excluded_column_names: set[str] = (
         set(schema.excluded_column_names) if schema.excluded_column_names is not None else set()
     )
-    unseen_column_names: Set[str] = set(dataframe.columns.to_list())
-    column_name_to_include: Dict[str, bool] = {}
-    schema_patch: Dict[SchemaFieldName, SchemaFieldValue] = {}
+    unseen_column_names: set[str] = set(dataframe.columns.to_list())
+    column_name_to_include: dict[str, bool] = {}
+    schema_patch: dict[SchemaFieldName, SchemaFieldValue] = {}
 
     for schema_field_name in SINGLE_COLUMN_SCHEMA_FIELD_NAMES:
         _check_single_column_schema_field_for_excluded_columns(
@@ -373,10 +434,10 @@ def _parse_dataframe_and_schema(dataframe: DataFrame, schema: Schema) -> Tuple[D
 def _check_single_column_schema_field_for_excluded_columns(
     schema: Schema,
     schema_field_name: str,
-    unseen_excluded_column_names: Set[str],
-    schema_patch: Dict[SchemaFieldName, SchemaFieldValue],
-    column_name_to_include: Dict[str, bool],
-    unseen_column_names: Set[str],
+    unseen_excluded_column_names: set[str],
+    schema_patch: dict[SchemaFieldName, SchemaFieldValue],
+    column_name_to_include: dict[str, bool],
+    unseen_column_names: set[str],
 ) -> None:
     """
     Checks single-column schema fields for excluded column names.
@@ -394,18 +455,18 @@ def _check_single_column_schema_field_for_excluded_columns(
 def _check_multi_column_schema_field_for_excluded_columns(
     schema: Schema,
     schema_field_name: str,
-    unseen_excluded_column_names: Set[str],
-    schema_patch: Dict[SchemaFieldName, SchemaFieldValue],
-    column_name_to_include: Dict[str, bool],
-    unseen_column_names: Set[str],
+    unseen_excluded_column_names: set[str],
+    schema_patch: dict[SchemaFieldName, SchemaFieldValue],
+    column_name_to_include: dict[str, bool],
+    unseen_column_names: set[str],
 ) -> None:
     """
     Checks multi-column schema fields for excluded columns names.
     """
-    column_names: Optional[List[str]] = getattr(schema, schema_field_name)
+    column_names: Optional[list[str]] = getattr(schema, schema_field_name)
     if column_names:
-        included_column_names: List[str] = []
-        excluded_column_names: List[str] = []
+        included_column_names: list[str] = []
+        excluded_column_names: list[str] = []
         for column_name in column_names:
             is_included_column = column_name not in unseen_excluded_column_names
             column_name_to_include[column_name] = is_included_column
@@ -421,10 +482,10 @@ def _check_multi_column_schema_field_for_excluded_columns(
 
 def _check_embedding_features_schema_field_for_excluded_columns(
     embedding_features: EmbeddingFeatures,
-    unseen_excluded_column_names: Set[str],
-    schema_patch: Dict[SchemaFieldName, SchemaFieldValue],
-    column_name_to_include: Dict[str, bool],
-    unseen_column_names: Set[str],
+    unseen_excluded_column_names: set[str],
+    schema_patch: dict[SchemaFieldName, SchemaFieldValue],
+    column_name_to_include: dict[str, bool],
+    unseen_column_names: set[str],
 ) -> None:
     """
     Check embedding features for excluded column names.
@@ -466,8 +527,8 @@ def _check_embedding_features_schema_field_for_excluded_columns(
 
 def _check_embedding_column_names_for_excluded_columns(
     embedding_column_name_mapping: EmbeddingColumnNames,
-    column_name_to_include: Dict[str, bool],
-    unseen_column_names: Set[str],
+    column_name_to_include: dict[str, bool],
+    unseen_column_names: set[str],
 ) -> None:
     """
     Check embedding column names for excluded column names.
@@ -481,10 +542,10 @@ def _check_embedding_column_names_for_excluded_columns(
 
 def _discover_feature_columns(
     dataframe: DataFrame,
-    unseen_excluded_column_names: Set[str],
-    schema_patch: Dict[SchemaFieldName, SchemaFieldValue],
-    column_name_to_include: Dict[str, bool],
-    unseen_column_names: Set[str],
+    unseen_excluded_column_names: set[str],
+    schema_patch: dict[SchemaFieldName, SchemaFieldValue],
+    column_name_to_include: dict[str, bool],
+    unseen_column_names: set[str],
 ) -> None:
     """
     Adds unseen and un-excluded columns as features, with the exception of "prediction_id"
@@ -498,10 +559,10 @@ def _discover_feature_columns(
         else:
             unseen_excluded_column_names.discard(column_name)
             logger.debug(f"excluded feature: {column_name}")
-    original_column_positions: List[int] = dataframe.columns.get_indexer(
+    original_column_positions: list[int] = dataframe.columns.get_indexer(
         discovered_feature_column_names
     )  # type: ignore
-    feature_column_name_to_position: Dict[str, int] = dict(
+    feature_column_name_to_position: dict[str, int] = dict(
         zip(discovered_feature_column_names, original_column_positions)
     )
     discovered_feature_column_names.sort(key=lambda col: feature_column_name_to_position[col])
@@ -514,16 +575,16 @@ def _discover_feature_columns(
 def _create_and_normalize_dataframe_and_schema(
     dataframe: DataFrame,
     schema: Schema,
-    schema_patch: Dict[SchemaFieldName, SchemaFieldValue],
-    column_name_to_include: Dict[str, bool],
-) -> Tuple[DataFrame, Schema]:
+    schema_patch: dict[SchemaFieldName, SchemaFieldValue],
+    column_name_to_include: dict[str, bool],
+) -> tuple[DataFrame, Schema]:
     """
     Creates new dataframe and schema objects to reflect excluded column names
     and discovered features. This also normalizes dataframe columns to ensure a
     standard set of columns (i.e. timestamp and prediction_id) and datatypes for
     those columns.
     """
-    included_column_names: List[str] = []
+    included_column_names: list[str] = []
     for column_name in dataframe.columns:
         if column_name_to_include.get(str(column_name), False):
             included_column_names.append(str(column_name))
@@ -587,7 +648,7 @@ def _normalize_timestamps(
     dataframe: DataFrame,
     schema: Schema,
     default_timestamp: Timestamp,
-) -> Tuple[DataFrame, Schema]:
+) -> tuple[DataFrame, Schema]:
     """
     Ensures that the dataframe has a timestamp column and the schema has a timestamp field. If the
     input dataframe contains a Unix or datetime timestamp or ISO8601 timestamp strings column, it
@@ -614,7 +675,7 @@ def _normalize_timestamps(
 
 def _get_schema_from_unknown_schema_param(schemaLike: SchemaLike) -> Schema:
     """
-    Compatibility function for converting from arize.utils.types.Schema to phoenix.datasets.Schema
+    Compatibility function for converting from arize.utils.types.Schema to phoenix.inferences.Schema
     """
     try:
         from arize.utils.types import (
@@ -625,7 +686,7 @@ def _get_schema_from_unknown_schema_param(schemaLike: SchemaLike) -> Schema:
         if not isinstance(schemaLike, ArizeSchema):
             raise ValueError("Unknown schema passed to Dataset. Please pass a phoenix Schema")
 
-        embedding_feature_column_names: Dict[str, EmbeddingColumnNames] = {}
+        embedding_feature_column_names: dict[str, EmbeddingColumnNames] = {}
         if schemaLike.embedding_feature_column_names is not None:
             for (
                 embedding_name,
@@ -673,54 +734,9 @@ def _get_schema_from_unknown_schema_param(schemaLike: SchemaLike) -> Schema:
         )
 
 
-def _add_prediction_id(num_rows: int) -> List[str]:
+def _add_prediction_id(num_rows: int) -> list[str]:
     return [str(uuid.uuid4()) for _ in range(num_rows)]
 
 
-class OpenInferenceCategory(Enum):
-    id = "id"
-    timestamp = "timestamp"
-    feature = "feature"
-    tag = "tag"
-    prediction = "prediction"
-    actual = "actual"
-
-
-class OpenInferenceSpecifier(Enum):
-    default = ""
-    score = "score"
-    label = "label"
-    embedding = "embedding"
-    raw_data = "raw_data"
-    link_to_data = "link_to_data"
-    retrieved_document_ids = "retrieved_document_ids"
-    retrieved_document_scores = "retrieved_document_scores"
-
-
-@dataclass(frozen=True)
-class _OpenInferenceColumnName:
-    full_name: str
-    category: OpenInferenceCategory
-    data_type: str
-    specifier: OpenInferenceSpecifier = OpenInferenceSpecifier.default
-    name: str = ""
-
-
-def _parse_open_inference_column_name(column_name: str) -> _OpenInferenceColumnName:
-    pattern = (
-        r"^:(?P<category>\w+)\.(?P<data_type>\[\w+\]|\w+)(\.(?P<specifier>\w+))?:(?P<name>.*)?$"
-    )
-    if match := re.match(pattern, column_name):
-        extract = match.groupdict(default="")
-        return _OpenInferenceColumnName(
-            full_name=column_name,
-            category=OpenInferenceCategory(extract.get("category", "").lower()),
-            data_type=extract.get("data_type", "").lower(),
-            specifier=OpenInferenceSpecifier(extract.get("specifier", "").lower()),
-            name=extract.get("name", ""),
-        )
-    raise ValueError(f"Invalid format for column name: {column_name}")
-
-
 # A dataset with no data. Useful for stubs
-EMPTY_DATASET = Dataset(pd.DataFrame(), schema=Schema())
+EMPTY_INFERENCES = Inferences(pd.DataFrame(), schema=Schema())