arize-phoenix 11.30.0__py3-none-any.whl → 11.32.0__py3-none-any.whl

phoenix/server/api/routers/v1/documents.py

@@ -1,5 +1,4 @@
-from datetime import datetime, timezone
-from typing import Any, Literal, Optional
+from typing import Optional
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 from pydantic import Field
@@ -11,64 +10,19 @@ from strawberry.relay import GlobalID
 from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect
 from phoenix.db.insertion.helpers import as_kv, insert_on_conflict
-from phoenix.db.insertion.types import Precursors
-from phoenix.server.api.types.Evaluation import DocumentAnnotation
+from phoenix.server.api.routers.v1.annotations import SpanDocumentAnnotationData
+from phoenix.server.api.types.DocumentAnnotation import DocumentAnnotation
 from phoenix.server.authorization import is_not_locked
 from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import DocumentAnnotationInsertEvent
 
 from .models import V1RoutesBaseModel
-from .spans import SpanAnnotationResult
 from .utils import RequestBody, ResponseBody, add_errors_to_responses
 
 # Since the document annotations are spans related, we place it under spans
 router = APIRouter(tags=["spans"])
 
 
-class SpanDocumentAnnotationData(V1RoutesBaseModel):
-    span_id: str = Field(description="OpenTelemetry Span ID (hex format w/o 0x prefix)")
-    name: str = Field(description="The name of the document annotation. E.x. relevance")
-    annotator_kind: Literal["LLM", "CODE", "HUMAN"] = Field(
-        description="The kind of annotator. E.g. llm judge, a heuristic piece of code, or a human"
-    )
-    document_position: int = Field(
-        description="A 0 based index of the document. E.x. the first document during retrieval is 0"
-    )
-    result: Optional[SpanAnnotationResult] = Field(
-        default=None, description="The score and or label of the annotation"
-    )
-    metadata: Optional[dict[str, Any]] = Field(
-        default=None, description="Metadata for custom values of the annotation"
-    )
-    identifier: str = Field(
-        default="",
-        description=(
-            "An custom ID for the annotation. "
-            "If provided, the annotation will be updated if it already exists."
-        ),
-    )
-
-    # Precursor here means a value to add to a queue for processing async
-    def as_precursor(self, *, user_id: Optional[int] = None) -> Precursors.DocumentAnnotation:
-        return Precursors.DocumentAnnotation(
-            datetime.now(timezone.utc),
-            self.span_id,
-            self.document_position,
-            models.DocumentAnnotation(
-                name=self.name,
-                annotator_kind=self.annotator_kind,
-                document_position=self.document_position,
-                score=self.result.score if self.result else None,
-                label=self.result.label if self.result else None,
-                explanation=self.result.explanation if self.result else None,
-                metadata_=self.metadata or {},
-                identifier=self.identifier,
-                source="API",
-                user_id=user_id,
-            ),
-        )
-
-
 class AnnotateSpanDocumentsRequestBody(RequestBody[list[SpanDocumentAnnotationData]]):
     pass
 
@@ -90,7 +44,11 @@ class AnnotateSpanDocumentsResponseBody(ResponseBody[list[InsertedSpanDocumentAn
             {
                 "status_code": HTTP_404_NOT_FOUND,
                 "description": "Span not found",
-            }
+            },
+            {
+                "status_code": 422,
+                "description": "Invalid request - non-empty identifier not supported",
+            },
         ]
     ),
     response_description="Span document annotation inserted successfully",
@@ -106,6 +64,14 @@ async def annotate_span_documents(
     if not request_body.data:
         return AnnotateSpanDocumentsResponseBody(data=[])
 
+    # Validate that identifiers are empty or only whitespace
+    for annotation in request_body.data:
+        if annotation.identifier.strip():
+            raise HTTPException(
+                detail=f"Non-empty identifier '{annotation.identifier}' is not supported",
+                status_code=422,  # Unprocessable Entity
+            )
+
     user_id: Optional[int] = None
     if request.app.state.authentication_enabled and isinstance(request.user, PhoenixUser):
         user_id = int(request.user.identity)
@@ -117,6 +83,7 @@ async def annotate_span_documents(
     ]
     if not sync:
         await request.state.enqueue(*precursors)
+        return AnnotateSpanDocumentsResponseBody(data=[])
 
     span_ids = {p.span_id for p in precursors}
     # Account for the fact that the spans could arrive after the annotation
@@ -130,38 +97,39 @@ async def annotate_span_documents(
             )
         }
 
