arize-phoenix 4.21.0__tar.gz → 4.22.1__tar.gz

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.21.0
+Version: 4.22.1
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/examples/manually-instrumented-chatbot/chat-service/chat/app.py

@@ -106,15 +106,15 @@ async def messages(messages_payload: MessagesPayload) -> MessagesResponse:
 @app.post("/feedback/")
 async def post_feedback(feedback_request: FeedbackRequest) -> None:
     if feedback_request.feedback == 1:
-        label = "thumbs_up"
+        label = "👍"
     elif feedback_request.feedback == 0:
-        label = "thumbs_down"
+        label = "👎"
 
     request_body = {
         "data": [
             {
                 "span_id": feedback_request.span_id,
-                "name": "correctness",
+                "name": "user_feedback",
                 "annotator_kind": "HUMAN",
                 "result": {"label": label, "score": feedback_request.feedback},
                 "metadata": {},

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/pyproject.toml

@@ -288,6 +288,12 @@ clean = [
   "jupyter nbconvert --ClearOutputPreprocessor.enabled=True --ClearMetadataPreprocessor.enabled=True --inplace **/*.ipynb **/internal/*.ipynb **/tracing/*.ipynb **/dolly-pythia-fine-tuned/*.ipynb",
 ]
 
+[tool.hatch.envs.auth.scripts]
+link = "cd src/phoenix/db/migrations/versions && ln -s ../future_versions/cd164e83824f_users_and_tokens.py cd164e83824f_users_and_tokens.py && echo 'created auth migration symlink'"
+unlink = "rm src/phoenix/db/migrations/versions/cd164e83824f_users_and_tokens.py && echo 'removed auth migration symlink'"
+up = "cd src/phoenix/db && alembic upgrade cd164e83824f && echo 'ran auth up-migration'"
+down = "cd src/phoenix/db && alembic downgrade 3be8647b87d8 && echo 'ran auth down-migration'"
+
 [tool.hatch.envs.publish]
 dependencies = [
   "check-wheel-contents",
@@ -300,6 +306,7 @@ testpypi = [
   "twine upload  --verbose --repository testpypi dist/*",
 ]
 pypi = [
+  "if [ -L src/phoenix/db/migrations/versions/cd164e83824f_users_and_tokens.py ]; then echo 'remove auth migration symlink before publishing with `hatch run auth:unlink`'; exit 1; fi",
   "check-wheel-contents dist/",
   "twine upload --verbose dist/*",
 ]

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/src/phoenix/config.py

@@ -2,7 +2,7 @@ import os
 import tempfile
 from logging import getLogger
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 
 from .utilities.re import parse_env_headers
 
@@ -60,6 +60,11 @@ ENV_PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_GRPC_ENDPOINT = (
     "PHOENIX_SERVER_INSTRUMENTATION_OTLP_TRACE_COLLECTOR_GRPC_ENDPOINT"
 )
 
+# Auth is under active development. Phoenix users are strongly advised not to
+# set these environment variables until the feature is officially released.
+ENV_DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH = "DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH"
+ENV_DANGEROUSLY_SET_PHOENIX_SECRET = "DANGEROUSLY_SET_PHOENIX_SECRET"
+
 
 def server_instrumentation_is_enabled() -> bool:
     return bool(
@@ -100,6 +105,57 @@ def get_working_dir() -> Path:
     return Path.home().resolve() / ".phoenix"
 
 
+def get_boolean_env_var(env_var: str) -> Optional[bool]:
+    """
+    Parses a boolean environment variable, returning None if the variable is not set.
+    """
+    if (value := os.environ.get(env_var)) is None:
+        return None
+    assert (lower := value.lower()) in (
+        "true",
+        "false",
+    ), f"{env_var} must be set to TRUE or FALSE (case-insensitive)"
+    return lower == "true"
+
+
+def get_env_enable_auth() -> bool:
+    """
+    Gets the value of the DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH environment variable.
+    """
+    return get_boolean_env_var(ENV_DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH) is True
+
+
+def get_env_phoenix_secret() -> Optional[str]:
+    """
+    Gets the value of the DANGEROUSLY_SET_PHOENIX_SECRET environment variable
+    and performs validation.
+    """
+    phoenix_secret = os.environ.get(ENV_DANGEROUSLY_SET_PHOENIX_SECRET)
+    if phoenix_secret is None:
+        return None
+    # todo: add validation for the phoenix secret
+    return phoenix_secret
+
+
+def get_auth_settings() -> Tuple[bool, Optional[str]]:
+    """
+    Gets auth settings and performs validation.
+    """
+    enable_auth = get_env_enable_auth()
+    phoenix_secret = get_env_phoenix_secret()
+    if enable_auth:
+        assert phoenix_secret, (
+            "DANGEROUSLY_SET_PHOENIX_SECRET must be set "
+            "when auth is enabled with DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH"
+        )
+    else:
+        assert not phoenix_secret, (
+            "DANGEROUSLY_SET_PHOENIX_SECRET cannot be set "
+            "unless auth is enabled with DANGEROUSLY_SET_PHOENIX_ENABLE_AUTH"
+        )
+    return enable_auth, phoenix_secret
+
+
 PHOENIX_DIR = Path(__file__).resolve().parent
 # Server config
 SERVER_DIR = PHOENIX_DIR / "server"
@@ -123,6 +179,8 @@ EXPORT_DIR = ROOT_DIR / "exports"
 INFERENCES_DIR = ROOT_DIR / "inferences"
 TRACE_DATASETS_DIR = ROOT_DIR / "trace_datasets"
 
+ENABLE_AUTH, PHOENIX_SECRET = get_auth_settings()
+
 
 def ensure_working_dir() -> None:
     """

arize_phoenix-4.22.1/src/phoenix/db/migrations/future_versions/README.md

@@ -0,0 +1,4 @@
+# Future Migrations
+
+This folder contains future migrations for unreleased features that are under active development. Do not run these migrations unless you are a Phoenix developer.
+

arize_phoenix-4.22.1/src/phoenix/db/migrations/future_versions/cd164e83824f_users_and_tokens.py

@@ -0,0 +1,292 @@
+"""users and tokens
+
+Revision ID: cd164e83824f
+Revises: 10460e46d750
+Create Date: 2024-08-01 18:36:52.157604
+
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Sequence, TypedDict, Union
+
+import sqlalchemy as sa
+from alembic import op
+from phoenix.datetime_utils import normalize_datetime
+from sqlalchemy import (
+    JSON,
+    TIMESTAMP,
+    CheckConstraint,
+    Dialect,
+    ForeignKey,
+    MetaData,
+    TypeDecorator,
+    func,
+    insert,
+)
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.ext.asyncio.engine import AsyncConnection
+from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.orm import (
+    DeclarativeBase,
+    Mapped,
+    mapped_column,
+)
+
+
+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",
+    )
+)
+
+
+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
+    impl = TIMESTAMP(timezone=True)
+
+    def process_bind_param(self, value: Optional[datetime], _: Dialect) -> Optional[datetime]:
+        return normalize_datetime(value)
+
+    def process_result_value(self, value: Optional[Any], _: Dialect) -> Optional[datetime]:
+        return normalize_datetime(value, timezone.utc)
+
+
+class ExperimentRunOutput(TypedDict, total=False):
+    task_output: 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
+    metadata = MetaData(
+        naming_convention={
+            "ix": "ix_%(table_name)s_%(column_0_N_name)s",
+            "uq": "uq_%(table_name)s_%(column_0_N_name)s",
+            "ck": "ck_%(table_name)s_`%(constraint_name)s`",
+            "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+            "pk": "pk_%(table_name)s",
+        }
+    )
+    type_annotation_map = {
+        Dict[str, Any]: JsonDict,
+        List[Dict[str, Any]]: JsonList,
+        ExperimentRunOutput: JsonDict,
+    }
+
+
+class UserRole(Base):
+    __tablename__ = "user_roles"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    role: Mapped[str] = mapped_column(unique=True)
+
+
+class User(Base):
+    __tablename__ = "users"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_role_id: Mapped[int] = mapped_column(
+        ForeignKey("user_roles.id"),
+        index=True,
+    )
+    username: Mapped[Optional[str]] = mapped_column(nullable=True, unique=True, index=True)
+    email: Mapped[str] = mapped_column(nullable=False, unique=True, index=True)
+    auth_method: Mapped[str] = mapped_column(
+        CheckConstraint("auth_method IN ('LOCAL')", name="valid_auth_method")
+    )
+    password_hash: Mapped[Optional[str]]
+    reset_password: Mapped[bool]
+    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()
+    )
+    deleted_at: Mapped[Optional[datetime]] = mapped_column(UtcTimeStamp)
+
+
+# revision identifiers, used by Alembic.
+revision: str = "cd164e83824f"
+down_revision: Union[str, None] = "3be8647b87d8"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+async def insert_roles_and_users(connection: AsyncConnection) -> None:
+    """
+    Populates the `user_roles` table and adds a system user and initial admin
+    user to the `users` table.
+    """
+    await connection.execute(
+        insert(UserRole).values([{"role": "SYSTEM"}, {"role": "ADMIN"}, {"role": "GENERAL"}])
+    )
+    system_user_role_id = sa.select(UserRole.id).where(UserRole.role == "SYSTEM").scalar_subquery()
+    admin_user_role_id = sa.select(UserRole.id).where(UserRole.role == "ADMIN").scalar_subquery()
+    await connection.execute(
+        insert(User).values(
+            [
+                {
+                    "user_role_id": system_user_role_id,
+                    "username": None,
+                    "email": "system@localhost",
+                    "auth_method": "LOCAL",
+                    "password_hash": None,
+                    "reset_password": False,
+                },
+                {
+                    "user_role_id": admin_user_role_id,
+                    "username": "admin",
+                    "email": "admin@localhost",
+                    "auth_method": "LOCAL",
+                    "password_hash": None,  # todo: replace this with the hashed PHOENIX_SECRET
+                    "reset_password": True,
+                },
+            ]
+        )
+    )
+
+
+def upgrade() -> None:
+    op.create_table(
+        "user_roles",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "role",
+            sa.String,
+            nullable=False,
+            unique=True,
+        ),
+    )
+    op.create_table(
+        "users",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "user_role_id",
+            sa.Integer,
+            sa.ForeignKey("user_roles.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column("username", sa.String, nullable=True, unique=True, index=True),
+        sa.Column("email", sa.String, nullable=False, unique=True, index=True),
+        sa.Column(
+            "auth_method",
+            sa.String,
+            sa.CheckConstraint("auth_method IN ('LOCAL')", "valid_auth_method"),
+            nullable=False,
+        ),
+        sa.Column("password_hash", sa.String, nullable=True),
+        sa.Column("reset_password", sa.Boolean, nullable=False),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "updated_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+            onupdate=sa.func.now(),
+        ),
+        sa.Column(
+            "deleted_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=True,
+        ),
+    )
+    op.create_table(
+        "api_keys",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "user_id",
+            sa.Integer,
+            sa.ForeignKey("users.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column("name", sa.String, nullable=False),
+        sa.Column("description", sa.String, nullable=True),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+        sa.Column(
+            "expires_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=True,
+        ),
+    )
+    op.create_table(
+        "audit_api_keys",
+        sa.Column("id", sa.Integer, primary_key=True),
+        sa.Column(
+            "api_key_id",
+            sa.Integer,
+            sa.ForeignKey("api_keys.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column(
+            "user_id",
+            sa.Integer,
+            sa.ForeignKey("users.id"),
+            nullable=False,
+            index=True,
+        ),
+        sa.Column(
+            "action",
+            sa.String,
+            sa.CheckConstraint("action IN ('CREATE', 'DELETE')", "valid_action"),
+            nullable=False,
+        ),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(timezone=True),
+            nullable=False,
+            server_default=sa.func.now(),
+        ),
+    )
+    op.run_async(insert_roles_and_users)
+
+
+def downgrade() -> None:
+    op.drop_table("audit_api_keys")
+    op.drop_table("api_keys")
+    op.drop_table("users")
+    op.drop_table("user_roles")

arize_phoenix-4.22.1/src/phoenix/db/migrations/versions/.gitignore

@@ -0,0 +1 @@
+cd164e83824f_users_and_tokens.py

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/src/phoenix/db/models.py

@@ -34,6 +34,7 @@ from sqlalchemy.orm import (
 )
 from sqlalchemy.sql import expression
 
+from phoenix.config import ENABLE_AUTH
 from phoenix.datetime_utils import normalize_datetime
 
 
@@ -616,3 +617,63 @@ class ExperimentRunAnnotation(Base):
             "name",
         ),
     )
