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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.30.0
+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.0 → 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.0 → 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.0 → 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.0 → 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.0 → 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.0 → arize_phoenix-4.30.2}/src/phoenix/session/client.py

@@ -22,7 +22,6 @@ from typing import (
     cast,
 )
 from urllib.parse import quote, urljoin
-from warnings import warn
 
 import httpx
 import pandas as pd
@@ -152,21 +151,37 @@ class Client(TraceDataExtractor):
                 "stop_time is deprecated. Use end_time instead.",
             )
             end_time = end_time or stop_time
-        response = self._client.post(
-            url=urljoin(self._base_url, "v1/spans"),
-            params={
-                "project_name": project_name,
-                "project-name": project_name,  # for backward-compatibility
-            },
-            json={
-                "queries": [q.to_dict() for q in queries],
-                "start_time": _to_iso_format(normalize_datetime(start_time)),
-                "end_time": _to_iso_format(normalize_datetime(end_time)),
-                "limit": limit,
-                "root_spans_only": root_spans_only,
-            },
-            timeout=timeout,
-        )
+        try:
+            response = self._client.post(
+                url=urljoin(self._base_url, "v1/spans"),
+                params={
+                    "project_name": project_name,
+                    "project-name": project_name,  # for backward-compatibility
+                },
+                json={
+                    "queries": [q.to_dict() for q in queries],
+                    "start_time": _to_iso_format(normalize_datetime(start_time)),
+                    "end_time": _to_iso_format(normalize_datetime(end_time)),
+                    "limit": limit,
+                    "root_spans_only": root_spans_only,
+                },
+                timeout=timeout,
+            )
+        except httpx.TimeoutException as error:
+            error_message = (
+                (
+                    f"The request timed out after {timeout} seconds. The timeout can be increased "
+                    "by passing a larger value to the `timeout` parameter "
+                    "and can be disabled altogether by passing `None`."
+                )
+                if timeout is not None
+                else (
+                    "The request timed out. The timeout can be adjusted by "
+                    "passing a number of seconds to the `timeout` parameter "
+                    "and can be disabled altogether by passing `None`."
+                )
+            )
+            raise TimeoutError(error_message) from error
         if response.status_code == 404:
             logger.info("No spans found.")
             return None
@@ -503,7 +518,6 @@ class Client(TraceDataExtractor):
         inputs: Iterable[Mapping[str, Any]] = (),
         outputs: Iterable[Mapping[str, Any]] = (),
         metadata: Iterable[Mapping[str, Any]] = (),
-        dataset_description: Optional[str] = None,
     ) -> Dataset:
         """
         Append examples to dataset on the Phoenix server. If `dataframe` or
@@ -537,11 +551,6 @@ class Client(TraceDataExtractor):
         Returns:
             A Dataset object with its examples.
         """
-        if dataset_description is not None:
-            warn(
-                "The `dataset_description` parameter has been deprecated "
-                "and will be removed in a future release."
-            )
         if dataframe is not None or csv_file_path is not None:
             if dataframe is not None and csv_file_path is not None:
                 raise ValueError(
@@ -838,3 +847,6 @@ def _is_all_dict(seq: Sequence[Any]) -> bool:
 
 
 class DatasetUploadError(Exception): ...
+
+
+class TimeoutError(Exception): ...

arize_phoenix-4.30.2/src/phoenix/version.py

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

arize_phoenix-4.30.0/src/phoenix/version.py

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