arize-phoenix 4.30.1__py3-none-any.whl → 4.30.2__py3-none-any.whl

{arize_phoenix-4.30.1.dist-info → arize_phoenix-4.30.2.dist-info}/METADATA

@@ -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.dist-info → arize_phoenix-4.30.2.dist-info}/RECORD

@@ -6,7 +6,7 @@ phoenix/exceptions.py,sha256=n2L2KKuecrdflB9MsCdAYCiSEvGJptIsfRkXMoJle7A,169
 phoenix/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 phoenix/services.py,sha256=OyML4t2XGnlqF0JXA9_uccL8HslTABxep9Ci7MViKEU,5216
 phoenix/settings.py,sha256=cO-qgis_S27nHirTobYI9hHPfZH18R--WMmxNdsVUwc,273
-phoenix/version.py,sha256=6kuemPn1sfBumZHqXy38x_dTEfi76ATKEh9dId-Cb78,23
+phoenix/version.py,sha256=DvmdNpuJDXvg0nMZADyqJJU0JkqI_2lJ8G7e_VN97L0,23
 phoenix/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 phoenix/core/embedding_dimension.py,sha256=zKGbcvwOXgLf-yrJBpQyKtd-LEOPRKHnUToyAU8Owis,87
 phoenix/core/model.py,sha256=km_a--PBHOuA337ClRw9xqhOHhrUT6Rl9pz_zV0JYkQ,4843
@@ -64,7 +64,7 @@ phoenix/metrics/retrieval_metrics.py,sha256=XFQPo66h16w7-1AJ92M1VL_BUIXIWxXHGKF_
 phoenix/metrics/timeseries.py,sha256=Cib3E0njJzi0vZpmyADvbakFQA98rIkfDaYAOmsmBz8,6277
 phoenix/metrics/wrappers.py,sha256=umZqa_5lf1wZSFe3FgzxF-qp1xbPdKD54W628GlGCUI,8392
 phoenix/otel/__init__.py,sha256=YvEiD-3aGZs9agwLNCXU34ofV3G-Q-dolfsiinOJuT0,407
-phoenix/otel/otel.py,sha256=pfFiqziSmTj8KepEZlVtjvSTd_SfNa6F8r9eqrOR6OQ,11829
+phoenix/otel/otel.py,sha256=NMQ-5KtpfCVGVkRzcz7fBsjCFTTR7R7wHna-87gvxfQ,17065
 phoenix/otel/settings.py,sha256=Qr2-RkgLQRfLhJqtLpEkSpqns7qLjPoOvpEOTqeSohM,3026
 phoenix/pointcloud/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 phoenix/pointcloud/clustering.py,sha256=IzcG67kJ2hPP7pcqVmKPSL_6gKRonKdOT3bCtbTOqnk,820
@@ -72,7 +72,7 @@ phoenix/pointcloud/pointcloud.py,sha256=4zAIkKs2xOUbchpj4XDAV-iPMXrfAJ15TG6rlIYG
 phoenix/pointcloud/projectors.py,sha256=zO_RrtDYSv2rqVOfIP2_9Cv11Dc8EmcZR94xhFcBYPU,1057
 phoenix/pointcloud/umap_parameters.py,sha256=3UQSjrysVOvq2V4KNpTMqNqNiK0BsTZnPBHWZ4fyJtQ,1708
 phoenix/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/app.py,sha256=7LiZiusw_yHZBVWMk8gH4tX8yFitTJ2jdyhMWVm2DdM,26817
+phoenix/server/app.py,sha256=4EPqxjfhFqxzk_JS560Gm8O9_TFtJ6lXW-72CfEzyGU,26920
 phoenix/server/dml_event.py,sha256=MpjCFqljxvgb9OB5Cez9vJesb3oHb3XxXictynBfcis,2851
 phoenix/server/dml_event_handler.py,sha256=6p-PucctivelVHfO-_9zNxWZYPr_eGjDF3bKjLtc5co,8251
 phoenix/server/grpc_server.py,sha256=jllxDNkpLQxDkvej4RhTokobowbvydF-SU8gSw1MTCc,3378