+
+
+# todo: unnest the following models when auth is released (https://github.com/Arize-ai/phoenix/issues/4183)
+if ENABLE_AUTH:
+
+    class UserRole(Base):
+        __tablename__ = "user_roles"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        role: Mapped[str] = mapped_column(unique=True)
+
+    class User(Base):
+        __tablename__ = "users"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        user_role_id: Mapped[int] = mapped_column(
+            ForeignKey("user_roles.id"),
+            index=True,
+        )
+        username: Mapped[Optional[str]] = mapped_column(nullable=True, unique=True, index=True)
+        email: Mapped[str] = mapped_column(nullable=False, unique=True, index=True)
+        auth_method: Mapped[str] = mapped_column(
+            CheckConstraint("auth_method IN ('LOCAL')", name="valid_auth_method")
+        )
+        password_hash: Mapped[Optional[str]]
+        reset_password: Mapped[bool]
+        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()
+        )
+        deleted_at: Mapped[Optional[datetime]] = mapped_column(UtcTimeStamp)
+
+    class APIKey(Base):
+        __tablename__ = "api_keys"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        user_id: Mapped[int] = mapped_column(
+            ForeignKey("users.id"),
+            index=True,
+        )
+        name: Mapped[str]
+        description: Mapped[Optional[str]]
+        created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
+        expires_at: Mapped[Optional[datetime]] = mapped_column(UtcTimeStamp)
+
+    # todo: standardize audit table format (https://github.com/Arize-ai/phoenix/issues/4185)
+    class AuditAPIKey(Base):
+        __tablename__ = "audit_api_keys"
+        id: Mapped[int] = mapped_column(primary_key=True)
+        api_key_id: Mapped[int] = mapped_column(
+            ForeignKey("api_keys.id"),
+            nullable=False,
+            index=True,
+        )
+        user_id: Mapped[int] = mapped_column(
+            ForeignKey("users.id"),
+            nullable=False,
+            index=True,
+        )
+        action: Mapped[str] = mapped_column(
+            CheckConstraint("action IN ('CREATE', 'DELETE')", name="valid_action")
+        )
+        created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/src/phoenix/experiments/functions.py

