arize-phoenix 8.12.1__tar.gz → 8.13.0__tar.gz

{arize_phoenix-8.12.1 → arize_phoenix-8.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 8.12.1
+Version: 8.13.0
 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-8.12.1 → arize_phoenix-8.13.0}/src/phoenix/db/migrations/versions/10460e46d750_datasets.py

@@ -29,7 +29,7 @@ def _(*args: Any, **kwargs: Any) -> str:
 JSON_ = (
     JSON()
     .with_variant(
-        postgresql.JSONB(),  # type: ignore
+        postgresql.JSONB(),
         "postgresql",
     )
     .with_variant(

{arize_phoenix-8.12.1 → arize_phoenix-8.13.0}/src/phoenix/db/migrations/versions/3be8647b87d8_add_token_columns_to_spans_table.py

@@ -41,7 +41,7 @@ def _(*args: Any, **kwargs: Any) -> str:
 JSON_ = (
     JSON()
     .with_variant(
-        postgresql.JSONB(),  # type: ignore
+        postgresql.JSONB(),
         "postgresql",
     )
     .with_variant(

{arize_phoenix-8.12.1 → arize_phoenix-8.13.0}/src/phoenix/db/migrations/versions/bc8fea3c2bc8_add_prompt_tables.py

@@ -29,7 +29,7 @@ def _(*args: Any, **kwargs: Any) -> str:
 JSON_ = (
     JSON()
     .with_variant(
-        postgresql.JSONB(),  # type: ignore
+        postgresql.JSONB(),
         "postgresql",
     )
     .with_variant(

{arize_phoenix-8.12.1 → arize_phoenix-8.13.0}/src/phoenix/db/migrations/versions/cf03bd6bae1d_init.py

@@ -29,7 +29,7 @@ def _(*args: Any, **kwargs: Any) -> str:
 JSON_ = (
     JSON()
     .with_variant(
-        postgresql.JSONB(),  # type: ignore
+        postgresql.JSONB(),
         "postgresql",
     )
     .with_variant(

{arize_phoenix-8.12.1 → arize_phoenix-8.13.0}/src/phoenix/db/models.py

@@ -159,7 +159,7 @@ def _(*args: Any, **kwargs: Any) -> str:
 JSON_ = (
     JSON()
     .with_variant(
-        postgresql.JSONB(),  # type: ignore
+        postgresql.JSONB(),
         "postgresql",
     )
     .with_variant(

{arize_phoenix-8.12.1 → arize_phoenix-8.13.0}/src/phoenix/server/api/routers/v1/experiments.py

@@ -3,13 +3,15 @@ from datetime import datetime
 from random import getrandbits
 from typing import Any, Optional
 
+import pandas as pd
 from fastapi import APIRouter, HTTPException, Path, Response
 from pydantic import Field
 from sqlalchemy import and_, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import joinedload
 from starlette.requests import Request
 from starlette.responses import PlainTextResponse
-from starlette.status import HTTP_404_NOT_FOUND
+from starlette.status import HTTP_200_OK, HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY
 from strawberry.relay import GlobalID
 
 from phoenix.db import models
@@ -19,7 +21,7 @@ from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.dml_event import ExperimentInsertEvent
 
 from .models import V1RoutesBaseModel
-from .utils import ResponseBody, add_errors_to_responses
+from .utils import ResponseBody, add_errors_to_responses, add_text_csv_content_to_responses
 
 router = APIRouter(tags=["experiments"], include_in_schema=True)
 
@@ -311,6 +313,66 @@ async def list_experiments(
         return ListExperimentsResponseBody(data=data)
 
 
+async def _get_experiment_runs_and_revisions(
+    session: AsyncSession, experiment_rowid: int
+) -> tuple[models.Experiment, tuple[models.ExperimentRun], tuple[models.DatasetExampleRevision]]:
+    experiment = await session.get(models.Experiment, experiment_rowid)
+    if not experiment:
+        raise HTTPException(detail="Experiment not found", status_code=HTTP_404_NOT_FOUND)
+    revision_ids = (
+        select(func.max(models.DatasetExampleRevision.id))
+        .join(
+            models.DatasetExample,
+            models.DatasetExample.id == models.DatasetExampleRevision.dataset_example_id,
+        )
+        .where(
+            and_(
+                models.DatasetExampleRevision.dataset_version_id <= experiment.dataset_version_id,
+                models.DatasetExample.dataset_id == experiment.dataset_id,
+            )
+        )
+        .group_by(models.DatasetExampleRevision.dataset_example_id)
+        .scalar_subquery()
+    )
+    runs_and_revisions = (
+        (
+            await session.execute(
+                select(models.ExperimentRun, models.DatasetExampleRevision)
+                .join(
+                    models.DatasetExample,
+                    models.DatasetExample.id == models.ExperimentRun.dataset_example_id,
+                )
+                .join(
+                    models.DatasetExampleRevision,
+                    and_(
+                        models.DatasetExample.id
+                        == models.DatasetExampleRevision.dataset_example_id,
+                        models.DatasetExampleRevision.id.in_(revision_ids),
+                        models.DatasetExampleRevision.revision_kind != "DELETE",
+                    ),
+                )
+                .options(
+                    joinedload(models.ExperimentRun.annotations),
+                )
+                .where(models.ExperimentRun.experiment_id == experiment_rowid)
+                .order_by(
+                    models.ExperimentRun.dataset_example_id,
+                    models.ExperimentRun.repetition_number,
+                )
+            )
+        )
+        .unique()
+        .all()
+    )
+    if not runs_and_revisions:
+        raise HTTPException(
+            detail="Experiment has no runs",
+            status_code=HTTP_404_NOT_FOUND,
+        )
+    runs, revisions = zip(*runs_and_revisions)
+    return experiment, runs, revisions
+
+
 @router.get(
     "/experiments/{experiment_id}/json",
     operation_id="getExperimentJSON",
@@ -324,112 +386,133 @@ async def list_experiments(
 )
 async def get_experiment_json(
     request: Request,
-    response: Response,
     experiment_id: str = Path(..., title="Experiment ID"),
-) -> str:
+) -> Response:
     experiment_globalid = GlobalID.from_id(experiment_id)
     try:
         experiment_rowid = from_global_id_with_expected_type(experiment_globalid, "Experiment")
     except ValueError:
         raise HTTPException(
-            detail=f"Experiment with ID {experiment_globalid} does not exist",
-            status_code=HTTP_404_NOT_FOUND,
+            detail=f"Invalid experiment ID: {experiment_globalid}",
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
         )
 
     async with request.app.state.db() as session:
-        experiment = await session.get(models.Experiment, experiment_rowid)
-        if not experiment:
-            raise HTTPException(
-                detail=f"Experiment with ID {experiment_globalid} does not exist",
-                status_code=HTTP_404_NOT_FOUND,
-            )
-        revision_ids = (
-            select(func.max(models.DatasetExampleRevision.id))
-            .join(
-                models.DatasetExample,
-                models.DatasetExample.id == models.DatasetExampleRevision.dataset_example_id,
-            )
-            .where(
-                and_(
-                    models.DatasetExampleRevision.dataset_version_id
-                    <= experiment.dataset_version_id,
-                    models.DatasetExample.dataset_id == experiment.dataset_id,
-                )
-            )
-            .group_by(models.DatasetExampleRevision.dataset_example_id)
-            .scalar_subquery()
+        experiment, runs, revisions = await _get_experiment_runs_and_revisions(
+            session, experiment_rowid
         )
-        runs_and_revisions = (
-            (
-                await session.execute(
-                    select(models.ExperimentRun, models.DatasetExampleRevision)
-                    .join(
-                        models.DatasetExample,
-                        models.DatasetExample.id == models.ExperimentRun.dataset_example_id,
-                    )
-                    .join(
-                        models.DatasetExampleRevision,
-                        and_(
-                            models.DatasetExample.id
-                            == models.DatasetExampleRevision.dataset_example_id,
-                            models.DatasetExampleRevision.id.in_(revision_ids),
-                            models.DatasetExampleRevision.revision_kind != "DELETE",
-                        ),
-                    )
-                    .options(
-                        joinedload(models.ExperimentRun.annotations),
-                    )
-                    .where(models.ExperimentRun.experiment_id == experiment_rowid)
-                    .order_by(
-                        models.ExperimentRun.dataset_example_id,
-                        models.ExperimentRun.repetition_number,
-                    )
+        records = []
+        for run, revision in zip(runs, revisions):
+            annotations = []
+            for annotation in run.annotations:
+                annotations.append(
+                    {
+                        "name": annotation.name,
+                        "annotator_kind": annotation.annotator_kind,
+                        "label": annotation.label,
+                        "score": annotation.score,
+                        "explanation": annotation.explanation,
+                        "trace_id": annotation.trace_id,
+                        "error": annotation.error,
+                        "metadata": annotation.metadata_,
+                        "start_time": annotation.start_time.isoformat(),
+                        "end_time": annotation.end_time.isoformat(),
+                    }
                 )
-            )
-            .unique()
-            .all()
+            record = {
+                "example_id": str(
+                    GlobalID(models.DatasetExample.__name__, str(run.dataset_example_id))
+                ),
+                "repetition_number": run.repetition_number,
+                "input": revision.input,
+                "reference_output": revision.output,
+                "output": run.output["task_output"],
+                "error": run.error,
+                "latency_ms": run.latency_ms,
+                "start_time": run.start_time.isoformat(),
+                "end_time": run.end_time.isoformat(),
+                "trace_id": run.trace_id,
+                "prompt_token_count": run.prompt_token_count,
+                "completion_token_count": run.completion_token_count,
+                "annotations": annotations,
+            }
+            records.append(record)
+
+        return Response(
+            content=json.dumps(records, ensure_ascii=False, indent=2),
+            headers={"content-disposition": f'attachment; filename="{experiment.name}.json"'},
+            media_type="application/json",
         )
-        if not runs_and_revisions:
-            raise HTTPException(
-                detail=f"Experiment with ID {experiment_globalid} has no runs",
-                status_code=HTTP_404_NOT_FOUND,
-            )
-    records = []
-    for run, revision in runs_and_revisions:
-        annotations = []
-        for annotation in run.annotations:
-            annotations.append(
-                {
-                    "name": annotation.name,
-                    "annotator_kind": annotation.annotator_kind,
-                    "label": annotation.label,
-                    "score": annotation.score,
-                    "explanation": annotation.explanation,
-                    "trace_id": annotation.trace_id,
-                    "error": annotation.error,
-                    "metadata": annotation.metadata_,
-                    "start_time": annotation.start_time.isoformat(),
-                    "end_time": annotation.end_time.isoformat(),
-                }
+
+
+@router.get(
+    "/experiments/{experiment_id}/csv",
+    operation_id="getExperimentCSV",
+    summary="Download experiment runs as a CSV file",
+    responses={**add_text_csv_content_to_responses(HTTP_200_OK)},
+)
+async def get_experiment_csv(
+    request: Request,
+    experiment_id: str = Path(..., title="Experiment ID"),
+) -> Response:
+    experiment_globalid = GlobalID.from_id(experiment_id)
+    try:
+        experiment_rowid = from_global_id_with_expected_type(experiment_globalid, "Experiment")
+    except ValueError:
+        raise HTTPException(
+            detail=f"Invalid experiment ID: {experiment_globalid}",
+            status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+        )
+
+    async with request.app.state.db() as session:
+        experiment, runs, revisions = await _get_experiment_runs_and_revisions(
+            session, experiment_rowid
+        )
+        records = []
+        for run, revision in zip(runs, revisions):
+            serialized_run_output = (
+                json.dumps(run.output["task_output"])
+                if isinstance(run.output["task_output"], dict)
+                else run.output["task_output"]
             )
-        record = {
-            "example_id": str(
-                GlobalID(models.DatasetExample.__name__, str(run.dataset_example_id))
-            ),
-            "repetition_number": run.repetition_number,
-            "input": revision.input,
-            "reference_output": revision.output,
-            "output": run.output["task_output"],
-            "error": run.error,
-            "latency_ms": run.latency_ms,
-            "start_time": run.start_time.isoformat(),
-            "end_time": run.end_time.isoformat(),
-            "trace_id": run.trace_id,
-            "prompt_token_count": run.prompt_token_count,
-            "completion_token_count": run.completion_token_count,
-            "annotations": annotations,
-        }
-        records.append(record)
-
-    response.headers["content-disposition"] = f'attachment; filename="{experiment.name}.json"'
-    return json.dumps(records, ensure_ascii=False, indent=2)
+            record = {
+                "example_id": str(GlobalID("DatasetExample", str(run.dataset_example_id))),
+                "repetition_number": run.repetition_number,
+                "input": json.dumps(revision.input),
+                "reference_output": json.dumps(revision.output),
+                "output": serialized_run_output,
+                "error": run.error,
+                "latency_ms": run.latency_ms,
+                "start_time": run.start_time.isoformat(),
+                "end_time": run.end_time.isoformat(),
+                "trace_id": run.trace_id,
+                "prompt_token_count": run.prompt_token_count,
+                "completion_token_count": run.completion_token_count,
+            }
+            for annotation in run.annotations:
+                prefix = f"annotation_{annotation.name}"
+                record.update(
+                    {
+                        f"{prefix}_label": annotation.label,
+                        f"{prefix}_score": annotation.score,
+                        f"{prefix}_explanation": annotation.explanation,
+                        f"{prefix}_metadata": json.dumps(annotation.metadata_),
+                        f"{prefix}_annotator_kind": annotation.annotator_kind,
+                        f"{prefix}_trace_id": annotation.trace_id,
+                        f"{prefix}_error": annotation.error,
+                        f"{prefix}_start_time": annotation.start_time.isoformat(),
+                        f"{prefix}_end_time": annotation.end_time.isoformat(),
+                    }
+                )
+            records.append(record)
+
+        df = pd.DataFrame.from_records(records)
+        csv_content = df.to_csv(index=False).encode()
+
+        return Response(
+            content=csv_content,
+            headers={
+                "content-disposition": f'attachment; filename="{experiment.name}.csv"',
+                "content-type": "text/csv",
+            },
+        )

arize_phoenix-8.13.0/src/phoenix/server/static/.vite/manifest.json

@@ -0,0 +1,87 @@
+{
+  "_components-Igx2_EFY.js": {
+    "file": "assets/components-Igx2_EFY.js",
+    "name": "components",
+    "imports": [
+      "_vendor-CwOvppSU.js",
+      "_pages-x8AxTGd1.js",
+      "_vendor-arizeai-bw-hz0cw.js",
+      "_vendor-codemirror-Du5cjwoZ.js",
+      "_vendor-three-C-AGeJYv.js"
+    ]
+  },
+  "_pages-x8AxTGd1.js": {
+    "file": "assets/pages-x8AxTGd1.js",
+    "name": "pages",
+    "imports": [
+      "_vendor-CwOvppSU.js",
+      "_vendor-arizeai-bw-hz0cw.js",
+      "_components-Igx2_EFY.js",
+      "_vendor-codemirror-Du5cjwoZ.js",
+      "_vendor-recharts-BMT-13Pz.js"
+    ]
+  },
+  "_vendor-Cg6lcjUC.css": {
+    "file": "assets/vendor-Cg6lcjUC.css",
+    "src": "_vendor-Cg6lcjUC.css"
+  },
+  "_vendor-CwOvppSU.js": {
+    "file": "assets/vendor-CwOvppSU.js",
+    "name": "vendor",
+    "imports": [
+      "_vendor-three-C-AGeJYv.js"
+    ],
+    "css": [
+      "assets/vendor-Cg6lcjUC.css"
+    ]
+  },
+  "_vendor-arizeai-bw-hz0cw.js": {
+    "file": "assets/vendor-arizeai-bw-hz0cw.js",
+    "name": "vendor-arizeai",
+    "imports": [
+      "_vendor-CwOvppSU.js"
+    ]
+  },
+  "_vendor-codemirror-Du5cjwoZ.js": {
+    "file": "assets/vendor-codemirror-Du5cjwoZ.js",
+    "name": "vendor-codemirror",
+    "imports": [
+      "_vendor-CwOvppSU.js",
+      "_vendor-shiki-CevgDqNV.js"
+    ]
+  },
+  "_vendor-recharts-BMT-13Pz.js": {
+    "file": "assets/vendor-recharts-BMT-13Pz.js",
+    "name": "vendor-recharts",
+    "imports": [
+      "_vendor-CwOvppSU.js"
+    ]
+  },
+  "_vendor-shiki-CevgDqNV.js": {
+    "file": "assets/vendor-shiki-CevgDqNV.js",
+    "name": "vendor-shiki",
+    "imports": [
+      "_vendor-CwOvppSU.js"
+    ]
+  },
+  "_vendor-three-C-AGeJYv.js": {
+    "file": "assets/vendor-three-C-AGeJYv.js",
+    "name": "vendor-three"
+  },
+  "index.tsx": {
+    "file": "assets/index-C2-HcjQo.js",
+    "name": "index",
+    "src": "index.tsx",
+    "isEntry": true,
+    "imports": [
+      "_vendor-CwOvppSU.js",
+      "_vendor-arizeai-bw-hz0cw.js",
+      "_pages-x8AxTGd1.js",
+      "_components-Igx2_EFY.js",
+      "_vendor-three-C-AGeJYv.js",
+      "_vendor-codemirror-Du5cjwoZ.js",
+      "_vendor-shiki-CevgDqNV.js",
+      "_vendor-recharts-BMT-13Pz.js"
+    ]
+  }
+}