arize-phoenix 11.28.0__tar.gz → 11.30.0__tar.gz

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 11.28.0
+Version: 11.30.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -50,7 +50,8 @@ Requires-Dist: python-multipart
 Requires-Dist: scikit-learn
 Requires-Dist: scipy
 Requires-Dist: sqlalchemy[asyncio]<3,>=2.0.4
-Requires-Dist: sqlean-py>=3.45.1
+Requires-Dist: sqlean-py<3.50,>=3.45.1; platform_system == 'Windows'
+Requires-Dist: sqlean-py>=3.45.1; platform_system != 'Windows'
 Requires-Dist: starlette
 Requires-Dist: strawberry-graphql==0.270.1
 Requires-Dist: tqdm

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/pyproject.toml

@@ -49,7 +49,8 @@ dependencies = [
   "alembic>=1.3.0, <2",
   "aiosqlite",
   "aioitertools",
-  "sqlean.py>=3.45.1",
+  "sqlean.py>=3.45.1; platform_system != 'Windows'",
+  "sqlean.py>=3.45.1,<3.50; platform_system == 'Windows'",  # https://github.com/nalgeon/sqlean.py/commit/2714a4789998811b7dd9f102f5b45ea071ed879e
   "cachetools",
   "python-multipart",  # see https://www.starlette.io/#dependencies
   "arize-phoenix-evals>=0.20.6",

arize_phoenix-11.30.0/src/phoenix/server/api/dataloaders/average_experiment_run_latency.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+from sqlalchemy import func, select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.types import DbSessionFactory
+
+ExperimentID: TypeAlias = int
+RunLatency: TypeAlias = Optional[float]
+Key: TypeAlias = ExperimentID
+Result: TypeAlias = RunLatency
+
+
+class AverageExperimentRunLatencyDataLoader(DataLoader[Key, Result]):
+    def __init__(
+        self,
+        db: DbSessionFactory,
+    ) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        experiment_ids = keys
+        average_repetition_latency_ms = (
+            select(
+                models.ExperimentRun.experiment_id.label("experiment_id"),
+                func.avg(models.ExperimentRun.latency_ms).label("average_repetition_latency_ms"),
+            )
+            .select_from(models.ExperimentRun)
+            .where(models.ExperimentRun.experiment_id.in_(experiment_ids))
+            .group_by(models.ExperimentRun.dataset_example_id, models.ExperimentRun.experiment_id)
+            .subquery()
+        )
+        query = select(
+            average_repetition_latency_ms.c.experiment_id,
+            func.avg(average_repetition_latency_ms.c.average_repetition_latency_ms).label(
+                "average_run_latency_ms"
+            ),
+        ).group_by(average_repetition_latency_ms.c.experiment_id)
+        async with self._db() as session:
+            average_run_latencies_ms = {
+                experiment_id: average_run_latency_ms
+                async for experiment_id, average_run_latency_ms in await session.stream(query)
+            }
+        return [average_run_latencies_ms.get(experiment_id) for experiment_id in keys]

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/src/phoenix/server/api/dataloaders/document_evaluations.py

@@ -5,11 +5,11 @@ from strawberry.dataloader import DataLoader
 from typing_extensions import TypeAlias
 
 from phoenix.db import models
-from phoenix.server.api.types.Evaluation import DocumentEvaluation
+from phoenix.server.api.types.Evaluation import DocumentAnnotation
 from phoenix.server.types import DbSessionFactory
 
 Key: TypeAlias = int
-Result: TypeAlias = list[DocumentEvaluation]
+Result: TypeAlias = list[DocumentAnnotation]
 
 
 class DocumentEvaluationsDataLoader(DataLoader[Key, Result]):
@@ -26,6 +26,6 @@ class DocumentEvaluationsDataLoader(DataLoader[Key, Result]):
             )
             async for document_evaluation in data:
                 document_evaluations_by_id[document_evaluation.span_rowid].append(
-                    DocumentEvaluation.from_sql_document_annotation(document_evaluation)
+                    DocumentAnnotation.from_sql_document_annotation(document_evaluation)
                 )
         return [document_evaluations_by_id[key] for key in keys]