-    missing_span_ids = span_ids - set(existing_spans.keys())
-    # We prefer to fail the entire operation if there are missing spans in sync mode
-    if missing_span_ids:
-        raise HTTPException(
-            detail=f"Spans with IDs {', '.join(missing_span_ids)} do not exist.",
-            status_code=HTTP_404_NOT_FOUND,
-        )
-
-    # Validate that document positions are within bounds
-    for annotation in span_document_annotations:
-        _, num_docs = existing_spans[annotation.span_id]
-        if annotation.document_position not in range(num_docs):
+        missing_span_ids = span_ids - set(existing_spans.keys())
+        # We prefer to fail the entire operation if there are missing spans in sync mode
+        if missing_span_ids:
             raise HTTPException(
-                detail=f"Document position {annotation.document_position} is out of bounds for "
-                f"span {annotation.span_id} (max: {num_docs - 1})",
-                status_code=422,  # Unprocessable Entity
+                detail=f"Spans with IDs {', '.join(missing_span_ids)} do not exist.",
+                status_code=HTTP_404_NOT_FOUND,
             )
 
-    inserted_document_annotation_ids = []
-    dialect = SupportedSQLDialect(session.bind.dialect.name)
-    for anno in precursors:
-        span_rowid, _ = existing_spans[anno.span_id]
-        values = dict(as_kv(anno.as_insertable(span_rowid).row))
-        span_document_annotation_id = await session.scalar(
-            insert_on_conflict(
-                values,
-                dialect=dialect,
-                table=models.DocumentAnnotation,
-                unique_by=("name", "span_rowid", "identifier", "document_position"),
-            ).returning(models.DocumentAnnotation.id)
-        )
-        inserted_document_annotation_ids.append(span_document_annotation_id)
+        # Validate that document positions are within bounds
+        for annotation in span_document_annotations:
+            _, num_docs = existing_spans[annotation.span_id]
+            if annotation.document_position not in range(num_docs):
+                raise HTTPException(
+                    detail=f"Document position {annotation.document_position} is out of bounds for "
+                    f"span {annotation.span_id} (max: {num_docs - 1})",
+                    status_code=422,  # Unprocessable Entity
+                )
+
+        inserted_document_annotation_ids = []
+        dialect = SupportedSQLDialect(session.bind.dialect.name)
+        for anno in precursors:
+            span_rowid, _ = existing_spans[anno.span_id]
+            values = dict(as_kv(anno.as_insertable(span_rowid).row))
+            span_document_annotation_id = await session.scalar(
+                insert_on_conflict(
+                    values,
+                    dialect=dialect,
+                    table=models.DocumentAnnotation,
+                    unique_by=("name", "span_rowid", "identifier", "document_position"),
+                    constraint_name="uq_document_annotations_name_span_rowid_document_pos_identifier",
+                ).returning(models.DocumentAnnotation.id)
+            )
+            inserted_document_annotation_ids.append(span_document_annotation_id)
 
     # We queue an event to let the application know that annotations have changed
     request.state.event_queue.put(

phoenix/server/api/routers/v1/experiment_runs.py

@@ -1,13 +1,13 @@
 from datetime import datetime
 from typing import Any, Optional
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Query
 from pydantic import Field
 from sqlalchemy import select
 from sqlalchemy.exc import IntegrityError as PostgreSQLIntegrityError
 from sqlean.dbapi2 import IntegrityError as SQLiteIntegrityError  # type: ignore[import-untyped]
 from starlette.requests import Request
-from starlette.status import HTTP_404_NOT_FOUND, HTTP_409_CONFLICT
+from starlette.status import HTTP_404_NOT_FOUND, HTTP_409_CONFLICT, HTTP_422_UNPROCESSABLE_ENTITY
 from strawberry.relay import GlobalID
 
 from phoenix.db import models
@@ -17,7 +17,7 @@ from phoenix.server.authorization import is_not_locked
 from phoenix.server.dml_event import ExperimentRunInsertEvent
 
 from .models import V1RoutesBaseModel
-from .utils import ResponseBody, add_errors_to_responses
+from .utils import PaginatedResponseBody, ResponseBody, add_errors_to_responses
 
 router = APIRouter(tags=["experiments"], include_in_schema=True)
 
@@ -129,7 +129,7 @@ class ExperimentRunResponse(ExperimentRun):
     experiment_id: str = Field(description="The ID of the experiment")
 
 
-class ListExperimentRunsResponseBody(ResponseBody[list[ExperimentRunResponse]]):
+class ListExperimentRunsResponseBody(PaginatedResponseBody[ExperimentRunResponse]):
     pass
 
 
@@ -137,13 +137,28 @@ class ListExperimentRunsResponseBody(ResponseBody[list[ExperimentRunResponse]]):
     "/experiments/{experiment_id}/runs",
     operation_id="listExperimentRuns",
     summary="List runs for an experiment",
+    description="Retrieve a paginated list of runs for an experiment",
     response_description="Experiment runs retrieved successfully",
     responses=add_errors_to_responses(
-        [{"status_code": HTTP_404_NOT_FOUND, "description": "Experiment not found"}]
+        [
+            {"status_code": HTTP_404_NOT_FOUND, "description": "Experiment not found"},
+            {"status_code": HTTP_422_UNPROCESSABLE_ENTITY, "description": "Invalid cursor format"},
+        ]
     ),
 )
 async def list_experiment_runs(
-    request: Request, experiment_id: str
+    request: Request,
+    experiment_id: str,
+    cursor: Optional[str] = Query(
+        default=None,
+        description="Cursor for pagination (base64-encoded experiment run ID)",
+    ),
+    limit: Optional[int] = Query(
+        default=None,
+        description="The max number of experiment runs to return at a time. "
+        "If not specified, returns all results.",
+        gt=0,
+    ),
 ) -> ListExperimentRunsResponseBody:
     experiment_gid = GlobalID.from_id(experiment_id)
     try:
@@ -154,30 +169,55 @@ async def list_experiment_runs(
             status_code=HTTP_404_NOT_FOUND,
         )
 
+    stmt = (
+        select(models.ExperimentRun)
+        .filter_by(experiment_id=experiment_rowid)
+        .order_by(models.ExperimentRun.id.desc())
+    )
+
+    if cursor:
+        try:
+            cursor_id = GlobalID.from_id(cursor).node_id
+            stmt = stmt.where(models.ExperimentRun.id <= int(cursor_id))
+        except ValueError:
+            raise HTTPException(
+                detail=f"Invalid cursor format: {cursor}",
+                status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+            )
+
+    # Apply limit only if specified for pagination
+    if limit is not None:
+        stmt = stmt.limit(limit + 1)
+
     async with request.app.state.db() as session:
-        experiment_runs = await session.execute(
-            select(models.ExperimentRun)
-            .where(models.ExperimentRun.experiment_id == experiment_rowid)
-            # order by dataset_example_id to be consistent with `list_dataset_examples`
-            .order_by(models.ExperimentRun.dataset_example_id.asc())
-        )
-        experiment_runs = experiment_runs.scalars().all()
-        runs = []
-        for exp_run in experiment_runs:
-            run_gid = GlobalID("ExperimentRun", str(exp_run.id))
-            experiment_gid = GlobalID("Experiment", str(exp_run.experiment_id))
-            example_gid = GlobalID("DatasetExample", str(exp_run.dataset_example_id))
-            runs.append(
-                ExperimentRunResponse(
-                    start_time=exp_run.start_time,
-                    end_time=exp_run.end_time,
-                    experiment_id=str(experiment_gid),
-                    dataset_example_id=str(example_gid),
-                    repetition_number=exp_run.repetition_number,
-                    output=exp_run.output.get("task_output"),
-                    error=exp_run.error,
-                    id=str(run_gid),
-                    trace_id=exp_run.trace_id,
-                )
+        experiment_runs = (await session.scalars(stmt)).all()
+
+    if not experiment_runs:
+        return ListExperimentRunsResponseBody(next_cursor=None, data=[])
+
+    next_cursor = None
+    # Only check for next cursor if limit was specified
+    if limit is not None and len(experiment_runs) == limit + 1:
+        last_run = experiment_runs[-1]
+        next_cursor = str(GlobalID("ExperimentRun", str(last_run.id)))
+        experiment_runs = experiment_runs[:-1]
+
+    runs = []
+    for exp_run in experiment_runs:
+        run_gid = GlobalID("ExperimentRun", str(exp_run.id))
+        experiment_gid = GlobalID("Experiment", str(exp_run.experiment_id))
+        example_gid = GlobalID("DatasetExample", str(exp_run.dataset_example_id))
+        runs.append(
+            ExperimentRunResponse(
+                start_time=exp_run.start_time,
+                end_time=exp_run.end_time,
+                experiment_id=str(experiment_gid),
+                dataset_example_id=str(example_gid),
+                repetition_number=exp_run.repetition_number,
+                output=exp_run.output.get("task_output"),
+                error=exp_run.error,
+                id=str(run_gid),
+                trace_id=exp_run.trace_id,
             )
-    return ListExperimentRunsResponseBody(data=runs)
+        )
+    return ListExperimentRunsResponseBody(data=runs, next_cursor=next_cursor)

phoenix/server/api/routers/v1/spans.py

@@ -5,7 +5,7 @@ from collections.abc import AsyncIterator
 from datetime import datetime, timezone
 from enum import Enum
 from secrets import token_urlsafe
-from typing import Annotated, Any, Literal, Optional, Union
+from typing import Annotated, Any, Optional, Union
 
 import pandas as pd
 import sqlalchemy as sa
@@ -27,8 +27,8 @@ from phoenix.datetime_utils import normalize_datetime
 from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect, get_ancestor_span_rowids
 from phoenix.db.insertion.helpers import as_kv, insert_on_conflict
-from phoenix.db.insertion.types import Precursors
 from phoenix.server.api.routers.utils import df_to_bytes
+from phoenix.server.api.routers.v1.annotations import SpanAnnotationData
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.authorization import is_not_locked
 from phoenix.server.bearer_auth import PhoenixUser
@@ -850,52 +850,6 @@ async def get_spans_handler(
     return await query_spans_handler(request, request_body, project_name)
 
 
-class SpanAnnotationResult(V1RoutesBaseModel):
-    label: Optional[str] = Field(default=None, description="The label assigned by the annotation")
-    score: Optional[float] = Field(default=None, description="The score assigned by the annotation")
-    explanation: Optional[str] = Field(
-        default=None, description="Explanation of the annotation result"
-    )
-
-
-class SpanAnnotationData(V1RoutesBaseModel):
-    span_id: str = Field(description="OpenTelemetry Span ID (hex format w/o 0x prefix)")
-    name: str = Field(description="The name of the annotation")
-    annotator_kind: Literal["LLM", "CODE", "HUMAN"] = Field(
-        description="The kind of annotator used for the annotation"
-    )
-    result: Optional[SpanAnnotationResult] = Field(
-        default=None, description="The result of the annotation"
-    )
-    metadata: Optional[dict[str, Any]] = Field(
-        default=None, description="Metadata for the annotation"
-    )
-    identifier: str = Field(
-        default="",
-        description=(
-            "The identifier of the annotation. "
-            "If provided, the annotation will be updated if it already exists."
-        ),
-    )
-
-    def as_precursor(self, *, user_id: Optional[int] = None) -> Precursors.SpanAnnotation:
-        return Precursors.SpanAnnotation(
-            datetime.now(timezone.utc),
-            self.span_id,
-            models.SpanAnnotation(
-                name=self.name,
-                annotator_kind=self.annotator_kind,
-                score=self.result.score if self.result else None,
-                label=self.result.label if self.result else None,
-                explanation=self.result.explanation if self.result else None,
-                metadata_=self.metadata or {},
-                identifier=self.identifier,
-                source="API",
-                user_id=user_id,
-            ),
-        )
-
-
 class AnnotateSpansRequestBody(RequestBody[list[SpanAnnotationData]]):
     data: list[SpanAnnotationData]
 

phoenix/server/api/routers/v1/traces.py

@@ -1,7 +1,6 @@
 import gzip
 import zlib
-from datetime import datetime, timezone
-from typing import Any, Literal, Optional
+from typing import Optional
 
 from fastapi import APIRouter, BackgroundTasks, Depends, Header, HTTPException, Path, Query
 from google.protobuf.message import DecodeError
@@ -10,7 +9,7 @@ from opentelemetry.proto.collector.trace.v1.trace_service_pb2 import (
     ExportTraceServiceResponse,
 )
 from pydantic import Field
-from sqlalchemy import delete, insert, select
+from sqlalchemy import delete, select
 from starlette.concurrency import run_in_threadpool
 from starlette.datastructures import State
 from starlette.requests import Request
@@ -23,8 +22,9 @@ from starlette.status import (
 from strawberry.relay import GlobalID
 
 from phoenix.db import models
-from phoenix.db.insertion.helpers import as_kv
-from phoenix.db.insertion.types import Precursors
+from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.db.insertion.helpers import as_kv, insert_on_conflict
+from phoenix.server.api.routers.v1.annotations import TraceAnnotationData
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.authorization import is_not_locked
 from phoenix.server.bearer_auth import PhoenixUser
@@ -33,7 +33,11 @@ from phoenix.trace.otel import decode_otlp_span
 from phoenix.utilities.project import get_project_name
 
 from .models import V1RoutesBaseModel
-from .utils import RequestBody, ResponseBody, add_errors_to_responses
+from .utils import (
+    RequestBody,
+    ResponseBody,
+    add_errors_to_responses,
+)
 
 router = APIRouter(tags=["traces"])
 
@@ -105,54 +109,8 @@ async def post_traces(
     )
 
 
-class TraceAnnotationResult(V1RoutesBaseModel):
-    label: Optional[str] = Field(default=None, description="The label assigned by the annotation")
-    score: Optional[float] = Field(default=None, description="The score assigned by the annotation")
-    explanation: Optional[str] = Field(
-        default=None, description="Explanation of the annotation result"
-    )
-
-
-class TraceAnnotation(V1RoutesBaseModel):
-    trace_id: str = Field(description="OpenTelemetry Trace ID (hex format w/o 0x prefix)")
-    name: str = Field(description="The name of the annotation")
-    annotator_kind: Literal["LLM", "HUMAN"] = Field(
-        description="The kind of annotator used for the annotation"
-    )
-    result: Optional[TraceAnnotationResult] = Field(
-        default=None, description="The result of the annotation"
-    )
-    metadata: Optional[dict[str, Any]] = Field(
-        default=None, description="Metadata for the annotation"
-    )
-    identifier: str = Field(
-        default="",
-        description=(
-            "The identifier of the annotation. "
-            "If provided, the annotation will be updated if it already exists."
-        ),
-    )
-
-    def as_precursor(self, *, user_id: Optional[int] = None) -> Precursors.TraceAnnotation:
-        return Precursors.TraceAnnotation(
-            datetime.now(timezone.utc),
-            self.trace_id,
-            models.TraceAnnotation(
-                name=self.name,
-                annotator_kind=self.annotator_kind,
-                score=self.result.score if self.result else None,
-                label=self.result.label if self.result else None,
-                explanation=self.result.explanation if self.result else None,
-                metadata_=self.metadata or {},
-                identifier=self.identifier,
-                source="APP",
-                user_id=user_id,
-            ),
-        )
-
-
-class AnnotateTracesRequestBody(RequestBody[list[TraceAnnotation]]):
-    data: list[TraceAnnotation] = Field(description="The trace annotations to be upserted")
+class AnnotateTracesRequestBody(RequestBody[list[TraceAnnotationData]]):
+    data: list[TraceAnnotationData] = Field(description="The trace annotations to be upserted")
 
 
 class InsertedTraceAnnotation(V1RoutesBaseModel):
@@ -208,10 +166,16 @@ async def annotate_traces(
                 status_code=HTTP_404_NOT_FOUND,
             )
         inserted_ids = []
+        dialect = SupportedSQLDialect(session.bind.dialect.name)
         for p in precursors:
             values = dict(as_kv(p.as_insertable(existing_traces[p.trace_id]).row))
             trace_annotation_id = await session.scalar(
-                insert(models.TraceAnnotation).values(**values).returning(models.TraceAnnotation.id)
+                insert_on_conflict(
+                    values,
+                    dialect=dialect,
+                    table=models.TraceAnnotation,
+                    unique_by=("name", "trace_rowid", "identifier"),
+                ).returning(models.TraceAnnotation.id)
             )
             inserted_ids.append(trace_annotation_id)
     request.state.event_queue.put(TraceAnnotationInsertEvent(tuple(inserted_ids)))

phoenix/server/api/types/Dataset.py

@@ -15,9 +15,11 @@ from phoenix.server.api.context import Context
 from phoenix.server.api.exceptions import BadRequest
 from phoenix.server.api.input_types.DatasetVersionSort import DatasetVersionSort
 from phoenix.server.api.types.DatasetExample import DatasetExample
+from phoenix.server.api.types.DatasetExperimentAnnotationSummary import (
+    DatasetExperimentAnnotationSummary,
+)
 from phoenix.server.api.types.DatasetVersion import DatasetVersion
 from phoenix.server.api.types.Experiment import Experiment, to_gql_experiment
-from phoenix.server.api.types.ExperimentAnnotationSummary import ExperimentAnnotationSummary
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.types.pagination import (
     ConnectionArgs,
@@ -270,53 +272,13 @@ class Dataset(Node):
     @strawberry.field
     async def experiment_annotation_summaries(
         self, info: Info[Context, None]
-    ) -> list[ExperimentAnnotationSummary]:
+    ) -> list[DatasetExperimentAnnotationSummary]:
         dataset_id = self.id_attr
-        repetition_mean_scores_by_example_subquery = (
-            select(
-                models.ExperimentRunAnnotation.name.label("annotation_name"),
-                func.avg(models.ExperimentRunAnnotation.score).label("mean_repetition_score"),
-            )
-            .select_from(models.ExperimentRunAnnotation)
-            .join(
-                models.ExperimentRun,
-                models.ExperimentRunAnnotation.experiment_run_id == models.ExperimentRun.id,
-            )
-            .join(
-                models.Experiment,
-                models.ExperimentRun.experiment_id == models.Experiment.id,
-            )
-            .where(models.Experiment.dataset_id == dataset_id)
-            .group_by(
-                models.ExperimentRun.dataset_example_id,
-                models.ExperimentRunAnnotation.name,
-            )
-            .subquery()
-            .alias("repetition_mean_scores_by_example")
-        )
-        repetition_mean_scores_subquery = (
-            select(
-                repetition_mean_scores_by_example_subquery.c.annotation_name.label(
-                    "annotation_name"
-                ),
-                func.avg(repetition_mean_scores_by_example_subquery.c.mean_repetition_score).label(
-                    "mean_score"
-                ),
-            )
-            .select_from(repetition_mean_scores_by_example_subquery)
-            .group_by(
-                repetition_mean_scores_by_example_subquery.c.annotation_name,
-            )
-            .subquery()
-            .alias("repetition_mean_scores")
-        )
-        repetitions_subquery = (
+        query = (
             select(
                 models.ExperimentRunAnnotation.name.label("annotation_name"),
                 func.min(models.ExperimentRunAnnotation.score).label("min_score"),
                 func.max(models.ExperimentRunAnnotation.score).label("max_score"),
-                func.count().label("count"),
-                func.count(models.ExperimentRunAnnotation.error).label("error_count"),
             )
             .select_from(models.ExperimentRunAnnotation)
             .join(
@@ -329,36 +291,16 @@ class Dataset(Node):
             )
             .where(models.Experiment.dataset_id == dataset_id)
             .group_by(models.ExperimentRunAnnotation.name)
-            .subquery()
-        )
-        run_scores_query = (
-            select(
-                repetition_mean_scores_subquery.c.annotation_name.label("annotation_name"),
-                repetition_mean_scores_subquery.c.mean_score.label("mean_score"),
-                repetitions_subquery.c.min_score.label("min_score"),
-                repetitions_subquery.c.max_score.label("max_score"),
-                repetitions_subquery.c.count.label("count_"),
-                repetitions_subquery.c.error_count.label("error_count"),
-            )
-            .select_from(repetition_mean_scores_subquery)
-            .join(
-                repetitions_subquery,
-                repetitions_subquery.c.annotation_name
-                == repetition_mean_scores_subquery.c.annotation_name,
-            )
-            .order_by(repetition_mean_scores_subquery.c.annotation_name)
+            .order_by(models.ExperimentRunAnnotation.name)
         )
         async with info.context.db() as session:
             return [
-                ExperimentAnnotationSummary(
+                DatasetExperimentAnnotationSummary(
                     annotation_name=scores_tuple.annotation_name,
                     min_score=scores_tuple.min_score,
                     max_score=scores_tuple.max_score,
-                    mean_score=scores_tuple.mean_score,
-                    count=scores_tuple.count_,
-                    error_count=scores_tuple.error_count,
                 )
-                async for scores_tuple in await session.stream(run_scores_query)
+                async for scores_tuple in await session.stream(query)
             ]
 
     @strawberry.field

phoenix/server/api/types/DatasetExperimentAnnotationSummary.py

@@ -0,0 +1,10 @@
+from typing import Optional
+
+import strawberry
+
+
+@strawberry.type
+class DatasetExperimentAnnotationSummary:
+    annotation_name: str
+    min_score: Optional[float]
+    max_score: Optional[float]