@@ -82,22 +82,23 @@ phoenix/server/telemetry.py,sha256=T_2OKrxNViAeaANlNspEekg_Y5uZIFWvKAnpz8Aoqvk,2
 phoenix/server/thread_server.py,sha256=RwXQGP_QhGD7le6WB7xEygEEuwBl5Ck_Zo8xGIYGi9M,2135
 phoenix/server/types.py,sha256=S2dReLNboR2nzjRK5j3MUyUDqu6AQFD7KRwJkeKj1q4,3609
 phoenix/server/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-phoenix/server/api/context.py,sha256=WuhGT2549C5Yc7pWj2S7NaPeT4a-N-_mmz-Vg5bUkI8,3637
+phoenix/server/api/context.py,sha256=XLlRtIhBl3iEq7exrN_DaO0n-XyvuvdO5bLB4uDrQhI,3724
 phoenix/server/api/exceptions.py,sha256=KdAzgwNan-wQ7THDrSoeJU2k9zWQVcH6lRiB462VsRA,990
 phoenix/server/api/interceptor.py,sha256=ykDnoC_apUd-llVli3m1CW18kNSIgjz2qZ6m5JmPDu8,1294
 phoenix/server/api/queries.py,sha256=hUzeHOUWuBQ-kjXh13-d5LgJfkbB8XSpFaHJX4YXpC8,23875
 phoenix/server/api/schema.py,sha256=4L2m6QXhaV13YPTZCEZ3hqCPQFHZOy3QnJVLRYQFzpg,548
 phoenix/server/api/utils.py,sha256=Kl47G-1A7QKTDrc75BU2QK6HupsG6MWuXxy351FOfKQ,858
-phoenix/server/api/dataloaders/__init__.py,sha256=TrOGnU_SD_vEIxOE_dm8HrD5C2ScLFQ4xQ7f8r-E76s,3064
+phoenix/server/api/dataloaders/__init__.py,sha256=D1xEKunv8ZUBEPk2eStX-JhoPR3_NaQcNOp47H-oChM,3161
 phoenix/server/api/dataloaders/annotation_summaries.py,sha256=Wv8AORZoGd5TJ4Y-em8iqJu87AMpZP7lWOTr-SML-x8,5560
 phoenix/server/api/dataloaders/average_experiment_run_latency.py,sha256=q091UmkXx37OBKh7L-GJ5LXHyRXfX2w4XTk1NMHtPpw,1827
-phoenix/server/api/dataloaders/dataset_example_revisions.py,sha256=rZhJoIYUGgYhXwVBtq5u0bqtHmIQ2Sh6HNnJsSGIXis,3767
+phoenix/server/api/dataloaders/dataset_example_revisions.py,sha256=_X2CwCc6lAkD4VuwAiyo4DfSVS8uuzub05sKyKiEXm8,5149
 phoenix/server/api/dataloaders/dataset_example_spans.py,sha256=-TjdyyJv2c2JiN1OXu6MMmQ-BEKlHXucEDcuObeRVsU,1416
 phoenix/server/api/dataloaders/document_evaluation_summaries.py,sha256=5XOom2KRAmCwPmtlraiZOSl3vhfaW-eiiYkmetAEalw,5616
 phoenix/server/api/dataloaders/document_evaluations.py,sha256=V6sE34jON_qFxt7eArJbktykAsty-gnBZHlEkORcj0E,1296
 phoenix/server/api/dataloaders/document_retrieval_metrics.py,sha256=JqDqkUuoeG6WfcmWSrmQptfF6IPX8XgzYzyECXTAjgg,4202
 phoenix/server/api/dataloaders/experiment_annotation_summaries.py,sha256=qDEBRo0XKJMYBYlXBgJ-69jwPK-0r4pi9ZhbjC_vx6M,2813
 phoenix/server/api/dataloaders/experiment_error_rates.py,sha256=wWTFOO2UxGIYUu53nnzzLk04-mJxw-BQgJELA9gT5bY,1949
+phoenix/server/api/dataloaders/experiment_run_annotations.py,sha256=Ey42FYy6WIASWlO-KKwHewfvH_RBL0Ci3W3xrv4oyaE,1361
 phoenix/server/api/dataloaders/experiment_run_counts.py,sha256=8VlKRaXwD56-7q_uonRr7L6QlEkyEQubkFKmKx6vuz0,1661
 phoenix/server/api/dataloaders/experiment_sequence_number.py,sha256=hSpKyOz3ES4UTfOzOfHeQ1ZXat-bzcdKybVSbYmhrBw,1563
 phoenix/server/api/dataloaders/latency_ms_quantile.py,sha256=5Y2OQ_GeH1My2573eOm7zPbqpwDZ_WeMLoZMq3KDoNQ,7403