arize_phoenix-11.30.0/src/phoenix/server/api/dataloaders/experiment_annotation_summaries.py

@@ -0,0 +1,133 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Optional
+
+from sqlalchemy import and_, func, select
+from strawberry.dataloader import AbstractCache, DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.types import DbSessionFactory
+
+
+@dataclass
+class ExperimentAnnotationSummary:
+    annotation_name: str
+    min_score: float
+    max_score: float
+    mean_score: float
+    count: int
+    error_count: int
+
+
+ExperimentID: TypeAlias = int
+Key: TypeAlias = ExperimentID
+Result: TypeAlias = list[ExperimentAnnotationSummary]
+
+
+class ExperimentAnnotationSummaryDataLoader(DataLoader[Key, Result]):
+    def __init__(
+        self,
+        db: DbSessionFactory,
+        cache_map: Optional[AbstractCache[Key, Result]] = None,
+    ) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        experiment_ids = keys
+        summaries: defaultdict[ExperimentID, Result] = defaultdict(list)
+        repetition_mean_scores_by_example_subquery = (
+            select(
+                models.ExperimentRun.experiment_id.label("experiment_id"),
+                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,
+            )
+            .where(models.ExperimentRun.experiment_id.in_(experiment_ids))
+            .group_by(
+                models.ExperimentRun.experiment_id,
+                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.experiment_id.label("experiment_id"),
+                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.experiment_id,
+                repetition_mean_scores_by_example_subquery.c.annotation_name,
+            )
+            .subquery()
+            .alias("repetition_mean_scores")
+        )
+        repetitions_subquery = (
+            select(
+                models.ExperimentRun.experiment_id.label("experiment_id"),
+                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(
+                models.ExperimentRun,
+                models.ExperimentRunAnnotation.experiment_run_id == models.ExperimentRun.id,
+            )
+            .where(models.ExperimentRun.experiment_id.in_(experiment_ids))
+            .group_by(models.ExperimentRun.experiment_id, models.ExperimentRunAnnotation.name)
+            .subquery()
+        )
+        run_scores_query = (
+            select(
+                repetition_mean_scores_subquery.c.experiment_id.label("experiment_id"),
+                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,
+                and_(
+                    repetitions_subquery.c.experiment_id
+                    == repetition_mean_scores_subquery.c.experiment_id,
+                    repetitions_subquery.c.annotation_name
+                    == repetition_mean_scores_subquery.c.annotation_name,
+                ),
+            )
+            .order_by(repetition_mean_scores_subquery.c.annotation_name)
+        )
+        async with self._db() as session:
+            async for scores_tuple in await session.stream(run_scores_query):
+                summaries[scores_tuple.experiment_id].append(
+                    ExperimentAnnotationSummary(
+                        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,
+                    )
+                )
+        return [
+            sorted(summaries[experiment_id], key=lambda summary: summary.annotation_name)
+            for experiment_id in experiment_ids
+        ]

arize_phoenix-11.30.0/src/phoenix/server/api/dataloaders/experiment_error_rates.py

@@ -0,0 +1,51 @@
+from typing import Optional
+
+from sqlalchemy import func, select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.types import DbSessionFactory
+
+ExperimentID: TypeAlias = int
+ErrorRate: TypeAlias = float
+Key: TypeAlias = ExperimentID
+Result: TypeAlias = Optional[ErrorRate]
+
+
+class ExperimentErrorRatesDataLoader(DataLoader[Key, Result]):
+    def __init__(
+        self,
+        db: DbSessionFactory,
+    ) -> None:
+        super().__init__(load_fn=self._load_fn)
+        self._db = db
+
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        experiment_ids = keys
+        average_repetition_error_rates_subquery = (
+            select(
+                models.ExperimentRun.experiment_id.label("experiment_id"),
+                (
+                    func.count(models.ExperimentRun.error) / func.count(models.ExperimentRun.id)
+                ).label("average_repetition_error_rate"),
+            )
+            .where(models.ExperimentRun.experiment_id.in_(experiment_ids))
+            .group_by(models.ExperimentRun.dataset_example_id, models.ExperimentRun.experiment_id)
+            .subquery()
+            .alias("average_repetition_error_rates")
+        )
+        average_run_error_rates_query = select(
+            average_repetition_error_rates_subquery.c.experiment_id,
+            func.avg(average_repetition_error_rates_subquery.c.average_repetition_error_rate).label(
+                "average_run_error_rates"
+            ),
+        ).group_by(average_repetition_error_rates_subquery.c.experiment_id)
+        async with self._db() as session:
+            average_run_error_rates = {
+                experiment_id: error_rate
+                async for experiment_id, error_rate in await session.stream(
+                    average_run_error_rates_query
+                )
+            }
+        return [average_run_error_rates.get(experiment_id) for experiment_id in experiment_ids]

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/src/phoenix/server/api/routers/v1/__init__.py

@@ -7,6 +7,7 @@ from phoenix.server.bearer_auth import is_authenticated
 from .annotation_configs import router as annotation_configs_router
 from .annotations import router as annotations_router
 from .datasets import router as datasets_router
+from .documents import router as documents_router
 from .evaluations import router as evaluations_router
 from .experiment_evaluations import router as experiment_evaluations_router
 from .experiment_runs import router as experiment_runs_router
@@ -70,5 +71,6 @@ def create_v1_router(authentication_enabled: bool) -> APIRouter:
     router.include_router(evaluations_router)
     router.include_router(prompts_router)
     router.include_router(projects_router)
+    router.include_router(documents_router)
     router.include_router(users_router)
     return router

arize_phoenix-11.30.0/src/phoenix/server/api/routers/v1/documents.py

@@ -0,0 +1,175 @@
+from datetime import datetime, timezone
+from typing import Any, Literal, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import Field
+from sqlalchemy import select
+from starlette.requests import Request
+from starlette.status import HTTP_404_NOT_FOUND
+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.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
+
+
+class InsertedSpanDocumentAnnotation(V1RoutesBaseModel):
+    id: str = Field(description="The ID of the inserted span document annotation")
+
+
+class AnnotateSpanDocumentsResponseBody(ResponseBody[list[InsertedSpanDocumentAnnotation]]):
+    pass
+
+
+@router.post(
+    "/document_annotations",
+    dependencies=[Depends(is_not_locked)],
+    operation_id="annotateSpanDocuments",
+    responses=add_errors_to_responses(
+        [
+            {
+                "status_code": HTTP_404_NOT_FOUND,
+                "description": "Span not found",
+            }
+        ]
+    ),
+    response_description="Span document annotation inserted successfully",
+    include_in_schema=True,
+)
+async def annotate_span_documents(
+    request: Request,
+    request_body: AnnotateSpanDocumentsRequestBody,
+    sync: bool = Query(
+        default=False, description="If set to true, the annotations are inserted synchronously."
+    ),
+) -> AnnotateSpanDocumentsResponseBody:
+    if not request_body.data:
+        return AnnotateSpanDocumentsResponseBody(data=[])
+
+    user_id: Optional[int] = None
+    if request.app.state.authentication_enabled and isinstance(request.user, PhoenixUser):
+        user_id = int(request.user.identity)
+
+    span_document_annotations = request_body.data
+
+    precursors = [
+        annotation.as_precursor(user_id=user_id) for annotation in span_document_annotations
+    ]
+    if not sync:
+        await request.state.enqueue(*precursors)
+
+    span_ids = {p.span_id for p in precursors}
+    # Account for the fact that the spans could arrive after the annotation
+    async with request.app.state.db() as session:
+        existing_spans = {
+            span_id: (id_, num_docs)
+            async for span_id, id_, num_docs in await session.stream(
+                select(models.Span.span_id, models.Span.id, models.Span.num_documents).filter(
+                    models.Span.span_id.in_(span_ids)
+                )
+            )
+        }
+
+    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):
+            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"),
+            ).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(
+        DocumentAnnotationInsertEvent(tuple(inserted_document_annotation_ids))
+    )
+    return AnnotateSpanDocumentsResponseBody(
+        data=[
+            InsertedSpanDocumentAnnotation(id=str(GlobalID(DocumentAnnotation.__name__, str(id_))))
+            for id_ in inserted_document_annotation_ids
+        ]
+    )

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/src/phoenix/server/api/routers/v1/spans.py

