arize-phoenix 4.30.1__tar.gz → 4.30.2__tar.gz

{arize_phoenix-4.30.1 → arize_phoenix-4.30.2}/PKG-INFO

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

{arize_phoenix-4.30.1 → arize_phoenix-4.30.2}/src/phoenix/server/api/context.py

@@ -17,6 +17,7 @@ from phoenix.server.api.dataloaders import (
     DocumentRetrievalMetricsDataLoader,
     ExperimentAnnotationSummaryDataLoader,
     ExperimentErrorRatesDataLoader,
+    ExperimentRunAnnotations,
     ExperimentRunCountsDataLoader,
     ExperimentSequenceNumberDataLoader,
     LatencyMsQuantileDataLoader,
@@ -45,6 +46,7 @@ class DataLoaders:
     annotation_summaries: AnnotationSummaryDataLoader
     experiment_annotation_summaries: ExperimentAnnotationSummaryDataLoader
     experiment_error_rates: ExperimentErrorRatesDataLoader
+    experiment_run_annotations: ExperimentRunAnnotations
     experiment_run_counts: ExperimentRunCountsDataLoader
     experiment_sequence_number: ExperimentSequenceNumberDataLoader
     latency_ms_quantile: LatencyMsQuantileDataLoader

{arize_phoenix-4.30.1 → arize_phoenix-4.30.2}/src/phoenix/server/api/dataloaders/__init__.py

@@ -12,6 +12,7 @@ from .document_evaluations import DocumentEvaluationsDataLoader
 from .document_retrieval_metrics import DocumentRetrievalMetricsDataLoader
 from .experiment_annotation_summaries import ExperimentAnnotationSummaryDataLoader
 from .experiment_error_rates import ExperimentErrorRatesDataLoader
+from .experiment_run_annotations import ExperimentRunAnnotations
 from .experiment_run_counts import ExperimentRunCountsDataLoader
 from .experiment_sequence_number import ExperimentSequenceNumberDataLoader
 from .latency_ms_quantile import LatencyMsQuantileCache, LatencyMsQuantileDataLoader
@@ -36,6 +37,7 @@ __all__ = [
     "AnnotationSummaryDataLoader",
     "ExperimentAnnotationSummaryDataLoader",
     "ExperimentErrorRatesDataLoader",
+    "ExperimentRunAnnotations",
     "ExperimentRunCountsDataLoader",
     "ExperimentSequenceNumberDataLoader",
     "LatencyMsQuantileDataLoader",

{arize_phoenix-4.30.1 → arize_phoenix-4.30.2}/src/phoenix/server/api/dataloaders/dataset_example_revisions.py

@@ -5,7 +5,8 @@ from typing import (
     Union,
 )
 
-from sqlalchemy import Integer, case, func, literal, or_, select, union
+from sqlalchemy import and_, case, func, null, or_, select
+from sqlalchemy.sql.expression import literal
 from strawberry.dataloader import DataLoader
 from typing_extensions import TypeAlias
 
@@ -22,40 +23,76 @@ Result: TypeAlias = DatasetExampleRevision
 
 class DatasetExampleRevisionsDataLoader(DataLoader[Key, Result]):
     def __init__(self, db: DbSessionFactory) -> None:
-        super().__init__(load_fn=self._load_fn)
+        super().__init__(
+            load_fn=self._load_fn,
+            max_batch_size=200,  # needed to prevent the size of the query from getting too large
+        )
         self._db = db
 
     async def _load_fn(self, keys: List[Key]) -> List[Union[Result, NotFound]]:
-        # sqlalchemy has limited SQLite support for VALUES, so use UNION ALL instead.
-        # For details, see https://github.com/sqlalchemy/sqlalchemy/issues/7228
-        keys_subquery = union(
-            *(
+        example_and_version_ids = tuple(
+            set(
+                (example_id, version_id)
+                for example_id, version_id in keys
+                if version_id is not None
+            )
+        )
+        versionless_example_ids = tuple(
+            set(example_id for example_id, version_id in keys if version_id is None)
+        )
+        resolved_example_and_version_ids = (
+            (
                 select(
-                    literal(example_id, Integer).label("example_id"),
-                    literal(version_id, Integer).label("version_id"),
+                    models.DatasetExample.id.label("example_id"),
+                    models.DatasetVersion.id.label("version_id"),
+                )
+                .select_from(models.DatasetExample)
+                .join(
+                    models.DatasetVersion,
+                    onclause=literal(True),  # cross join
+                )
+                .where(
+                    or_(
+                        *(
+                            and_(
+                                models.DatasetExample.id == example_id,
+                                models.DatasetVersion.id == version_id,
+                            )
+                            for example_id, version_id in example_and_version_ids
+                        )
+                    )
                 )
-                for example_id, version_id in keys
             )
-        ).subquery()
+            .union(
+                select(
+                    models.DatasetExample.id.label("example_id"), null().label("version_id")
+                ).where(models.DatasetExample.id.in_(versionless_example_ids))
+            )
+            .subquery()
+        )
         revision_ids = (
             select(
-                keys_subquery.c.example_id,
-                keys_subquery.c.version_id,
+                resolved_example_and_version_ids.c.example_id,
+                resolved_example_and_version_ids.c.version_id,
                 func.max(models.DatasetExampleRevision.id).label("revision_id"),
             )
-            .select_from(keys_subquery)
+            .select_from(resolved_example_and_version_ids)
             .join(
                 models.DatasetExampleRevision,
-                onclause=keys_subquery.c.example_id
+                onclause=resolved_example_and_version_ids.c.example_id
                 == models.DatasetExampleRevision.dataset_example_id,
             )
             .where(
                 or_(
-                    keys_subquery.c.version_id.is_(None),
-                    models.DatasetExampleRevision.dataset_version_id <= keys_subquery.c.version_id,
+                    resolved_example_and_version_ids.c.version_id.is_(None),
+                    models.DatasetExampleRevision.dataset_version_id
+                    <= resolved_example_and_version_ids.c.version_id,
                 )
             )
-            .group_by(keys_subquery.c.example_id, keys_subquery.c.version_id)
+            .group_by(
+                resolved_example_and_version_ids.c.example_id,
+                resolved_example_and_version_ids.c.version_id,
+            )
         ).subquery()
         query = (
             select(

arize_phoenix-4.30.2/src/phoenix/server/api/dataloaders/experiment_run_annotations.py

@@ -0,0 +1,40 @@
+from collections import defaultdict
+from typing import (
+    DefaultDict,
+    List,
+)
+
+from sqlalchemy import select
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db.models import ExperimentRunAnnotation as OrmExperimentRunAnnotation
+from phoenix.server.types import DbSessionFactory
+
+ExperimentRunID: TypeAlias = int
+Key: TypeAlias = ExperimentRunID
+Result: TypeAlias = List[OrmExperimentRunAnnotation]
+
+
+class ExperimentRunAnnotations(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]:
+        run_ids = tuple(set(keys))
+        annotations: DefaultDict[Key, Result] = defaultdict(list)
+        async with self._db() as session:
+            async for run_id, annotation in await session.stream(
+                select(
+                    OrmExperimentRunAnnotation.experiment_run_id, OrmExperimentRunAnnotation
+                ).where(OrmExperimentRunAnnotation.experiment_run_id.in_(run_ids))
+            ):
+                annotations[run_id].append(annotation)
+        return [
+            sorted(annotations[run_id], key=lambda annotation: annotation.name, reverse=True)
+            for run_id in run_ids
+        ]

{arize_phoenix-4.30.1 → arize_phoenix-4.30.2}/src/phoenix/server/api/types/ExperimentRun.py

@@ -2,7 +2,6 @@ from datetime import datetime
 from typing import Optional
 
 import strawberry
-from sqlalchemy import select
 from strawberry import UNSET
 from strawberry.relay import Connection, GlobalID, Node, NodeID
 from strawberry.scalars import JSON
@@ -48,14 +47,7 @@ class ExperimentRun(Node):
             before=before if isinstance(before, CursorString) else None,
         )
         run_id = self.id_attr
-        async with info.context.db() as session:
-            annotations = (
-                await session.scalars(
-                    select(models.ExperimentRunAnnotation)
-                    .where(models.ExperimentRunAnnotation.experiment_run_id == run_id)
-                    .order_by(models.ExperimentRunAnnotation.name.desc())
-                )
-            ).all()
+        annotations = await info.context.data_loaders.experiment_run_annotations.load(run_id)
         return connection_from_list(
             [to_gql_experiment_run_annotation(annotation) for annotation in annotations], args
         )

{arize_phoenix-4.30.1 → arize_phoenix-4.30.2}/src/phoenix/server/app.py

@@ -66,6 +66,7 @@ from phoenix.server.api.dataloaders import (
     DocumentRetrievalMetricsDataLoader,
     ExperimentAnnotationSummaryDataLoader,
     ExperimentErrorRatesDataLoader,
+    ExperimentRunAnnotations,
     ExperimentRunCountsDataLoader,
     ExperimentSequenceNumberDataLoader,
     LatencyMsQuantileDataLoader,
@@ -446,6 +447,7 @@ def create_graphql_router(
                 ),
                 experiment_annotation_summaries=ExperimentAnnotationSummaryDataLoader(db),
                 experiment_error_rates=ExperimentErrorRatesDataLoader(db),
+                experiment_run_annotations=ExperimentRunAnnotations(db),
                 experiment_run_counts=ExperimentRunCountsDataLoader(db),
                 experiment_sequence_number=ExperimentSequenceNumberDataLoader(db),
                 latency_ms_quantile=LatencyMsQuantileDataLoader(

arize_phoenix-4.30.2/src/phoenix/version.py

@@ -0,0 +1 @@
+__version__ = "4.30.2"

arize_phoenix-4.30.1/src/phoenix/version.py

@@ -1 +0,0 @@
-__version__ = "4.30.1"