@@ -198,7 +199,7 @@ phoenix/server/api/types/ExampleRevisionInterface.py,sha256=gV3Gt9-3Oi5wjaVtepC6
 phoenix/server/api/types/Experiment.py,sha256=YNs8SzOMSYUKiAMANuWSv8NxSNFzSIFOBOWb_yztE0s,5482
 phoenix/server/api/types/ExperimentAnnotationSummary.py,sha256=Uk3JtxIrsMoZT5tqc4nJdUOM3XegVzjUyoV3pkjNotE,256
 phoenix/server/api/types/ExperimentComparison.py,sha256=0sFz6MoBDw39dds0qVyaqhVs9qqO5rkG1FMSjmfBeCc,441
-phoenix/server/api/types/ExperimentRun.py,sha256=122_SID7SLKPUq2dJ2Y4BBw40DNUtcxo6QCZuO8UbBs,2997
+phoenix/server/api/types/ExperimentRun.py,sha256=LkR7fBRZ3nH57ZoHJwePTGtJYcTMM-EH5r1TVPiMyxg,2687
 phoenix/server/api/types/ExperimentRunAnnotation.py,sha256=iBxDaD9DgiF-Qymp5QyxWfJRGYXM1_CeWA_qzsZBqkI,1812
 phoenix/server/api/types/ExportedFile.py,sha256=e3GTn7B5LgsTbqiwjhMCQH7VsiqXitrBO4aCMS1lHsg,163
 phoenix/server/api/types/Functionality.py,sha256=tzV9xdhB8zqfsjWxP66NDC7EZsplYkYO7jRbLWJIeeg,382
@@ -295,8 +296,8 @@ phoenix/utilities/logging.py,sha256=lDXd6EGaamBNcQxL4vP1au9-i_SXe0OraUDiJOcszSw,
 phoenix/utilities/project.py,sha256=8IJuMM4yUMoooPi37sictGj8Etu9rGmq6RFtc9848cQ,436
 phoenix/utilities/re.py,sha256=PDve_OLjRTM8yQQJHC8-n3HdIONi7aNils3ZKRZ5uBM,2045
 phoenix/utilities/span_store.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-arize_phoenix-4.30.1.dist-info/METADATA,sha256=dygvZQ4Y3cjF7a80jliAm0DoupHUB_N3STUVDRmL-D4,11977
-arize_phoenix-4.30.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-arize_phoenix-4.30.1.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
-arize_phoenix-4.30.1.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
-arize_phoenix-4.30.1.dist-info/RECORD,,
+arize_phoenix-4.30.2.dist-info/METADATA,sha256=qMHw9BdGbxXT2Z0TrtzXy-bv_atoD45Ohw0EF9pMu1k,11977
+arize_phoenix-4.30.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+arize_phoenix-4.30.2.dist-info/licenses/IP_NOTICE,sha256=JBqyyCYYxGDfzQ0TtsQgjts41IJoa-hiwDrBjCb9gHM,469
+arize_phoenix-4.30.2.dist-info/licenses/LICENSE,sha256=HFkW9REuMOkvKRACuwLPT0hRydHb3zNg-fdFt94td18,3794
+arize_phoenix-4.30.2.dist-info/RECORD,,

phoenix/otel/otel.py

