arize-phoenix 12.6.0__tar.gz → 12.7.0__tar.gz

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 12.6.0
+Version: 12.7.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues
@@ -58,7 +58,7 @@ Requires-Dist: strawberry-graphql==0.270.1
 Requires-Dist: tqdm
 Requires-Dist: typing-extensions>=4.6
 Requires-Dist: uvicorn
-Requires-Dist: wrapt>=1.17.2
+Requires-Dist: wrapt<2,>=1.17.2
 Provides-Extra: container
 Requires-Dist: aiohttp; extra == 'container'
 Requires-Dist: anthropic>=0.49.0; extra == 'container'
@@ -194,16 +194,22 @@ Phoenix container images are available via [Docker Hub](https://hub.docker.com/r
 
 The `arize-phoenix` package includes the entire Phoenix platfom. However if you have deployed the Phoenix platform, there are light-weight Python sub-packages and TypeScript packages that can be used in conjunction with the platfrom.
 
-### Subpackages
+### Python Subpackages
 
-| Package                                                                                             | Version & Docs                                                                                                                                                                                                                                                                      | Description                                                                                       |
-| --------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
-| [arize-phoenix-otel](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-otel)           | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-otel)](https://pypi.org/project/arize-phoenix-otel/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/otel/en/latest/index.html)       | Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults        |
-| [arize-phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-client)       | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-client)](https://pypi.org/project/arize-phoenix-client/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/client/en/latest/index.html) | Lightweight client for interacting with the Phoenix server via its OpenAPI REST interface         |
-| [arize-phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-evals)         | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-evals)](https://pypi.org/project/arize-phoenix-evals/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/evals/en/latest/index.html)    | Tooling to evaluate LLM applications including RAG relevance, answer relevance, and more          |
-| [@arizeai/phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-client) | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-client)](https://www.npmjs.com/package/@arizeai/phoenix-client) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)                            | Client for the Arize Phoenix API                                                                  |
-| [@arizeai/phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-evals)   | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-evals)](https://www.npmjs.com/package/@arizeai/phoenix-evals) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)                              | TypeScript evaluation library for LLM applications (alpha release)                                |
-| [@arizeai/phoenix-mcp](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-mcp)       | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-mcp)](https://www.npmjs.com/package/@arizeai/phoenix-mcp) [![Docs](https://img.shields.io/badge/docs-blue?logo=markdown&logoColor=white)](./js/packages/phoenix-mcp/README.md)                                    | MCP server implementation for Arize Phoenix providing unified interface to Phoenix's capabilities |
+| Package                                                                                       | Version & Docs                                                                                                                                                                                                                                                                      | Description                                                                                |
+| --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| [arize-phoenix-otel](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-otel)     | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-otel)](https://pypi.org/project/arize-phoenix-otel/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/otel/en/latest/index.html)       | Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults |
+| [arize-phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-client) | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-client)](https://pypi.org/project/arize-phoenix-client/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/client/en/latest/index.html) | Lightweight client for interacting with the Phoenix server via its OpenAPI REST interface  |
+| [arize-phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-evals)   | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-evals)](https://pypi.org/project/arize-phoenix-evals/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/evals/en/latest/index.html)    | Tooling to evaluate LLM applications including RAG relevance, answer relevance, and more   |
+
+### TypeScript Subpackages
+
+| Package                                                                                             | Version & Docs                                                                                                                                                                                                                                           | Description                                                                                       |
+| --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| [@arizeai/phoenix-otel](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-otel)     | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-otel)](https://www.npmjs.com/package/@arizeai/phoenix-otel) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)     | Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults        |
+| [@arizeai/phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-client) | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-client)](https://www.npmjs.com/package/@arizeai/phoenix-client) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/) | Client for the Arize Phoenix API                                                                  |
+| [@arizeai/phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-evals)   | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-evals)](https://www.npmjs.com/package/@arizeai/phoenix-evals) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)   | TypeScript evaluation library for LLM applications (alpha release)                                |
+| [@arizeai/phoenix-mcp](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-mcp)       | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-mcp)](https://www.npmjs.com/package/@arizeai/phoenix-mcp) [![Docs](https://img.shields.io/badge/docs-blue?logo=markdown&logoColor=white)](./js/packages/phoenix-mcp/README.md)         | MCP server implementation for Arize Phoenix providing unified interface to Phoenix's capabilities |
 
 ## Tracing Integrations
 

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/README.md

@@ -64,16 +64,22 @@ Phoenix container images are available via [Docker Hub](https://hub.docker.com/r
 
 The `arize-phoenix` package includes the entire Phoenix platfom. However if you have deployed the Phoenix platform, there are light-weight Python sub-packages and TypeScript packages that can be used in conjunction with the platfrom.
 
-### Subpackages
-
-| Package                                                                                             | Version & Docs                                                                                                                                                                                                                                                                      | Description                                                                                       |
-| --------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
-| [arize-phoenix-otel](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-otel)           | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-otel)](https://pypi.org/project/arize-phoenix-otel/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/otel/en/latest/index.html)       | Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults        |
-| [arize-phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-client)       | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-client)](https://pypi.org/project/arize-phoenix-client/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/client/en/latest/index.html) | Lightweight client for interacting with the Phoenix server via its OpenAPI REST interface         |
-| [arize-phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-evals)         | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-evals)](https://pypi.org/project/arize-phoenix-evals/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/evals/en/latest/index.html)    | Tooling to evaluate LLM applications including RAG relevance, answer relevance, and more          |
-| [@arizeai/phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-client) | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-client)](https://www.npmjs.com/package/@arizeai/phoenix-client) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)                            | Client for the Arize Phoenix API                                                                  |
-| [@arizeai/phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-evals)   | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-evals)](https://www.npmjs.com/package/@arizeai/phoenix-evals) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)                              | TypeScript evaluation library for LLM applications (alpha release)                                |
-| [@arizeai/phoenix-mcp](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-mcp)       | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-mcp)](https://www.npmjs.com/package/@arizeai/phoenix-mcp) [![Docs](https://img.shields.io/badge/docs-blue?logo=markdown&logoColor=white)](./js/packages/phoenix-mcp/README.md)                                    | MCP server implementation for Arize Phoenix providing unified interface to Phoenix's capabilities |
+### Python Subpackages
+
+| Package                                                                                       | Version & Docs                                                                                                                                                                                                                                                                      | Description                                                                                |
+| --------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
+| [arize-phoenix-otel](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-otel)     | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-otel)](https://pypi.org/project/arize-phoenix-otel/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/otel/en/latest/index.html)       | Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults |
+| [arize-phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-client) | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-client)](https://pypi.org/project/arize-phoenix-client/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/client/en/latest/index.html) | Lightweight client for interacting with the Phoenix server via its OpenAPI REST interface  |
+| [arize-phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/packages/phoenix-evals)   | [![PyPI Version](https://img.shields.io/pypi/v/arize-phoenix-evals)](https://pypi.org/project/arize-phoenix-evals/) [![Docs](https://img.shields.io/badge/docs-blue?logo=readthedocs&logoColor=white)](https://arize-phoenix.readthedocs.io/projects/evals/en/latest/index.html)    | Tooling to evaluate LLM applications including RAG relevance, answer relevance, and more   |
+
+### TypeScript Subpackages
+
+| Package                                                                                             | Version & Docs                                                                                                                                                                                                                                           | Description                                                                                       |
+| --------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| [@arizeai/phoenix-otel](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-otel)     | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-otel)](https://www.npmjs.com/package/@arizeai/phoenix-otel) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)     | Provides a lightweight wrapper around OpenTelemetry primitives with Phoenix-aware defaults        |
+| [@arizeai/phoenix-client](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-client) | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-client)](https://www.npmjs.com/package/@arizeai/phoenix-client) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/) | Client for the Arize Phoenix API                                                                  |
+| [@arizeai/phoenix-evals](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-evals)   | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-evals)](https://www.npmjs.com/package/@arizeai/phoenix-evals) [![Docs](https://img.shields.io/badge/docs-blue?logo=typescript&logoColor=white)](https://arize-ai.github.io/phoenix/)   | TypeScript evaluation library for LLM applications (alpha release)                                |
+| [@arizeai/phoenix-mcp](https://github.com/Arize-ai/phoenix/tree/main/js/packages/phoenix-mcp)       | [![NPM Version](https://img.shields.io/npm/v/%40arizeai%2Fphoenix-mcp)](https://www.npmjs.com/package/@arizeai/phoenix-mcp) [![Docs](https://img.shields.io/badge/docs-blue?logo=markdown&logoColor=white)](./js/packages/phoenix-mcp/README.md)         | MCP server implementation for Arize Phoenix providing unified interface to Phoenix's capabilities |
 
 ## Tracing Integrations
 

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/pyproject.toml

@@ -33,7 +33,7 @@ dependencies = [
   "pyarrow",
   "typing-extensions>=4.6",
   "scipy",
-  "wrapt>=1.17.2",
+  "wrapt>=1.17.2,<2",
   "protobuf>=4.25.8",
   "grpcio",
   "grpc-interceptor",

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/context.py

@@ -29,6 +29,7 @@ from phoenix.server.api.dataloaders import (
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
     ExperimentAnnotationSummaryDataLoader,
+    ExperimentDatasetSplitsDataLoader,
     ExperimentErrorRatesDataLoader,
     ExperimentRepeatedRunGroupAnnotationSummariesDataLoader,
     ExperimentRepeatedRunGroupsDataLoader,
@@ -111,6 +112,7 @@ class DataLoaders:
     document_evaluations: DocumentEvaluationsDataLoader
     document_retrieval_metrics: DocumentRetrievalMetricsDataLoader
     experiment_annotation_summaries: ExperimentAnnotationSummaryDataLoader
+    experiment_dataset_splits: ExperimentDatasetSplitsDataLoader
     experiment_error_rates: ExperimentErrorRatesDataLoader
     experiment_repeated_run_group_annotation_summaries: (
         ExperimentRepeatedRunGroupAnnotationSummariesDataLoader

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/dataloaders/__init__.py

@@ -25,6 +25,7 @@ from .document_evaluation_summaries import (
 from .document_evaluations import DocumentEvaluationsDataLoader
 from .document_retrieval_metrics import DocumentRetrievalMetricsDataLoader
 from .experiment_annotation_summaries import ExperimentAnnotationSummaryDataLoader
+from .experiment_dataset_splits import ExperimentDatasetSplitsDataLoader
 from .experiment_error_rates import ExperimentErrorRatesDataLoader
 from .experiment_repeated_run_group_annotation_summaries import (
     ExperimentRepeatedRunGroupAnnotationSummariesDataLoader,
@@ -91,6 +92,7 @@ __all__ = [
     "DatasetExamplesAndVersionsByExperimentRunDataLoader",
     "DatasetExampleSplitsDataLoader",
     "DatasetLabelsDataLoader",
+    "ExperimentDatasetSplitsDataLoader",
     "DocumentEvaluationSummaryDataLoader",
     "DocumentEvaluationsDataLoader",
     "DocumentRetrievalMetricsDataLoader",

arize_phoenix-12.7.0/src/phoenix/server/api/dataloaders/experiment_dataset_splits.py

@@ -0,0 +1,43 @@
+from sqlalchemy import 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
+Key: TypeAlias = ExperimentID
+Result: TypeAlias = list[models.DatasetSplit]
+
+
+class ExperimentDatasetSplitsDataLoader(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
+        async with self._db() as session:
+            splits: dict[ExperimentID, list[models.DatasetSplit]] = {}
+
+            async for experiment_id, split in await session.stream(
+                select(models.ExperimentDatasetSplit.experiment_id, models.DatasetSplit)
+                .select_from(models.DatasetSplit)
+                .join(
+                    models.ExperimentDatasetSplit,
+                    onclause=(
+                        models.DatasetSplit.id == models.ExperimentDatasetSplit.dataset_split_id
+                    ),
+                )
+                .where(models.ExperimentDatasetSplit.experiment_id.in_(experiment_ids))
+            ):
+                if experiment_id not in splits:
+                    splits[experiment_id] = []
+                splits[experiment_id].append(split)
+
+            return [
+                sorted(splits.get(experiment_id, []), key=lambda x: x.name)
+                for experiment_id in keys
+            ]

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/input_types/ChatCompletionInput.py

@@ -40,6 +40,7 @@ class ChatCompletionOverDatasetInput:
     repetitions: int
     dataset_id: GlobalID
     dataset_version_id: Optional[GlobalID] = None
+    split_ids: Optional[list[GlobalID]] = None
     experiment_name: Optional[str] = None
     experiment_description: Optional[str] = None
     experiment_metadata: Optional[JSON] = strawberry.field(default_factory=dict)

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/input_types/DatasetFilter.py

@@ -1,6 +1,8 @@
 from enum import Enum
+from typing import Optional
 
 import strawberry
+from strawberry import UNSET
 
 
 @strawberry.enum
@@ -10,5 +12,6 @@ class DatasetFilterColumn(Enum):
 
 @strawberry.input(description="A filter for datasets")
 class DatasetFilter:
-    col: DatasetFilterColumn
-    value: str
+    col: Optional[DatasetFilterColumn] = None
+    value: Optional[str] = None
+    filter_labels: Optional[list[str]] = UNSET

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/mutations/chat_mutations.py

@@ -186,12 +186,21 @@ class ChatCompletionMutationMixin:
                     raise NotFound("No versions found for the given dataset")
             else:
                 resolved_version_id = dataset_version_id
+            # Parse split IDs if provided
+            resolved_split_ids: Optional[list[int]] = None
+            if input.split_ids is not None and len(input.split_ids) > 0:
+                resolved_split_ids = [
+                    from_global_id_with_expected_type(split_id, models.DatasetSplit.__name__)
+                    for split_id in input.split_ids
+                ]
+
             revisions = [
                 revision
                 async for revision in await session.stream_scalars(
-                    get_dataset_example_revisions(resolved_version_id).order_by(
-                        models.DatasetExampleRevision.id
-                    )
+                    get_dataset_example_revisions(
+                        resolved_version_id,
+                        split_ids=resolved_split_ids,
+                    ).order_by(models.DatasetExampleRevision.id)
                 )
             ]
             if not revisions:
@@ -208,6 +217,11 @@ class ChatCompletionMutationMixin:
                 project_name=project_name,
                 user_id=user_id,
             )
+            if resolved_split_ids:
+                experiment.experiment_dataset_splits = [
+                    models.ExperimentDatasetSplit(dataset_split_id=split_id)
+                    for split_id in resolved_split_ids
+                ]
             await insert_experiment_with_examples_snapshot(session, experiment)
 
         results: list[Union[ChatCompletionMutationPayload, BaseException]] = []

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/queries.py

@@ -22,7 +22,10 @@ from phoenix.config import (
 )
 from phoenix.db import models
 from phoenix.db.constants import DEFAULT_PROJECT_TRACE_RETENTION_POLICY_ID
-from phoenix.db.helpers import SupportedSQLDialect, exclude_experiment_projects
+from phoenix.db.helpers import (
+    SupportedSQLDialect,
+    exclude_experiment_projects,
+)
 from phoenix.db.models import LatencyMs
 from phoenix.pointcloud.clustering import Hdbscan
 from phoenix.server.api.auth import MSG_ADMIN_ONLY, IsAdmin
@@ -385,7 +388,35 @@ class Query:
             sort_col = getattr(models.Dataset, sort.col.value)
             stmt = stmt.order_by(sort_col.desc() if sort.dir is SortDir.desc else sort_col.asc())
         if filter:
-            stmt = stmt.where(getattr(models.Dataset, filter.col.value).ilike(f"%{filter.value}%"))
+            # Apply name filter
+            if filter.col and filter.value:
+                stmt = stmt.where(
+                    getattr(models.Dataset, filter.col.value).ilike(f"%{filter.value}%")
+                )
+
+            # Apply label filter
+            if filter.filter_labels and filter.filter_labels is not UNSET:
+                label_rowids = []
+                for label_id in filter.filter_labels:
+                    try:
+                        label_rowid = from_global_id_with_expected_type(
+                            global_id=GlobalID.from_id(label_id),
+                            expected_type_name="DatasetLabel",
+                        )
+                        label_rowids.append(label_rowid)
+                    except ValueError:
+                        continue  # Skip invalid label IDs
+
+                if label_rowids:
+                    # Join with the junction table to filter by labels
+                    stmt = (
+                        stmt.join(
+                            models.DatasetsDatasetLabel,
+                            models.Dataset.id == models.DatasetsDatasetLabel.dataset_id,
+                        )
+                        .where(models.DatasetsDatasetLabel.dataset_label_id.in_(label_rowids))
+                        .distinct()
+                    )
         async with info.context.db() as session:
             datasets = await session.scalars(stmt)
         return connection_from_list(
@@ -448,6 +479,7 @@ class Query:
                     )
                 )
             ).all()
+
             if not experiments or len(experiments) < len(experiment_rowids):
                 raise NotFound("Unable to resolve one or more experiment IDs.")
             num_datasets = len(set(experiment.dataset_id for experiment in experiments))
@@ -456,37 +488,19 @@ class Query:
             base_experiment = next(
                 experiment for experiment in experiments if experiment.id == base_experiment_rowid
             )
-            revision_ids = (
-                select(func.max(models.DatasetExampleRevision.id))
-                .join(
-                    models.DatasetExample,
-                    models.DatasetExample.id == models.DatasetExampleRevision.dataset_example_id,
-                )
-                .where(
-                    and_(
-                        models.DatasetExampleRevision.dataset_version_id
-                        <= base_experiment.dataset_version_id,
-                        models.DatasetExample.dataset_id == base_experiment.dataset_id,
-                    )
-                )
-                .group_by(models.DatasetExampleRevision.dataset_example_id)
-                .scalar_subquery()
-            )
+
+            # Use ExperimentDatasetExample to pull down examples.
+            # Splits are mutable and should not be used for comparison.
+            # The comparison should only occur against examples which were assigned to the same
+            # splits at the time of execution of the ExperimentRun.
             examples_query = (
                 select(models.DatasetExample)
-                .distinct(models.DatasetExample.id)
-                .join(
-                    models.DatasetExampleRevision,
-                    onclause=and_(
-                        models.DatasetExample.id
-                        == models.DatasetExampleRevision.dataset_example_id,
-                        models.DatasetExampleRevision.id.in_(revision_ids),
-                        models.DatasetExampleRevision.revision_kind != "DELETE",
-                    ),
-                )
+                .join(models.ExperimentDatasetExample)
+                .where(models.ExperimentDatasetExample.experiment_id == base_experiment_rowid)
                 .order_by(models.DatasetExample.id.desc())
                 .limit(page_size + 1)
             )
+
             if cursor is not None:
                 examples_query = examples_query.where(models.DatasetExample.id < cursor.rowid)
 
@@ -1103,6 +1117,7 @@ class Query:
         after: Optional[CursorString] = UNSET,
         before: Optional[CursorString] = UNSET,
         filter: Optional[PromptFilter] = UNSET,
+        labelIds: Optional[list[GlobalID]] = UNSET,
     ) -> Connection[Prompt]:
         args = ConnectionArgs(
             first=first,
@@ -1119,6 +1134,16 @@ class Query:
             stmt = stmt.where(column.ilike(f"%{filter.value}%")).order_by(
                 models.Prompt.updated_at.desc()
             )
+        if labelIds:
+            stmt = stmt.join(models.PromptPromptLabel).where(
+                models.PromptPromptLabel.prompt_label_id.in_(
+                    from_global_id_with_expected_type(
+                        global_id=label_id, expected_type_name="PromptLabel"
+                    )
+                    for label_id in labelIds
+                )
+            )
+            stmt = stmt.distinct()
         async with info.context.db() as session:
             orm_prompts = await session.stream_scalars(stmt)
             data = [to_gql_prompt_from_orm(orm_prompt) async for orm_prompt in orm_prompts]

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/routers/v1/datasets.py

@@ -23,6 +23,9 @@ from starlette.concurrency import run_in_threadpool
 from starlette.datastructures import FormData, UploadFile
 from starlette.requests import Request
 from starlette.responses import Response
+from starlette.status import (
+    HTTP_404_NOT_FOUND,
+)
 from strawberry.relay import GlobalID
 from typing_extensions import TypeAlias, assert_never
 
@@ -34,8 +37,10 @@ from phoenix.db.insertion.dataset import (
     ExampleContent,
     add_dataset_examples,
 )
+from phoenix.db.types.db_models import UNDEFINED
 from phoenix.server.api.types.Dataset import Dataset as DatasetNodeType
 from phoenix.server.api.types.DatasetExample import DatasetExample as DatasetExampleNodeType
+from phoenix.server.api.types.DatasetSplit import DatasetSplit as DatasetSplitNodeType
 from phoenix.server.api.types.DatasetVersion import DatasetVersion as DatasetVersionNodeType
 from phoenix.server.api.types.node import from_global_id_with_expected_type
 from phoenix.server.api.utils import delete_projects, delete_traces
@@ -697,6 +702,7 @@ class DatasetExample(V1RoutesBaseModel):
 class ListDatasetExamplesData(V1RoutesBaseModel):
     dataset_id: str
     version_id: str
+    filtered_splits: list[str] = UNDEFINED
     examples: list[DatasetExample]
 
 
@@ -719,6 +725,10 @@ async def get_dataset_examples(
             "The ID of the dataset version (if omitted, returns data from the latest version)"
         ),
     ),
+    split: Optional[list[str]] = Query(
+        default=None,
+        description="List of dataset split identifiers (GlobalIDs or names) to filter by",
+    ),
 ) -> ListDatasetExamplesResponseBody:
     try:
         dataset_gid = GlobalID.from_id(id)
@@ -795,9 +805,13 @@ async def get_dataset_examples(
                 )
 
         subquery = partial_subquery.subquery()
+
         # Query for the most recent example revisions that are not deleted
         query = (
-            select(models.DatasetExample, models.DatasetExampleRevision)
+            select(
+                models.DatasetExample,
+                models.DatasetExampleRevision,
+            )
             .join(
                 models.DatasetExampleRevision,
                 models.DatasetExample.id == models.DatasetExampleRevision.dataset_example_id,
@@ -810,6 +824,28 @@ async def get_dataset_examples(
             .filter(models.DatasetExampleRevision.revision_kind != "DELETE")
             .order_by(models.DatasetExample.id.asc())
         )
+
+        # If splits are provided, filter by dataset splits
+        resolved_split_names: list[str] = []
+        if split:
+            # Resolve split identifiers (IDs or names) to IDs and names
+            resolved_split_ids, resolved_split_names = await _resolve_split_identifiers(
+                session, split
+            )
+
+            # Add filter for splits (join with the association table)
+            # Use distinct() to prevent duplicates when an example belongs to
+            # multiple splits
+            query = (
+                query.join(
+                    models.DatasetSplitDatasetExample,
+                    models.DatasetExample.id
+                    == models.DatasetSplitDatasetExample.dataset_example_id,
+                )
+                .filter(models.DatasetSplitDatasetExample.dataset_split_id.in_(resolved_split_ids))
+                .distinct()
+            )
+
         examples = [
             DatasetExample(
                 id=str(GlobalID("DatasetExample", str(example.id))),
@@ -824,6 +860,7 @@ async def get_dataset_examples(
         data=ListDatasetExamplesData(
             dataset_id=str(GlobalID("Dataset", str(resolved_dataset_id))),
             version_id=str(GlobalID("DatasetVersion", str(resolved_version_id))),
+            filtered_splits=resolved_split_names,
             examples=examples,
         )
     )
@@ -1080,3 +1117,115 @@ async def _get_db_examples(
 
 def _is_all_dict(seq: Sequence[Any]) -> bool:
     return all(map(lambda obj: isinstance(obj, dict), seq))
+
+
+# Split identifier helper types and functions
+class _SplitId(int): ...
+
+
+_SplitIdentifier: TypeAlias = Union[_SplitId, str]
+
+
+def _parse_split_identifier(split_identifier: str) -> _SplitIdentifier:
+    """
+    Parse a split identifier as either a GlobalID or a name.
+
+    Args:
+        split_identifier: The identifier string (GlobalID or name)
+
+    Returns:
+        Either a _SplitId or an Identifier
+
+    Raises:
+        HTTPException: If the identifier format is invalid
+    """
+    if not split_identifier:
+        raise HTTPException(422, "Invalid split identifier")
+    try:
+        split_id = from_global_id_with_expected_type(
+            GlobalID.from_id(split_identifier),
+            DatasetSplitNodeType.__name__,
+        )
+    except ValueError:
+        return split_identifier
+    return _SplitId(split_id)
+
+
+async def _resolve_split_identifiers(
+    session: AsyncSession,
+    split_identifiers: list[str],
+) -> tuple[list[int], list[str]]:
+    """
+    Resolve a list of split identifiers (IDs or names) to split IDs and names.
+
+    Args:
+        session: The database session
+        split_identifiers: List of split identifiers (GlobalIDs or names)
+
+    Returns:
+        Tuple of (list of split IDs, list of split names)
+
+    Raises:
+        HTTPException: If any split identifier is invalid or not found
+    """
+    split_ids: list[int] = []
+    split_names: list[str] = []
+
+    # Parse all identifiers first
+    parsed_identifiers: list[_SplitIdentifier] = []
+    for identifier_str in split_identifiers:
+        parsed_identifiers.append(_parse_split_identifier(identifier_str.strip()))
+
+    # Separate IDs and names
+    requested_ids: list[int] = []
+    requested_names: list[str] = []
+    for identifier in parsed_identifiers:
+        if isinstance(identifier, _SplitId):
+            requested_ids.append(int(identifier))
+        elif isinstance(identifier, str):
+            requested_names.append(identifier)
+        else:
+            assert_never(identifier)
+
+    # Query for splits by ID
+    if requested_ids:
+        id_results = await session.stream(
+            select(models.DatasetSplit.id, models.DatasetSplit.name).where(
+                models.DatasetSplit.id.in_(requested_ids)
+            )
+        )
+        async for split_id, split_name in id_results:
+            split_ids.append(split_id)
+            split_names.append(split_name)
+
+        # Check if all requested IDs were found
+        found_ids = set(split_ids[-len(requested_ids) :] if requested_ids else [])
+        missing_ids = [sid for sid in requested_ids if sid not in found_ids]
+        if missing_ids:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Dataset splits not found for IDs: {', '.join(map(str, missing_ids))}",
+            )
+
+    # Query for splits by name
+    if requested_names:
+        name_results = await session.stream(
+            select(models.DatasetSplit.id, models.DatasetSplit.name).where(
+                models.DatasetSplit.name.in_(requested_names)
+            )
+        )
+        name_to_id: dict[str, int] = {}
+        async for split_id, split_name in name_results:
+            split_ids.append(split_id)
+            split_names.append(split_name)
+            name_to_id[split_name] = split_id
+
+        # Check if all requested names were found
+        missing_names = [name for name in requested_names if name not in name_to_id]
+        if missing_names:
+            raise HTTPException(
+                status_code=HTTP_404_NOT_FOUND,
+                detail=f"Dataset splits not found: {', '.join(missing_names)}",
+            )
+
+    return split_ids, split_names

{arize_phoenix-12.6.0 → arize_phoenix-12.7.0}/src/phoenix/server/api/routers/v1/experiments.py

@@ -25,6 +25,7 @@ from phoenix.server.bearer_auth import PhoenixUser
 from phoenix.server.dml_event import ExperimentInsertEvent
 from phoenix.server.experiments.utils import generate_experiment_project_name
 
+from .datasets import _resolve_split_identifiers
 from .models import V1RoutesBaseModel
 from .utils import ResponseBody, add_errors_to_responses, add_text_csv_content_to_responses
 
@@ -80,6 +81,10 @@ class CreateExperimentRequestBody(V1RoutesBaseModel):
             "(if omitted, the latest version will be used)"
         ),
     )
+    splits: Optional[list[str]] = Field(
+        default=None,
+        description="List of dataset split identifiers (GlobalIDs or names) to filter by",
+    )
     repetitions: int = Field(
         default=1, description="Number of times the experiment should be repeated for each example"
     )
@@ -192,6 +197,20 @@ async def create_experiment(
             project_name=project_name,
             user_id=user_id,
         )
+
+        if request_body.splits is not None:
+            # Resolve split identifiers (IDs or names) to IDs and names
+            resolved_split_ids, _ = await _resolve_split_identifiers(session, request_body.splits)
+
+            # Generate experiment dataset splits relation
+            # prior to the crosswalk table insert
+            # in insert_experiment_with_examples_snapshot
+            experiment.experiment_dataset_splits = [
+                models.ExperimentDatasetSplit(dataset_split_id=split_id)
+                for split_id in resolved_split_ids
+            ]
+
+        # crosswalk table assumes the relation is already present
         await insert_experiment_with_examples_snapshot(session, experiment)
 
         dialect = SupportedSQLDialect(session.bind.dialect.name)