arize-phoenix 4.4.4rc6__py3-none-any.whl → 4.5.0__py3-none-any.whl

phoenix/db/insertion/evaluation.py

@@ -6,7 +6,7 @@ from typing_extensions import assert_never
 
 from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect, num_docs_col
-from phoenix.db.insertion.helpers import OnConflict, insert_on_conflict
+from phoenix.db.insertion.helpers import OnConflict, insert_stmt
 from phoenix.exceptions import PhoenixException
 from phoenix.trace import v1 as pb
 
@@ -15,24 +15,24 @@ class InsertEvaluationError(PhoenixException):
     pass
 
 
-class EvaluationInsertionEvent(NamedTuple):
+class EvaluationInsertionResult(NamedTuple):
     project_rowid: int
     evaluation_name: str
 
 
-class SpanEvaluationInsertionEvent(EvaluationInsertionEvent): ...
+class SpanEvaluationInsertionEvent(EvaluationInsertionResult): ...
 
 
-class TraceEvaluationInsertionEvent(EvaluationInsertionEvent): ...
+class TraceEvaluationInsertionEvent(EvaluationInsertionResult): ...
 
 
-class DocumentEvaluationInsertionEvent(EvaluationInsertionEvent): ...
+class DocumentEvaluationInsertionEvent(EvaluationInsertionResult): ...
 
 
 async def insert_evaluation(
     session: AsyncSession,
     evaluation: pb.Evaluation,
-) -> Optional[EvaluationInsertionEvent]:
+) -> Optional[EvaluationInsertionResult]:
     evaluation_name = evaluation.name
     result = evaluation.result
     label = result.label.value if result.HasField("label") else None