@@ -447,14 +447,14 @@ def evaluate_experiment(
         )
         if not dataset.examples:
             raise ValueError(f"Dataset has no examples: {dataset_id=}, {dataset_version_id=}")
-        experiment_runs = tuple(
-            ExperimentRun.from_dict(exp_run)
+        experiment_runs = {
+            exp_run["id"]: ExperimentRun.from_dict(exp_run)
             for exp_run in sync_client.get(f"/v1/experiments/{experiment.id}/runs").json()["data"]
-        )
+        }
         if not experiment_runs:
             raise ValueError("Experiment has not been run")
         params = ExperimentParameters(n_examples=len(dataset.examples))
-        task_summary = TaskSummary.from_task_runs(params, experiment_runs)
+        task_summary = TaskSummary.from_task_runs(params, experiment_runs.values())
         ran_experiment = object.__new__(RanExperiment)
         ran_experiment.__init__(  # type: ignore[misc]
             dataset=dataset,

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/src/phoenix/experiments/types.py

@@ -167,7 +167,7 @@ class Dataset:
     def from_dict(cls, obj: Mapping[str, Any]) -> Dataset:
         examples = tuple(map(Example.from_dict, obj.get("examples") or ()))
         return cls(
-            id=obj["id"],
+            id=obj["dataset_id"],
             version_id=obj["version_id"],
             examples={ex.id: ex for ex in examples},
         )
@@ -225,7 +225,7 @@ class ExperimentRun:
         )
 
     def __post_init__(self) -> None:
-        if bool(self.output) == bool(self.error):
+        if self.output is None and self.error is None:
             raise ValueError("Must specify exactly one of experiment_run_output or error")
 
 
@@ -284,7 +284,7 @@ class ExperimentEvaluationRun:
         )
 
     def __post_init__(self) -> None:
-        if bool(self.result) == bool(self.error):
+        if self.result is None and self.error is None:
             raise ValueError("Must specify either result or error")
 
 

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/src/phoenix/server/api/context.py

@@ -14,7 +14,6 @@ from phoenix.server.api.dataloaders import (
     DocumentEvaluationsDataLoader,
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
-    EvaluationSummaryDataLoader,
     ExperimentAnnotationSummaryDataLoader,
     ExperimentErrorRatesDataLoader,
     ExperimentRunCountsDataLoader,
@@ -26,10 +25,8 @@ from phoenix.server.api.dataloaders import (
     SpanAnnotationsDataLoader,
     SpanDatasetExamplesDataLoader,
     SpanDescendantsDataLoader,
-    SpanEvaluationsDataLoader,
     SpanProjectsDataLoader,
     TokenCountDataLoader,
-    TraceEvaluationsDataLoader,
     TraceRowIdsDataLoader,
 )
 from phoenix.server.dml_event import DmlEvent
@@ -45,7 +42,6 @@ class DataLoaders:
     document_evaluations: DocumentEvaluationsDataLoader
     document_retrieval_metrics: DocumentRetrievalMetricsDataLoader
     annotation_summaries: AnnotationSummaryDataLoader
-    evaluation_summaries: EvaluationSummaryDataLoader
     experiment_annotation_summaries: ExperimentAnnotationSummaryDataLoader
     experiment_error_rates: ExperimentErrorRatesDataLoader
     experiment_run_counts: ExperimentRunCountsDataLoader
@@ -56,10 +52,8 @@ class DataLoaders:
     span_annotations: SpanAnnotationsDataLoader
     span_dataset_examples: SpanDatasetExamplesDataLoader
     span_descendants: SpanDescendantsDataLoader
-    span_evaluations: SpanEvaluationsDataLoader
     span_projects: SpanProjectsDataLoader
     token_counts: TokenCountDataLoader
-    trace_evaluations: TraceEvaluationsDataLoader
     trace_row_ids: TraceRowIdsDataLoader
     project_by_name: ProjectByNameDataLoader
 

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/src/phoenix/server/api/dataloaders/__init__.py

@@ -10,7 +10,6 @@ from .document_evaluation_summaries import (
 )
 from .document_evaluations import DocumentEvaluationsDataLoader
 from .document_retrieval_metrics import DocumentRetrievalMetricsDataLoader
-from .evaluation_summaries import EvaluationSummaryCache, EvaluationSummaryDataLoader
 from .experiment_annotation_summaries import ExperimentAnnotationSummaryDataLoader
 from .experiment_error_rates import ExperimentErrorRatesDataLoader
 from .experiment_run_counts import ExperimentRunCountsDataLoader
@@ -22,10 +21,8 @@ from .record_counts import RecordCountCache, RecordCountDataLoader
 from .span_annotations import SpanAnnotationsDataLoader
 from .span_dataset_examples import SpanDatasetExamplesDataLoader
 from .span_descendants import SpanDescendantsDataLoader
-from .span_evaluations import SpanEvaluationsDataLoader
 from .span_projects import SpanProjectsDataLoader
 from .token_counts import TokenCountCache, TokenCountDataLoader
-from .trace_evaluations import TraceEvaluationsDataLoader
 from .trace_row_ids import TraceRowIdsDataLoader
 
 __all__ = [
@@ -37,7 +34,6 @@ __all__ = [
     "DocumentEvaluationsDataLoader",
     "DocumentRetrievalMetricsDataLoader",
     "AnnotationSummaryDataLoader",
-    "EvaluationSummaryDataLoader",
     "ExperimentAnnotationSummaryDataLoader",
     "ExperimentErrorRatesDataLoader",
     "ExperimentRunCountsDataLoader",
@@ -47,10 +43,8 @@ __all__ = [
     "RecordCountDataLoader",
     "SpanDatasetExamplesDataLoader",
     "SpanDescendantsDataLoader",
-    "SpanEvaluationsDataLoader",
     "SpanProjectsDataLoader",
     "TokenCountDataLoader",
-    "TraceEvaluationsDataLoader",
     "TraceRowIdsDataLoader",
     "ProjectByNameDataLoader",
     "SpanAnnotationsDataLoader",
@@ -65,9 +59,6 @@ class CacheForDataLoaders:
     annotation_summary: AnnotationSummaryCache = field(
         default_factory=AnnotationSummaryCache,
     )
-    evaluation_summary: EvaluationSummaryCache = field(
-        default_factory=EvaluationSummaryCache,
-    )
     latency_ms_quantile: LatencyMsQuantileCache = field(
         default_factory=LatencyMsQuantileCache,
     )

{arize_phoenix-4.21.0 → arize_phoenix-4.22.1}/src/phoenix/server/api/routers/v1/experiment_runs.py

@@ -108,7 +108,12 @@ async def create_experiment_run(
     return CreateExperimentResponseBody(data=CreateExperimentRunResponseBodyData(id=str(run_gid)))
 
 
-class ListExperimentRunsResponseBody(ResponseBody[List[ExperimentRun]]):
+class ExperimentRunResponse(ExperimentRun):
+    id: str = Field(description="The ID of the experiment run")
+    experiment_id: str = Field(description="The ID of the experiment")
+
+
+class ListExperimentRunsResponseBody(ResponseBody[List[ExperimentRunResponse]]):
     pass
 
 
@@ -147,7 +152,7 @@ async def list_experiment_runs(
             experiment_gid = GlobalID("Experiment", str(exp_run.experiment_id))
             example_gid = GlobalID("DatasetExample", str(exp_run.dataset_example_id))
             runs.append(
-                ExperimentRun(
+                ExperimentRunResponse(
                     start_time=exp_run.start_time,
                     end_time=exp_run.end_time,
                     experiment_id=str(experiment_gid),