arize-phoenix 11.27.0__tar.gz → 11.29.0__tar.gz

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 11.27.0
+Version: 11.29.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.27.0 → arize_phoenix-11.29.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.27.0 → arize_phoenix-11.29.0}/src/phoenix/db/insertion/document_annotation.py

@@ -63,7 +63,7 @@ class DocumentAnnotationQueueInserter(
         session: AsyncSession,
         *insertions: Insertables.DocumentAnnotation,
     ) -> list[DocumentAnnotationDmlEvent]:
-        records = [dict(as_kv(ins.row)) for ins in insertions]
+        records = [{**dict(as_kv(ins.row)), "updated_at": ins.row.updated_at} for ins in insertions]
         stmt = self._insert_on_conflict(*records).returning(self.table.id)
         ids = tuple([_ async for _ in await session.stream_scalars(stmt)])
         return [DocumentAnnotationDmlEvent(ids)]
@@ -99,7 +99,7 @@ class DocumentAnnotationQueueInserter(
 
         for p in parcels:
             if (anno := existing_annos.get(_key(p))) is not None:
-                if p.received_at <= anno.updated_at:
+                if p.item.updated_at <= anno.updated_at:
                     to_discard.append(p)
                 else:
                     to_insert.append(

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/src/phoenix/db/insertion/span_annotation.py

@@ -57,7 +57,7 @@ class SpanAnnotationQueueInserter(
         session: AsyncSession,
         *insertions: Insertables.SpanAnnotation,
     ) -> list[SpanAnnotationDmlEvent]:
-        records = [dict(as_kv(ins.row)) for ins in insertions]
+        records = [{**dict(as_kv(ins.row)), "updated_at": ins.row.updated_at} for ins in insertions]
         stmt = self._insert_on_conflict(*records).returning(self.table.id)
         ids = tuple([_ async for _ in await session.stream_scalars(stmt)])
         return [SpanAnnotationDmlEvent(ids)]
@@ -92,7 +92,7 @@ class SpanAnnotationQueueInserter(
 
         for p in parcels:
             if (anno := existing_annos.get(_key(p))) is not None:
-                if p.received_at <= anno.updated_at:
+                if p.item.updated_at <= anno.updated_at:
                     to_discard.append(p)
                 else:
                     to_insert.append(

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/src/phoenix/db/insertion/trace_annotation.py

@@ -56,7 +56,7 @@ class TraceAnnotationQueueInserter(
         session: AsyncSession,
         *insertions: Insertables.TraceAnnotation,
     ) -> list[TraceAnnotationDmlEvent]:
-        records = [dict(as_kv(ins.row)) for ins in insertions]
+        records = [{**dict(as_kv(ins.row)), "updated_at": ins.row.updated_at} for ins in insertions]
         stmt = self._insert_on_conflict(*records).returning(self.table.id)
         ids = tuple([_ async for _ in await session.stream_scalars(stmt)])
         return [TraceAnnotationDmlEvent(ids)]
@@ -91,7 +91,7 @@ class TraceAnnotationQueueInserter(
 
         for p in parcels:
             if (anno := existing_annos.get(_key(p))) is not None:
-                if p.received_at <= anno.updated_at:
+                if p.item.updated_at <= anno.updated_at:
                     to_discard.append(p)
                 else:
                     to_insert.append(

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/src/phoenix/db/insertion/types.py

@@ -174,6 +174,7 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
 class Precursors(ABC):
     @dataclass(frozen=True)
     class SpanAnnotation:
+        updated_at: datetime
         span_id: str
         obj: models.SpanAnnotation
 
@@ -182,6 +183,7 @@ class Precursors(ABC):
             span_rowid: int,
         ) -> Insertables.SpanAnnotation:
             return Insertables.SpanAnnotation(
+                updated_at=self.updated_at,
                 span_id=self.span_id,
                 obj=self.obj,
                 span_rowid=span_rowid,
@@ -189,6 +191,7 @@ class Precursors(ABC):
 
     @dataclass(frozen=True)
     class TraceAnnotation:
+        updated_at: datetime
         trace_id: str
         obj: models.TraceAnnotation
 
@@ -197,6 +200,7 @@ class Precursors(ABC):
             trace_rowid: int,
         ) -> Insertables.TraceAnnotation:
             return Insertables.TraceAnnotation(
+                updated_at=self.updated_at,
                 trace_id=self.trace_id,
                 obj=self.obj,
                 trace_rowid=trace_rowid,
@@ -204,6 +208,7 @@ class Precursors(ABC):
 
     @dataclass(frozen=True)
     class DocumentAnnotation:
+        updated_at: datetime
         span_id: str
         document_position: int
         obj: models.DocumentAnnotation
@@ -213,6 +218,7 @@ class Precursors(ABC):
             span_rowid: int,
         ) -> Insertables.DocumentAnnotation:
             return Insertables.DocumentAnnotation(
+                updated_at=self.updated_at,
                 span_id=self.span_id,
                 document_position=self.document_position,
                 obj=self.obj,
@@ -223,6 +229,7 @@ class Precursors(ABC):
 class Insertables(ABC):
     @dataclass(frozen=True)
     class SpanAnnotation(Precursors.SpanAnnotation):
+        updated_at: datetime
         span_rowid: int
         identifier: str = ""
 
@@ -230,10 +237,12 @@ class Insertables(ABC):
         def row(self) -> models.SpanAnnotation:
             obj = copy(self.obj)
             obj.span_rowid = self.span_rowid
+            obj.updated_at = self.updated_at
             return obj
 
     @dataclass(frozen=True)
     class TraceAnnotation(Precursors.TraceAnnotation):
+        updated_at: datetime
         trace_rowid: int
         identifier: str = ""
 
@@ -241,10 +250,12 @@ class Insertables(ABC):
         def row(self) -> models.TraceAnnotation:
             obj = copy(self.obj)
             obj.trace_rowid = self.trace_rowid
+            obj.updated_at = self.updated_at
             return obj
 
     @dataclass(frozen=True)
     class DocumentAnnotation(Precursors.DocumentAnnotation):
+        updated_at: datetime
         span_rowid: int
         identifier: str = ""
 
@@ -252,4 +263,5 @@ class Insertables(ABC):
         def row(self) -> models.DocumentAnnotation:
             obj = copy(self.obj)
             obj.span_rowid = self.span_rowid
+            obj.updated_at = self.updated_at
             return obj

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/src/phoenix/server/api/dataloaders/average_experiment_run_latency.py

@@ -23,32 +23,28 @@ class AverageExperimentRunLatencyDataLoader(DataLoader[Key, Result]):
 
     async def _load_fn(self, keys: list[Key]) -> list[Result]:
         experiment_ids = keys
-        resolved_experiment_ids = (
-            select(models.Experiment.id)
-            .where(models.Experiment.id.in_(set(experiment_ids)))
-            .subquery()
-        )
-        query = (
+        average_repetition_latency_ms = (
             select(
-                resolved_experiment_ids.c.id,
+                models.ExperimentRun.experiment_id.label("experiment_id"),
                 func.avg(
                     func.extract("epoch", models.ExperimentRun.end_time)
                     - func.extract("epoch", models.ExperimentRun.start_time)
-                ),
+                ).label("average_repetition_latency_ms"),
             )
-            .outerjoin_from(
-                from_=resolved_experiment_ids,
-                target=models.ExperimentRun,
-                onclause=resolved_experiment_ids.c.id == models.ExperimentRun.experiment_id,
-            )
-            .group_by(resolved_experiment_ids.c.id)
+            .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:
-            avg_latencies = {
-                experiment_id: avg_latency
-                async for experiment_id, avg_latency in await session.stream(query)
+            average_run_latencies_ms = {
+                experiment_id: average_run_latency_ms
+                async for experiment_id, average_run_latency_ms in await session.stream(query)
             }
-        return [
-            avg_latencies.get(experiment_id, ValueError(f"Unknown experiment: {experiment_id}"))
-            for experiment_id in keys
-        ]
+        return [average_run_latencies_ms.get(experiment_id) for experiment_id in keys]

arize_phoenix-11.29.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.dataset_example_id,
+                models.ExperimentRun.experiment_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.29.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.27.0 → arize_phoenix-11.29.0}/src/phoenix/server/api/routers/v1/evaluations.py

@@ -1,5 +1,6 @@
 import gzip
 from collections.abc import Callable
+from datetime import datetime, timezone
 from itertools import chain
 from typing import Any, Iterator, Optional, Union, cast
 
@@ -269,6 +270,7 @@ def _document_annotation_factory(
     Callable[..., Precursors.DocumentAnnotation],
 ]:
     return lambda index: lambda **kwargs: Precursors.DocumentAnnotation(
+        datetime.now(timezone.utc),
         span_id=str(index[span_id_idx]),
         document_position=int(index[document_position_idx]),
         obj=models.DocumentAnnotation(
@@ -280,6 +282,7 @@ def _document_annotation_factory(
 
 def _span_annotation_factory(span_id: str) -> Callable[..., Precursors.SpanAnnotation]:
     return lambda **kwargs: Precursors.SpanAnnotation(
+        datetime.now(timezone.utc),
         span_id=str(span_id),
         obj=models.SpanAnnotation(**kwargs),
     )
@@ -287,6 +290,7 @@ def _span_annotation_factory(span_id: str) -> Callable[..., Precursors.SpanAnnot
 
 def _trace_annotation_factory(trace_id: str) -> Callable[..., Precursors.TraceAnnotation]:
     return lambda **kwargs: Precursors.TraceAnnotation(
+        datetime.now(timezone.utc),
         trace_id=str(trace_id),
         obj=models.TraceAnnotation(**kwargs),
     )

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/src/phoenix/server/api/routers/v1/spans.py

@@ -880,6 +880,7 @@ class SpanAnnotationData(V1RoutesBaseModel):
 
     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,

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/src/phoenix/server/api/routers/v1/traces.py

@@ -1,5 +1,6 @@
 import gzip
 import zlib
+from datetime import datetime, timezone
 from typing import Any, Literal, Optional
 
 from fastapi import APIRouter, BackgroundTasks, Depends, Header, HTTPException, Path, Query
@@ -134,6 +135,7 @@ class TraceAnnotation(V1RoutesBaseModel):
 
     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,

{arize_phoenix-11.27.0 → arize_phoenix-11.29.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.27.0 → arize_phoenix-11.29.0}/src/phoenix/server/api/types/Experiment.py

@@ -4,7 +4,6 @@ from typing import ClassVar, Optional
 import strawberry
 from sqlalchemy import func, select
 from sqlalchemy.orm import joinedload
-from sqlalchemy.sql.functions import coalesce
 from strawberry import UNSET, Private
 from strawberry.relay import Connection, Node, NodeID
 from strawberry.scalars import JSON
@@ -165,8 +164,8 @@ class Experiment(Node):
             select(
                 models.SpanCostDetail.token_type,
                 models.SpanCostDetail.is_prompt,
-                coalesce(func.sum(models.SpanCostDetail.cost), 0).label("cost"),
-                coalesce(func.sum(models.SpanCostDetail.tokens), 0).label("tokens"),
+                func.sum(models.SpanCostDetail.cost).label("cost"),
+                func.sum(models.SpanCostDetail.tokens).label("tokens"),
             )
             .select_from(models.SpanCostDetail)
             .join(models.SpanCost, models.SpanCostDetail.span_cost_id == models.SpanCost.id)

{arize_phoenix-11.27.0 → arize_phoenix-11.29.0}/src/phoenix/server/static/.vite/manifest.json

@@ -1,22 +1,22 @@
 {
-  "_components-BC-SDWO9.js": {
-    "file": "assets/components-BC-SDWO9.js",
+  "_components-dCdVienD.js": {
+    "file": "assets/components-dCdVienD.js",
     "name": "components",
     "imports": [
       "_vendor-RdRDaQiR.js",
-      "_pages-D19Jzk-2.js",
+      "_pages-CA4bKhm9.js",
       "_vendor-arizeai-DsYDNOqt.js",
       "_vendor-codemirror-BzJDUbEx.js",
       "_vendor-three-BLWp5bic.js"
     ]
   },
-  "_pages-D19Jzk-2.js": {
-    "file": "assets/pages-D19Jzk-2.js",
+  "_pages-CA4bKhm9.js": {
+    "file": "assets/pages-CA4bKhm9.js",
     "name": "pages",
     "imports": [
       "_vendor-RdRDaQiR.js",
       "_vendor-arizeai-DsYDNOqt.js",
-      "_components-BC-SDWO9.js",
+      "_components-dCdVienD.js",
       "_vendor-codemirror-BzJDUbEx.js",
       "_vendor-recharts-BTHn5Y2R.js"
     ]
@@ -75,15 +75,15 @@
     "name": "vendor-three"
   },
   "index.tsx": {
-    "file": "assets/index-CjTh13rR.js",
+    "file": "assets/index-Bp44T8N2.js",
     "name": "index",
     "src": "index.tsx",
     "isEntry": true,
     "imports": [
       "_vendor-RdRDaQiR.js",
       "_vendor-arizeai-DsYDNOqt.js",
-      "_pages-D19Jzk-2.js",
-      "_components-BC-SDWO9.js",
+      "_pages-CA4bKhm9.js",
+      "_components-dCdVienD.js",
       "_vendor-three-BLWp5bic.js",
       "_vendor-codemirror-BzJDUbEx.js",
       "_vendor-shiki-BAcocHFl.js",