@@ -51,9 +51,10 @@ def register(
             not provided, the `PHOENIX_PROJECT_NAME` environment variable will be used.
         batch (bool): If True, spans will be processed using a BatchSpanprocessor. If False, spans
             will be processed one at a time using a SimpleSpanProcessor.
-        set_global_tracer_provider (bool): If False, the TracerProvider will not be set as the global
-            tracer provider. Defaults to True.
-        headers (dict, optional): Optional headers to include in the HTTP request to the collector.
+        set_global_tracer_provider (bool): If False, the TracerProvider will not be set as the
+            global tracer provider. Defaults to True.
+        headers (dict, optional): Optional headers to include in the request to the collector.
+            If not provided, the `PHOENIX_CLIENT_HEADERS` environment variable will be used.
         verbose (bool): If True, configuration details will be printed to stdout.
     """
 
@@ -73,7 +74,8 @@ def register(
         global_provider_msg = (
             "|  \n"
             "|  `register` has set this TracerProvider as the global OpenTelemetry default.\n"
-            "|  To disable this behavior, call `register` with `set_global_tracer_provider=False`.\n"
+            "|  To disable this behavior, call `register` with "
+            "`set_global_tracer_provider=False`.\n"
         )
     else:
         global_provider_msg = ""
@@ -85,6 +87,22 @@ def register(
 
 
 class TracerProvider(_TracerProvider):
+    """
+    An extension of `opentelemetry.sdk.trace.TracerProvider` with Phoenix-aware defaults.
+
+    Extended keyword arguments are documented in the `Args` section. For further documentation, see
+    the OpenTelemetry documentation at https://opentelemetry.io/docs/specs/otel/trace/sdk/.
+
+    Args:
+        endpoint (str, optional): The collector endpoint to which spans will be exported. If
+            specified, a default SpanProcessor will be created and added to this TracerProvider.
+            If not provided, the `PHOENIX_OTEL_COLLECTOR_ENDPOINT` environment variable will be
+            used to infer which collector endpoint to use, defaults to the gRPC endpoint. When
+            specifying the endpoint, the transport method (HTTP or gRPC) will be inferred from the
+            URL.
+        verbose (bool): If True, configuration details will be printed to stdout.
+    """
+
     def __init__(
         self, *args: Any, endpoint: Optional[str] = None, verbose: bool = True, **kwargs: Any
     ):
@@ -112,6 +130,12 @@ class TracerProvider(_TracerProvider):
             print(self._tracing_details())
 
     def add_span_processor(self, *args: Any, **kwargs: Any) -> None:
+        """
+        Registers a new `SpanProcessor` for this `TracerProvider`.
+
+        If this `TracerProvider` has a default processor, it will be removed.
+        """
+
         if self._default_processor:
             self._active_span_processor.shutdown()
             self._active_span_processor._span_processors = tuple()  # remove default processors
@@ -163,6 +187,24 @@ class TracerProvider(_TracerProvider):
 
 
 class SimpleSpanProcessor(_SimpleSpanProcessor):
+    """
+    Simple SpanProcessor implementation.
+
+    SimpleSpanProcessor is an implementation of `SpanProcessor` that passes ended spans directly to
+    the configured `SpanExporter`.
+
+    Args:
+        span_exporter (SpanExporter, optional): The `SpanExporter` to which ended spans will be
+            passed.
+        endpoint (str, optional): The collector endpoint to which spans will be exported. If not
+            provided, the `PHOENIX_OTEL_COLLECTOR_ENDPOINT` environment variable will be used to
+            infer which collector endpoint to use, defaults to the gRPC endpoint. When specifying
+            the endpoint, the transport method (HTTP or gRPC) will be inferred from the URL.
+        headers (dict, optional): Optional headers to include in the request to the collector.
+            If not provided, the `PHOENIX_CLIENT_HEADERS` or `OTEL_EXPORTER_OTLP_HEADERS`
+            environment variable will be used.
+    """
+
     def __init__(
         self,
         span_exporter: Optional[SpanExporter] = None,
@@ -182,6 +224,37 @@ class SimpleSpanProcessor(_SimpleSpanProcessor):
 
 
 class BatchSpanProcessor(_BatchSpanProcessor):
+    """
+    Batch SpanProcessor implementation.
+
+    `BatchSpanProcessor` is an implementation of `SpanProcessor` that batches ended spans and
+    pushes them to the configured `SpanExporter`.
+
+    `BatchSpanProcessor` is configurable with the following environment variables which correspond
+    to constructor parameters:
+
+    - :envvar:`OTEL_BSP_SCHEDULE_DELAY`
+    - :envvar:`OTEL_BSP_MAX_QUEUE_SIZE`
+    - :envvar:`OTEL_BSP_MAX_EXPORT_BATCH_SIZE`
+    - :envvar:`OTEL_BSP_EXPORT_TIMEOUT`
+
+    Args:
+        span_exporter (SpanExporter, optional): The `SpanExporter` to which ended spans will be
+            passed.
+        endpoint (str, optional): The collector endpoint to which spans will be exported. If not
+            provided, the `PHOENIX_OTEL_COLLECTOR_ENDPOINT` environment variable will be used to
+            infer which collector endpoint to use, defaults to the gRPC endpoint. When specifying
+            the endpoint, the transport method (HTTP or gRPC) will be inferred from the URL.
+        headers (dict, optional): Optional headers to include in the request to the collector.
+            If not provided, the `PHOENIX_CLIENT_HEADERS` or `OTEL_EXPORTER_OTLP_HEADERS`
+            environment variable will be used.
+        max_queue_size (int, optional): The maximum queue size.
+        schedule_delay_millis (float, optional): The delay between two consecutive exports in
+            milliseconds.
+        max_export_batch_size (int, optional): The maximum batch size.
+        export_timeout_millis (float, optional): The batch timeout in milliseconds.
+    """
+
     def __init__(
         self,
         span_exporter: Optional[SpanExporter] = None,
@@ -201,6 +274,20 @@ class BatchSpanProcessor(_BatchSpanProcessor):
 
 
 class HTTPSpanExporter(_HTTPSpanExporter):
+    """
+    OTLP span exporter using HTTP.
+
+    For more information, see:
+    - `opentelemetry.exporter.otlp.proto.http.trace_exporter.OTLPSpanExporter`
+
+    Args:
+        endpoint (str, optional): OpenTelemetry Collector receiver endpoint. If not provided, the
+            `PHOENIX_OTEL_COLLECTOR_ENDPOINT` environment variable will be used to infer which
+            collector endpoint to use, defaults to the HTTP endpoint.
+        headers: Headers to send when exporting. If not provided, the `PHOENIX_CLIENT_HEADERS`
+            or `OTEL_EXPORTER_OTLP_HEADERS` environment variables will be used.
+    """
+
     def __init__(self, *args: Any, **kwargs: Any):
         sig = inspect.signature(_HTTPSpanExporter)
         bound_args = sig.bind_partial(*args, **kwargs)
@@ -210,12 +297,30 @@ class HTTPSpanExporter(_HTTPSpanExporter):
             bound_args.arguments["headers"] = get_env_client_headers()
 
         if bound_args.arguments.get("endpoint") is None:
-            _, endpoint = _normalized_endpoint(None)
+            _, endpoint = _normalized_endpoint(None, use_http=True)
             bound_args.arguments["endpoint"] = endpoint
         super().__init__(**bound_args.arguments)
 
 
 class GRPCSpanExporter(_GRPCSpanExporter):
+    """
+    OTLP span exporter using gRPC.
+
+    For more information, see:
+    - `opentelemetry.exporter.otlp.proto.grpc.trace_exporter.OTLPSpanExporter`
+
+    Args:
+        endpoint (str, optional): OpenTelemetry Collector receiver endpoint. If not provided, the
+            `PHOENIX_OTEL_COLLECTOR_ENDPOINT` environment variable will be used to infer which
+            collector endpoint to use, defaults to the gRPC endpoint.
+        insecure: Connection type
+        credentials: Credentials object for server authentication
+        headers: Headers to send when exporting. If not provided, the `PHOENIX_CLIENT_HEADERS`
+            or `OTEL_EXPORTER_OTLP_HEADERS` environment variables will be used.
+        timeout: Backend request timeout in seconds
+        compression: gRPC compression method to use
+    """
+
     def __init__(self, *args: Any, **kwargs: Any):
         sig = inspect.signature(_GRPCSpanExporter)
         bound_args = sig.bind_partial(*args, **kwargs)
@@ -270,12 +375,16 @@ _KNOWN_PROVIDERS = {
 }
 
 
-def _normalized_endpoint(endpoint: Optional[str]) -> Tuple[ParseResult, str]:
+def _normalized_endpoint(
+    endpoint: Optional[str], use_http: bool = False
+) -> Tuple[ParseResult, str]:
     if endpoint is None:
         base_endpoint = get_env_collector_endpoint() or "http://localhost:6006"
         parsed = urlparse(base_endpoint)
         if parsed.hostname in _KNOWN_PROVIDERS:
             parsed = _KNOWN_PROVIDERS[parsed.hostname](parsed)
+        elif use_http:
+            parsed = _construct_http_endpoint(parsed)
         else:
             parsed = _construct_grpc_endpoint(parsed)
     else:

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

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",

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(

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
+        ]

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
         )

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(

phoenix/version.py

@@ -1 +1 @@
-__version__ = "4.30.1"
+__version__ = "4.30.2"