@@ -91,7 +91,7 @@ async def _insert_trace_evaluation(
     set_.pop("metadata_")
     set_["metadata"] = values["metadata_"]  # `metadata` must match database
     await session.execute(
-        insert_on_conflict(
+        insert_stmt(
             dialect=dialect,
             table=models.TraceAnnotation,
             values=values,
@@ -139,7 +139,7 @@ async def _insert_span_evaluation(
     set_.pop("metadata_")
     set_["metadata"] = values["metadata_"]  # `metadata` must match database
     await session.execute(
-        insert_on_conflict(
+        insert_stmt(
             dialect=dialect,
             table=models.SpanAnnotation,
             values=values,
@@ -160,7 +160,7 @@ async def _insert_document_evaluation(
     label: Optional[str],
     score: Optional[float],
     explanation: Optional[str],
-) -> EvaluationInsertionEvent:
+) -> EvaluationInsertionResult:
     dialect = SupportedSQLDialect(session.bind.dialect.name)
     stmt = (
         select(
@@ -196,7 +196,7 @@ async def _insert_document_evaluation(
     set_.pop("metadata_")
     set_["metadata"] = values["metadata_"]  # `metadata` must match database
     await session.execute(
-        insert_on_conflict(
+        insert_stmt(
             dialect=dialect,
             table=models.DocumentAnnotation,
             values=values,

phoenix/db/insertion/helpers.py

@@ -1,42 +1,39 @@
-from abc import ABC
 from enum import Enum, auto
-from typing import Any, Awaitable, Callable, Mapping, Optional, Sequence
+from typing import Any, Mapping, Optional, Sequence
 
-from sqlalchemy import Insert
+from sqlalchemy import Insert, insert
 from sqlalchemy.dialects.postgresql import insert as insert_postgresql
 from sqlalchemy.dialects.sqlite import insert as insert_sqlite
-from sqlalchemy.ext.asyncio import AsyncSession
-from typing_extensions import TypeAlias, assert_never
+from typing_extensions import assert_never
 
 from phoenix.db.helpers import SupportedSQLDialect
 
 
-class DataManipulationEvent(ABC):
-    """
-    Execution of DML (Data Manipulation Language) statements.
-    """
-
-
-DataManipulation: TypeAlias = Callable[[AsyncSession], Awaitable[Optional[DataManipulationEvent]]]
-
-
 class OnConflict(Enum):
     DO_NOTHING = auto()
     DO_UPDATE = auto()
 
 
-def insert_on_conflict(
+def insert_stmt(
     dialect: SupportedSQLDialect,
     table: Any,
     values: Mapping[str, Any],
-    constraint: str,
-    column_names: Sequence[str],
+    constraint: Optional[str] = None,
+    column_names: Sequence[str] = (),
     on_conflict: OnConflict = OnConflict.DO_NOTHING,
     set_: Optional[Mapping[str, Any]] = None,
 ) -> Insert:
     """
     Dialect specific insertion statement using ON CONFLICT DO syntax.
     """
+    if bool(constraint) != bool(column_names):
+        raise ValueError(
+            "Both `constraint` and `column_names` must be provided or omitted at the same time."
+        )
+    if (dialect is SupportedSQLDialect.POSTGRESQL and constraint is None) or (
+        dialect is SupportedSQLDialect.SQLITE and not column_names
+    ):
+        return insert(table).values(values)
     if dialect is SupportedSQLDialect.POSTGRESQL:
         stmt_postgresql = insert_postgresql(table).values(values)
         if on_conflict is OnConflict.DO_NOTHING or not set_:

phoenix/db/insertion/span.py

@@ -7,7 +7,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect
-from phoenix.db.insertion.helpers import OnConflict, insert_on_conflict
+from phoenix.db.insertion.helpers import OnConflict, insert_stmt
 from phoenix.trace.attributes import get_attribute_value
 from phoenix.trace.schemas import Span, SpanStatusCode
 
@@ -27,7 +27,7 @@ async def insert_span(
 ) -> Optional[SpanInsertionEvent]:
     dialect = SupportedSQLDialect(session.bind.dialect.name)
     project_rowid = await session.scalar(
-        insert_on_conflict(
+        insert_stmt(
             dialect=dialect,
             table=models.Project,
             constraint="uq_projects_name",
@@ -87,7 +87,7 @@ async def insert_span(
         cumulative_llm_token_count_prompt += cast(int, accumulation[1] or 0)
         cumulative_llm_token_count_completion += cast(int, accumulation[2] or 0)
     span_rowid = await session.scalar(
-        insert_on_conflict(
+        insert_stmt(
             dialect=dialect,
             table=models.Span,
             constraint="uq_spans_span_id",

phoenix/db/migrations/versions/cf03bd6bae1d_init.py

@@ -6,11 +6,13 @@ Create Date: 2024-04-03 19:41:48.871555
 
 """
 
-from typing import Sequence, Union
+from typing import Any, Sequence, Union
 
 import sqlalchemy as sa
 from alembic import op
-from phoenix.db.migrations.types import JSON_
+from sqlalchemy import JSON
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.ext.compiler import compiles
 
 # revision identifiers, used by Alembic.
 revision: str = "cf03bd6bae1d"
@@ -19,6 +21,30 @@ branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
 
 
+class JSONB(JSON):
+    # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
+    __visit_name__ = "JSONB"
+
+
+@compiles(JSONB, "sqlite")  # type: ignore
+def _(*args: Any, **kwargs: Any) -> str:
+    # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
+    return "JSONB"
+
+
+JSON_ = (
+    JSON()
+    .with_variant(
+        postgresql.JSONB(),  # type: ignore
+        "postgresql",
+    )
+    .with_variant(
+        JSONB(),
+        "sqlite",
+    )
+)
+
+
 def upgrade() -> None:
     projects_table = op.create_table(
         "projects",

phoenix/db/models.py

@@ -1,5 +1,5 @@
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, TypedDict
+from typing import Any, Dict, List, Optional
 
 from sqlalchemy import (
     JSON,
@@ -15,14 +15,12 @@ from sqlalchemy import (
     String,
     TypeDecorator,
     UniqueConstraint,
-    case,
     func,
     insert,
-    select,
     text,
 )
 from sqlalchemy.dialects import postgresql
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+from sqlalchemy.ext.asyncio import AsyncEngine
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import (
@@ -61,24 +59,6 @@ JSON_ = (
 )
 
 
-class JsonDict(TypeDecorator[Dict[str, Any]]):
-    # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
-    cache_ok = True
-    impl = JSON_
-
-    def process_bind_param(self, value: Optional[Dict[str, Any]], _: Dialect) -> Dict[str, Any]:
-        return value if isinstance(value, dict) else {}
-
-
-class JsonList(TypeDecorator[List[Any]]):
-    # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
-    cache_ok = True
-    impl = JSON_
-
-    def process_bind_param(self, value: Optional[List[Any]], _: Dialect) -> List[Any]:
-        return value if isinstance(value, list) else []
-
-
 class UtcTimeStamp(TypeDecorator[datetime]):
     # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
     cache_ok = True
@@ -91,10 +71,6 @@ class UtcTimeStamp(TypeDecorator[datetime]):
         return normalize_datetime(value, timezone.utc)
 
 
-class ExperimentResult(TypedDict, total=False):
-    result: Any
-
-
 class Base(DeclarativeBase):
     # Enforce best practices for naming constraints
     # https://alembic.sqlalchemy.org/en/latest/naming.html#integration-of-naming-conventions-into-operations-autogenerate
@@ -108,9 +84,8 @@ class Base(DeclarativeBase):
         }
     )
     type_annotation_map = {
-        Dict[str, Any]: JsonDict,
-        List[Dict[str, Any]]: JsonList,
-        ExperimentResult: JsonDict,
+        Dict[str, Any]: JSON_,
+        List[Dict[str, Any]]: JSON_,
     }
 
 
@@ -179,10 +154,6 @@ class Trace(Base):
         cascade="all, delete-orphan",
         uselist=True,
     )
-    experiment_runs: Mapped[List["ExperimentRun"]] = relationship(
-        primaryjoin="foreign(ExperimentRun.trace_id) == Trace.trace_id",
-        back_populates="trace",
-    )
     __table_args__ = (
         UniqueConstraint(
             "trace_id",
@@ -232,7 +203,6 @@ class Span(Base):
 
     trace: Mapped["Trace"] = relationship("Trace", back_populates="spans")
     document_annotations: Mapped[List["DocumentAnnotation"]] = relationship(back_populates="span")
-    dataset_examples: Mapped[List["DatasetExample"]] = relationship(back_populates="span")
 
     __table_args__ = (
         UniqueConstraint(
@@ -406,205 +376,3 @@ class DocumentAnnotation(Base):
             "document_position",
         ),
     )
-
-
-class Dataset(Base):
-    __tablename__ = "datasets"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    name: Mapped[str] = mapped_column(unique=True)
-    description: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
-    created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
-    updated_at: Mapped[datetime] = mapped_column(
-        UtcTimeStamp, server_default=func.now(), onupdate=func.now()
-    )
-
-    @hybrid_property
-    def example_count(self) -> Optional[int]:
-        if hasattr(self, "_example_count_value"):
-            assert isinstance(self._example_count_value, int)
-            return self._example_count_value
-        return None
-
-    @example_count.inplace.expression
-    def _example_count(cls) -> ColumnElement[int]:
-        return (
-            select(
-                func.sum(
-                    case(
-                        (DatasetExampleRevision.revision_kind == "CREATE", 1),
-                        (DatasetExampleRevision.revision_kind == "DELETE", -1),
-                        else_=0,
-                    )
-                )
-            )
-            .select_from(DatasetExampleRevision)
-            .join(
-                DatasetExample,
-                onclause=DatasetExample.id == DatasetExampleRevision.dataset_example_id,
-            )
-            .filter(DatasetExample.dataset_id == cls.id)
-            .label("example_count")
-        )
-
-    async def load_example_count(self, session: AsyncSession) -> None:
-        if not hasattr(self, "_example_count_value"):
-            self._example_count_value = await session.scalar(
-                select(
-                    func.sum(
-                        case(
-                            (DatasetExampleRevision.revision_kind == "CREATE", 1),
-                            (DatasetExampleRevision.revision_kind == "DELETE", -1),
-                            else_=0,
-                        )
-                    )
-                )
-                .select_from(DatasetExampleRevision)
-                .join(
-                    DatasetExample,
-                    onclause=DatasetExample.id == DatasetExampleRevision.dataset_example_id,
-                )
-                .filter(DatasetExample.dataset_id == self.id)
-            )
-
-
-class DatasetVersion(Base):
-    __tablename__ = "dataset_versions"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    dataset_id: Mapped[int] = mapped_column(
-        ForeignKey("datasets.id", ondelete="CASCADE"),
-        index=True,
-    )
-    description: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
-    created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
-
-
-class DatasetExample(Base):
-    __tablename__ = "dataset_examples"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    dataset_id: Mapped[int] = mapped_column(
-        ForeignKey("datasets.id", ondelete="CASCADE"),
-        index=True,
-    )
-    span_rowid: Mapped[Optional[int]] = mapped_column(
-        ForeignKey("spans.id", ondelete="SET NULL"),
-        index=True,
-        nullable=True,
-    )
-    created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
-
-    span: Mapped[Optional[Span]] = relationship(back_populates="dataset_examples")
-
-
-class DatasetExampleRevision(Base):
-    __tablename__ = "dataset_example_revisions"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    dataset_example_id: Mapped[int] = mapped_column(
-        ForeignKey("dataset_examples.id", ondelete="CASCADE"),
-        index=True,
-    )
-    dataset_version_id: Mapped[int] = mapped_column(
-        ForeignKey("dataset_versions.id", ondelete="CASCADE"),
-        index=True,
-    )
-    input: Mapped[Dict[str, Any]]
-    output: Mapped[Dict[str, Any]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
-    revision_kind: Mapped[str] = mapped_column(
-        CheckConstraint(
-            "revision_kind IN ('CREATE', 'PATCH', 'DELETE')", name="valid_revision_kind"
-        ),
-    )
-    created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
-
-    __table_args__ = (
-        UniqueConstraint(
-            "dataset_example_id",
-            "dataset_version_id",
-        ),
-    )
-
-
-class Experiment(Base):
-    __tablename__ = "experiments"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    dataset_id: Mapped[int] = mapped_column(
-        ForeignKey("datasets.id", ondelete="CASCADE"),
-        index=True,
-    )
-    dataset_version_id: Mapped[int] = mapped_column(
-        ForeignKey("dataset_versions.id", ondelete="CASCADE"),
-        index=True,
-    )
-    name: Mapped[str]
-    description: Mapped[Optional[str]]
-    repetitions: Mapped[int]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
-    project_name: Mapped[Optional[str]] = mapped_column(index=True)
-    created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
-    updated_at: Mapped[datetime] = mapped_column(
-        UtcTimeStamp, server_default=func.now(), onupdate=func.now()
-    )
-
-
-class ExperimentRun(Base):
-    __tablename__ = "experiment_runs"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    experiment_id: Mapped[int] = mapped_column(
-        ForeignKey("experiments.id", ondelete="CASCADE"),
-        index=True,
-    )
-    dataset_example_id: Mapped[int] = mapped_column(
-        ForeignKey("dataset_examples.id", ondelete="CASCADE"),
-        index=True,
-    )
-    repetition_number: Mapped[int]
-    trace_id: Mapped[Optional[str]]
-    output: Mapped[ExperimentResult]
-    start_time: Mapped[datetime] = mapped_column(UtcTimeStamp)
-    end_time: Mapped[datetime] = mapped_column(UtcTimeStamp)
-    prompt_token_count: Mapped[Optional[int]]
-    completion_token_count: Mapped[Optional[int]]
-    error: Mapped[Optional[str]]
-
-    trace: Mapped["Trace"] = relationship(
-        primaryjoin="foreign(ExperimentRun.trace_id) == Trace.trace_id",
-        back_populates="experiment_runs",
-    )
-
-    __table_args__ = (
-        UniqueConstraint(
-            "experiment_id",
-            "dataset_example_id",
-            "repetition_number",
-        ),
-    )
-
-
-class ExperimentRunAnnotation(Base):
-    __tablename__ = "experiment_run_annotations"
-    id: Mapped[int] = mapped_column(primary_key=True)
-    experiment_run_id: Mapped[int] = mapped_column(
-        ForeignKey("experiment_runs.id", ondelete="CASCADE"),
-        index=True,
-    )
-    name: Mapped[str]
-    annotator_kind: Mapped[str] = mapped_column(
-        CheckConstraint("annotator_kind IN ('LLM', 'CODE', 'HUMAN')", name="valid_annotator_kind"),
-    )
-    label: Mapped[Optional[str]]
-    score: Mapped[Optional[float]]
-    explanation: Mapped[Optional[str]]
-    trace_id: Mapped[Optional[str]]
-    error: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
-    start_time: Mapped[datetime] = mapped_column(UtcTimeStamp)
-    end_time: Mapped[datetime] = mapped_column(UtcTimeStamp)
-
-    __table_args__ = (
-        UniqueConstraint(
-            "experiment_run_id",
-            "name",
-        ),
-    )

phoenix/inferences/fixtures.py

@@ -9,7 +9,7 @@ from urllib.parse import quote, urljoin
 
 from pandas import read_parquet
 
-from phoenix.config import INFERENCES_DIR
+from phoenix.config import DATASET_DIR
 from phoenix.inferences.inferences import Inferences
 from phoenix.inferences.schema import (
     EmbeddingColumnNames,
@@ -20,7 +20,7 @@ from phoenix.inferences.schema import (
 logger = logging.getLogger(__name__)
 
 
-class InferencesRole(Enum):
+class DatasetRole(Enum):
     PRIMARY = auto()
     REFERENCE = auto()
     CORPUS = auto()
@@ -39,11 +39,11 @@ class Fixture:
     corpus_file_name: Optional[str] = None
     corpus_schema: Optional[Schema] = None
 
-    def paths(self) -> Iterator[Tuple[InferencesRole, Path]]:
+    def paths(self) -> Iterator[Tuple[DatasetRole, Path]]:
         return (
             (role, Path(self.prefix) / name)
             for role, name in zip(
-                InferencesRole,
+                DatasetRole,
                 (
                     self.primary_file_name,
                     self.reference_file_name,
@@ -413,41 +413,41 @@ FIXTURES: Tuple[Fixture, ...] = (
 NAME_TO_FIXTURE = {fixture.name: fixture for fixture in FIXTURES}
 
 
-def get_inferences(
+def get_datasets(
     fixture_name: str,
     no_internet: bool = False,
 ) -> Tuple[Inferences, Optional[Inferences], Optional[Inferences]]:
     """
-    Downloads primary and reference inferences for a fixture if they are not found
+    Downloads primary and reference datasets for a fixture if they are not found
     locally.
     """
     fixture = _get_fixture_by_name(fixture_name=fixture_name)
     if no_internet:
-        paths = {role: INFERENCES_DIR / path for role, path in fixture.paths()}
+        paths = {role: DATASET_DIR / path for role, path in fixture.paths()}
     else:
-        paths = dict(_download(fixture, INFERENCES_DIR))
-    primary_inferences = Inferences(
-        read_parquet(paths[InferencesRole.PRIMARY]),
+        paths = dict(_download(fixture, DATASET_DIR))
+    primary_dataset = Inferences(
+        read_parquet(paths[DatasetRole.PRIMARY]),
         fixture.primary_schema,
         "production",
     )
-    reference_inferences = None
+    reference_dataset = None
     if fixture.reference_file_name is not None:
-        reference_inferences = Inferences(
-            read_parquet(paths[InferencesRole.REFERENCE]),
+        reference_dataset = Inferences(
+            read_parquet(paths[DatasetRole.REFERENCE]),
             fixture.reference_schema
             if fixture.reference_schema is not None
             else fixture.primary_schema,
             "training",
         )
-    corpus_inferences = None
+    corpus_dataset = None
     if fixture.corpus_file_name is not None:
-        corpus_inferences = Inferences(
-            read_parquet(paths[InferencesRole.CORPUS]),
+        corpus_dataset = Inferences(
+            read_parquet(paths[DatasetRole.CORPUS]),
             fixture.corpus_schema,
             "knowledge_base",
         )
-    return primary_inferences, reference_inferences, corpus_inferences
+    return primary_dataset, reference_dataset, corpus_dataset
 
 
 def _get_fixture_by_name(fixture_name: str) -> Fixture:
@@ -496,14 +496,14 @@ def load_example(use_case: str) -> ExampleInferences:
 
     """
     fixture = _get_fixture_by_name(use_case)
-    primary_inferences, reference_inferences, corpus_inferences = get_inferences(use_case)
+    primary_dataset, reference_dataset, corpus_dataset = get_datasets(use_case)
     print(f"📥 Loaded {use_case} example datasets.")
     print("ℹ️ About this use-case:")
     print(fixture.description)
     return ExampleInferences(
-        primary=primary_inferences,
-        reference=reference_inferences,
-        corpus=corpus_inferences,
+        primary=primary_dataset,
+        reference=reference_dataset,
+        corpus=corpus_dataset,
     )
 
 
@@ -544,7 +544,7 @@ class GCSAssets(NamedTuple):
         )
 
 
-def _download(fixture: Fixture, location: Path) -> Iterator[Tuple[InferencesRole, Path]]:
+def _download(fixture: Fixture, location: Path) -> Iterator[Tuple[DatasetRole, Path]]:
     for role, path in fixture.paths():
         yield role, GCSAssets().metadata(path).save_artifact(location)
 
@@ -556,5 +556,5 @@ if __name__ == "__main__":
     for fixture in FIXTURES:
         start_time = time.time()
         print(f"getting {fixture.name}", end="...")
-        dict(_download(fixture, INFERENCES_DIR))
+        dict(_download(fixture, DATASET_DIR))
         print(f"done ({time.time() - start_time:.2f}s)")

phoenix/inferences/inferences.py

@@ -15,7 +15,7 @@ from pandas.api.types import (
 )
 from typing_extensions import TypeAlias
 
-from phoenix.config import GENERATED_INFERENCES_NAME_PREFIX, INFERENCES_DIR
+from phoenix.config import DATASET_DIR, GENERATED_DATASET_NAME_PREFIX
 from phoenix.datetime_utils import normalize_timestamps
 from phoenix.utilities.deprecation import deprecated
 
@@ -31,7 +31,7 @@ from .schema import (
     SchemaFieldName,
     SchemaFieldValue,
 )
-from .validation import validate_inferences_inputs
+from .validation import validate_dataset_inputs
 
 logger = logging.getLogger(__name__)
 
@@ -62,7 +62,7 @@ class Inferences:
 
     Examples
     --------
-    >>> primary_inferences = px.Inferences(
+    >>> primary_dataset = px.Inferences(
     >>>    dataframe=production_dataframe, schema=schema, name="primary"
     >>> )
     """
@@ -81,7 +81,7 @@ class Inferences:
         # allow for schema like objects
         if not isinstance(schema, Schema):
             schema = _get_schema_from_unknown_schema_param(schema)
-        errors = validate_inferences_inputs(
+        errors = validate_dataset_inputs(
             dataframe=dataframe,
             schema=schema,
         )
@@ -95,7 +95,7 @@ class Inferences:
         self.__dataframe: DataFrame = dataframe
         self.__schema: Schema = schema
         self.__name: str = (
-            name if name is not None else f"{GENERATED_INFERENCES_NAME_PREFIX}{str(uuid.uuid4())}"
+            name if name is not None else f"{GENERATED_DATASET_NAME_PREFIX}{str(uuid.uuid4())}"
         )
         self._is_empty = self.dataframe.empty
         logger.info(f"""Dataset: {self.__name} initialized""")
@@ -118,7 +118,7 @@ class Inferences:
     @classmethod
     def from_name(cls, name: str) -> "Inferences":
         """Retrieves a dataset by name from the file system"""
-        directory = INFERENCES_DIR / name
+        directory = DATASET_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()
@@ -127,7 +127,7 @@ class Inferences:
 
     def to_disc(self) -> None:
         """writes the data and schema to disc"""
-        directory = INFERENCES_DIR / self.name
+        directory = DATASET_DIR / self.name
         directory.mkdir(parents=True, exist_ok=True)
         self.dataframe.to_parquet(
             directory / self._data_file_name,

phoenix/inferences/validation.py

@@ -34,7 +34,7 @@ def _check_valid_schema(schema: Schema) -> List[err.ValidationError]:
     return []
 
 
-def validate_inferences_inputs(dataframe: DataFrame, schema: Schema) -> List[err.ValidationError]:
+def validate_dataset_inputs(dataframe: DataFrame, schema: Schema) -> List[err.ValidationError]:
     errors = _check_missing_columns(dataframe, schema)
     if errors:
         return errors