@@ -949,9 +949,11 @@ async def annotate_spans(
     span_ids = {p.span_id for p in precursors}
     async with request.app.state.db() as session:
         existing_spans = {
-            span.span_id: span.id
-            async for span in await session.stream_scalars(
-                select(models.Span).filter(models.Span.span_id.in_(span_ids))
+            span_id: id_
+            async for span_id, id_ in await session.stream(
+                select(models.Span.span_id, models.Span.id).filter(
+                    models.Span.span_id.in_(span_ids)
+                )
             )
         }
 

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/src/phoenix/server/api/routers/v1/traces.py

@@ -193,9 +193,11 @@ async def annotate_traces(
     trace_ids = {p.trace_id for p in precursors}
     async with request.app.state.db() as session:
         existing_traces = {
-            trace.trace_id: trace.id
-            async for trace in await session.stream_scalars(
-                select(models.Trace).filter(models.Trace.trace_id.in_(trace_ids))
+            trace_id: id_
+            async for trace_id, id_ in await session.stream(
+                select(models.Trace.trace_id, models.Trace.id).filter(
+                    models.Trace.trace_id.in_(trace_ids)
+                )
             )
         }
 

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/src/phoenix/server/api/types/Dataset.py

@@ -272,15 +272,53 @@ class Dataset(Node):
         self, info: Info[Context, None]
     ) -> list[ExperimentAnnotationSummary]:
         dataset_id = self.id_attr
-        query = (
+        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,
-                func.min(models.ExperimentRunAnnotation.score),
-                func.max(models.ExperimentRunAnnotation.score),
-                func.avg(models.ExperimentRunAnnotation.score),
-                func.count(),
-                func.count(models.ExperimentRunAnnotation.error),
             )
+            .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 = (
+            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(
                 models.ExperimentRun,
                 models.ExperimentRunAnnotation.experiment_run_id == models.ExperimentRun.id,
@@ -291,26 +329,36 @@ class Dataset(Node):
             )
             .where(models.Experiment.dataset_id == dataset_id)
             .group_by(models.ExperimentRunAnnotation.name)
-            .order_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)
         )
         async with info.context.db() as session:
             return [
                 ExperimentAnnotationSummary(
-                    annotation_name=annotation_name,
-                    min_score=min_score,
-                    max_score=max_score,
-                    mean_score=mean_score,
-                    count=count_,
-                    error_count=error_count,
+                    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 (
-                    annotation_name,
-                    min_score,
-                    max_score,
-                    mean_score,
-                    count_,
-                    error_count,
-                ) in await session.stream(query)
+                async for scores_tuple in await session.stream(run_scores_query)
             ]
 
     @strawberry.field

{arize_phoenix-11.28.0 → arize_phoenix-11.30.0}/src/phoenix/server/api/types/Evaluation.py

@@ -1,6 +1,7 @@
 import strawberry
 
-from phoenix.db.models import DocumentAnnotation, TraceAnnotation
+from phoenix.db.models import DocumentAnnotation as DBDocumentAnnotation
+from phoenix.db.models import TraceAnnotation
 
 from .Annotation import Annotation
 
@@ -20,15 +21,15 @@ class TraceEvaluation(Annotation):
 
 
 @strawberry.type
-class DocumentEvaluation(Annotation):
+class DocumentAnnotation(Annotation):
     document_position: int = strawberry.field(
         description="The zero-based index among retrieved documents, which "
         "is collected as a list (even when ordering is not inherently meaningful)."
     )
 
     @staticmethod
-    def from_sql_document_annotation(annotation: DocumentAnnotation) -> "DocumentEvaluation":
-        return DocumentEvaluation(
+    def from_sql_document_annotation(annotation: DBDocumentAnnotation) -> "DocumentAnnotation":
+        return DocumentAnnotation(
             name=annotation.name,
             score=annotation.score,
             label=annotation.label,