arize-phoenix 4.4.4rc6__py3-none-any.whl → 4.5.0__py3-none-any.whl

phoenix/server/api/context.py

@@ -11,54 +11,34 @@ from typing_extensions import TypeAlias
 
 from phoenix.core.model_schema import Model
 from phoenix.server.api.dataloaders import (
-    AverageExperimentRunLatencyDataLoader,
     CacheForDataLoaders,
-    DatasetExampleRevisionsDataLoader,
-    DatasetExampleSpansDataLoader,
     DocumentEvaluationsDataLoader,
     DocumentEvaluationSummaryDataLoader,
     DocumentRetrievalMetricsDataLoader,
     EvaluationSummaryDataLoader,
-    ExperimentAnnotationSummaryDataLoader,
-    ExperimentErrorRatesDataLoader,
-    ExperimentRunCountsDataLoader,
-    ExperimentSequenceNumberDataLoader,
     LatencyMsQuantileDataLoader,
     MinStartOrMaxEndTimeDataLoader,
-    ProjectByNameDataLoader,
     RecordCountDataLoader,
     SpanDescendantsDataLoader,
     SpanEvaluationsDataLoader,
-    SpanProjectsDataLoader,
     TokenCountDataLoader,
     TraceEvaluationsDataLoader,
-    TraceRowIdsDataLoader,
 )
 
 
 @dataclass
 class DataLoaders:
-    average_experiment_run_latency: AverageExperimentRunLatencyDataLoader
-    dataset_example_revisions: DatasetExampleRevisionsDataLoader
-    dataset_example_spans: DatasetExampleSpansDataLoader
     document_evaluation_summaries: DocumentEvaluationSummaryDataLoader
     document_evaluations: DocumentEvaluationsDataLoader
     document_retrieval_metrics: DocumentRetrievalMetricsDataLoader
     evaluation_summaries: EvaluationSummaryDataLoader
-    experiment_annotation_summaries: ExperimentAnnotationSummaryDataLoader
-    experiment_error_rates: ExperimentErrorRatesDataLoader
-    experiment_run_counts: ExperimentRunCountsDataLoader
-    experiment_sequence_number: ExperimentSequenceNumberDataLoader
     latency_ms_quantile: LatencyMsQuantileDataLoader
     min_start_or_max_end_times: MinStartOrMaxEndTimeDataLoader
     record_counts: RecordCountDataLoader
     span_descendants: SpanDescendantsDataLoader
     span_evaluations: SpanEvaluationsDataLoader
-    span_projects: SpanProjectsDataLoader
     token_counts: TokenCountDataLoader
     trace_evaluations: TraceEvaluationsDataLoader
-    trace_row_ids: TraceRowIdsDataLoader
-    project_by_name: ProjectByNameDataLoader
 
 
 ProjectRowId: TypeAlias = int

phoenix/server/api/dataloaders/__init__.py

@@ -8,9 +8,6 @@ from phoenix.db.insertion.evaluation import (
 )
 from phoenix.db.insertion.span import ClearProjectSpansEvent, SpanInsertionEvent
 
-from .average_experiment_run_latency import AverageExperimentRunLatencyDataLoader
-from .dataset_example_revisions import DatasetExampleRevisionsDataLoader
-from .dataset_example_spans import DatasetExampleSpansDataLoader
 from .document_evaluation_summaries import (
     DocumentEvaluationSummaryCache,
     DocumentEvaluationSummaryDataLoader,
@@ -18,44 +15,27 @@ from .document_evaluation_summaries import (
 from .document_evaluations import DocumentEvaluationsDataLoader
 from .document_retrieval_metrics import DocumentRetrievalMetricsDataLoader
 from .evaluation_summaries import EvaluationSummaryCache, EvaluationSummaryDataLoader
-from .experiment_annotation_summaries import ExperimentAnnotationSummaryDataLoader
-from .experiment_error_rates import ExperimentErrorRatesDataLoader
-from .experiment_run_counts import ExperimentRunCountsDataLoader
-from .experiment_sequence_number import ExperimentSequenceNumberDataLoader
 from .latency_ms_quantile import LatencyMsQuantileCache, LatencyMsQuantileDataLoader
 from .min_start_or_max_end_times import MinStartOrMaxEndTimeCache, MinStartOrMaxEndTimeDataLoader
-from .project_by_name import ProjectByNameDataLoader
 from .record_counts import RecordCountCache, RecordCountDataLoader
 from .span_descendants import SpanDescendantsDataLoader
 from .span_evaluations import SpanEvaluationsDataLoader
-from .span_projects import SpanProjectsDataLoader
 from .token_counts import TokenCountCache, TokenCountDataLoader
 from .trace_evaluations import TraceEvaluationsDataLoader
-from .trace_row_ids import TraceRowIdsDataLoader
 
 __all__ = [
     "CacheForDataLoaders",
-    "AverageExperimentRunLatencyDataLoader",
-    "DatasetExampleRevisionsDataLoader",
-    "DatasetExampleSpansDataLoader",
     "DocumentEvaluationSummaryDataLoader",
     "DocumentEvaluationsDataLoader",
     "DocumentRetrievalMetricsDataLoader",
     "EvaluationSummaryDataLoader",
-    "ExperimentAnnotationSummaryDataLoader",
-    "ExperimentErrorRatesDataLoader",
-    "ExperimentRunCountsDataLoader",
-    "ExperimentSequenceNumberDataLoader",
     "LatencyMsQuantileDataLoader",
     "MinStartOrMaxEndTimeDataLoader",
     "RecordCountDataLoader",
     "SpanDescendantsDataLoader",
     "SpanEvaluationsDataLoader",
-    "SpanProjectsDataLoader",
     "TokenCountDataLoader",
     "TraceEvaluationsDataLoader",
-    "TraceRowIdsDataLoader",
-    "ProjectByNameDataLoader",
 ]
 
 

phoenix/server/api/dataloaders/span_descendants.py

@@ -9,7 +9,7 @@ from typing import (
 from aioitertools.itertools import groupby
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import joinedload
+from sqlalchemy.orm import contains_eager
 from strawberry.dataloader import DataLoader
 from typing_extensions import TypeAlias
 
@@ -52,7 +52,8 @@ class SpanDescendantsDataLoader(DataLoader[Key, Result]):
         stmt = (
             select(descendant_ids.c[root_id_label], models.Span)
             .join(descendant_ids, models.Span.id == descendant_ids.c.id)
-            .options(joinedload(models.Span.trace, innerjoin=True).load_only(models.Trace.trace_id))
+            .join(models.Trace)
+            .options(contains_eager(models.Span.trace))
             .order_by(descendant_ids.c[root_id_label])
         )
         results: Dict[SpanId, Result] = {key: [] for key in keys}

phoenix/server/api/routers/v1/__init__.py

@@ -1,40 +1,6 @@
-from typing import Any, Awaitable, Callable, Mapping, Tuple
-
-import wrapt
-from starlette import routing
-from starlette.requests import Request
-from starlette.responses import Response
-from starlette.status import HTTP_403_FORBIDDEN
-
-from . import (
-    datasets,
-    evaluations,
-    experiment_evaluations,
-    experiment_runs,
-    experiments,
-    spans,
-    traces,
-)
-from .dataset_examples import list_dataset_examples
-
-
-@wrapt.decorator  # type: ignore
-async def forbid_if_readonly(
-    wrapped: Callable[[Request], Awaitable[Response]],
-    _: Any,
-    args: Tuple[Request],
-    kwargs: Mapping[str, Any],
-) -> Response:
-    request, *_ = args
-    if request.app.state.read_only:
-        return Response(status_code=HTTP_403_FORBIDDEN)
-    return await wrapped(*args, **kwargs)
-
-
-class Route(routing.Route):
-    def __init__(self, path: str, endpoint: Callable[..., Any], **kwargs: Any) -> None:
-        super().__init__(path, forbid_if_readonly(endpoint), **kwargs)
+from starlette.routing import Route
 
+from . import evaluations, spans, traces
 
 V1_ROUTES = [
     Route("/v1/evaluations", evaluations.post_evaluations, methods=["POST"]),
@@ -42,45 +8,4 @@ V1_ROUTES = [
     Route("/v1/traces", traces.post_traces, methods=["POST"]),
     Route("/v1/spans", spans.query_spans_handler, methods=["POST"]),
     Route("/v1/spans", spans.get_spans_handler, methods=["GET"]),
-    Route("/v1/datasets/upload", datasets.post_datasets_upload, methods=["POST"]),
-    Route("/v1/datasets", datasets.list_datasets, methods=["GET"]),
-    Route("/v1/datasets/{id:str}", datasets.get_dataset_by_id, methods=["GET"]),
-    Route("/v1/datasets/{id:str}/csv", datasets.get_dataset_csv, methods=["GET"]),
-    Route(
-        "/v1/datasets/{id:str}/jsonl/openai_ft",
-        datasets.get_dataset_jsonl_openai_ft,
-        methods=["GET"],
-    ),
-    Route(
-        "/v1/datasets/{id:str}/jsonl/openai_evals",
-        datasets.get_dataset_jsonl_openai_evals,
-        methods=["GET"],
-    ),
-    Route("/v1/datasets/{id:str}/examples", list_dataset_examples, methods=["GET"]),
-    Route("/v1/datasets/{id:str}/versions", datasets.get_dataset_versions, methods=["GET"]),
-    Route(
-        "/v1/datasets/{dataset_id:str}/experiments",
-        experiments.create_experiment,
-        methods=["POST"],
-    ),
-    Route(
-        "/v1/experiments/{experiment_id:str}",
-        experiments.read_experiment,
-        methods=["GET"],
-    ),
-    Route(
-        "/v1/experiments/{experiment_id:str}/runs",
-        experiment_runs.create_experiment_run,
-        methods=["POST"],
-    ),
-    Route(
-        "/v1/experiments/{experiment_id:str}/runs",
-        experiment_runs.list_experiment_runs,
-        methods=["GET"],
-    ),
-    Route(
-        "/v1/experiment_evaluations",
-        experiment_evaluations.upsert_experiment_evaluation,
-        methods=["POST"],
-    ),
 ]

phoenix/server/api/routers/v1/evaluations.py

@@ -44,7 +44,14 @@ async def post_evaluations(request: Request) -> Response:
     summary: Add evaluations to a span, trace, or document
     operationId: addEvaluations
     tags:
-      - private
+      - evaluations
+    parameters:
+      - name: project-name
+        in: query
+        schema:
+          type: string
+          default: default
+        description: The project name to add the evaluation to
     requestBody:
       required: true
       content:
@@ -98,9 +105,9 @@ async def get_evaluations(request: Request) -> Response:
     summary: Get evaluations from Phoenix
     operationId: getEvaluation
     tags:
-      - private
+      - evaluations
     parameters:
-      - name: project_name
+      - name: project-name
         in: query
         schema:
           type: string
@@ -109,15 +116,13 @@ async def get_evaluations(request: Request) -> Response:
     responses:
       200:
         description: Success
-      403:
-        description: Forbidden
       404:
         description: Not found
     """
     project_name = (
-        request.query_params.get("project_name")
-        or request.query_params.get("project-name")  # for backward compatibility
-        or request.headers.get("project-name")  # read from headers for backwards compatibility
+        request.query_params.get("project-name")
+        # read from headers for backwards compatibility
+        or request.headers.get("project-name")
         or DEFAULT_PROJECT_NAME
     )
 

phoenix/server/api/routers/v1/spans.py

@@ -19,9 +19,9 @@ async def query_spans_handler(request: Request) -> Response:
     summary: Query spans using query DSL
     operationId: querySpans
     tags:
-      - private
+      - spans
     parameters:
-      - name: project_name
+      - name: project-name
         in: query
         schema:
           type: string
@@ -68,8 +68,6 @@ async def query_spans_handler(request: Request) -> Response:
     responses:
       200:
         description: Success
-      403:
-        description: Forbidden
       404:
         description: Not found
       422:
@@ -78,11 +76,9 @@ async def query_spans_handler(request: Request) -> Response:
     payload = await request.json()
     queries = payload.pop("queries", [])
     project_name = (
-        request.query_params.get("project_name")
-        or request.query_params.get("project-name")  # for backward compatibility
-        or request.headers.get(
-            "project-name"
-        )  # read from headers/payload for backward-compatibility
+        request.query_params.get("project-name")
+        # read from headers/payload for backward-compatibility
+        or request.headers.get("project-name")
         or payload.get("project_name")
         or DEFAULT_PROJECT_NAME
     )

phoenix/server/api/routers/v1/traces.py

@@ -11,6 +11,7 @@ from starlette.datastructures import State
 from starlette.requests import Request
 from starlette.responses import Response
 from starlette.status import (
+    HTTP_403_FORBIDDEN,
     HTTP_415_UNSUPPORTED_MEDIA_TYPE,
     HTTP_422_UNPROCESSABLE_ENTITY,
 )
@@ -24,7 +25,7 @@ async def post_traces(request: Request) -> Response:
     summary: Send traces to Phoenix
     operationId: addTraces
     tags:
-      - private
+      - traces
     requestBody:
       required: true
       content:
@@ -42,6 +43,8 @@ async def post_traces(request: Request) -> Response:
       422:
         description: Request body is invalid
     """
+    if request.app.state.read_only:
+        return Response(status_code=HTTP_403_FORBIDDEN)
     content_type = request.headers.get("content-type")
     if content_type != "application/x-protobuf":
         return Response(

phoenix/server/api/schema.py

@@ -1,7 +1,308 @@
+from collections import defaultdict
+from typing import Dict, List, Optional, Set, Union
+
+import numpy as np
+import numpy.typing as npt
 import strawberry
+from sqlalchemy import delete, select
+from sqlalchemy.orm import contains_eager, load_only
+from strawberry import ID, UNSET
+from strawberry.types import Info
+from typing_extensions import Annotated
+
+from phoenix.config import DEFAULT_PROJECT_NAME
+from phoenix.db import models
+from phoenix.db.insertion.span import ClearProjectSpansEvent
+from phoenix.pointcloud.clustering import Hdbscan
+from phoenix.server.api.context import Context
+from phoenix.server.api.helpers import ensure_list
+from phoenix.server.api.input_types.ClusterInput import ClusterInput
+from phoenix.server.api.input_types.Coordinates import (
+    InputCoordinate2D,
+    InputCoordinate3D,
+)
+from phoenix.server.api.types.Cluster import Cluster, to_gql_clusters
+from phoenix.server.api.types.DatasetRole import AncillaryDatasetRole, DatasetRole
+from phoenix.server.api.types.Dimension import to_gql_dimension
+from phoenix.server.api.types.EmbeddingDimension import (
+    DEFAULT_CLUSTER_SELECTION_EPSILON,
+    DEFAULT_MIN_CLUSTER_SIZE,
+    DEFAULT_MIN_SAMPLES,
+    to_gql_embedding_dimension,
+)
+from phoenix.server.api.types.Event import create_event_id, unpack_event_id
+from phoenix.server.api.types.ExportEventsMutation import ExportEventsMutation
+from phoenix.server.api.types.Functionality import Functionality
+from phoenix.server.api.types.Model import Model
+from phoenix.server.api.types.node import (
+    GlobalID,
+    Node,
+    from_global_id,
+    from_global_id_with_expected_type,
+)
+from phoenix.server.api.types.pagination import (
+    Connection,
+    ConnectionArgs,
+    CursorString,
+    connection_from_list,
+)
+from phoenix.server.api.types.Project import Project
+from phoenix.server.api.types.Span import to_gql_span
+from phoenix.server.api.types.Trace import Trace
+
+
+@strawberry.type
+class Query:
+    @strawberry.field
+    async def projects(
+        self,
+        info: Info[Context, None],
+        first: Optional[int] = 50,
+        last: Optional[int] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
+    ) -> Connection[Project]:
+        args = ConnectionArgs(
+            first=first,
+            after=after if isinstance(after, CursorString) else None,
+            last=last,
+            before=before if isinstance(before, CursorString) else None,
+        )
+        async with info.context.db() as session:
+            projects = await session.scalars(select(models.Project))
+        data = [
+            Project(
+                id_attr=project.id,
+                name=project.name,
+                gradient_start_color=project.gradient_start_color,
+                gradient_end_color=project.gradient_end_color,
+            )
+            for project in projects
+        ]
+        return connection_from_list(data=data, args=args)
+
+    @strawberry.field
+    async def functionality(self, info: Info[Context, None]) -> "Functionality":
+        has_model_inferences = not info.context.model.is_empty
+        async with info.context.db() as session:
+            has_traces = (await session.scalar(select(models.Trace).limit(1))) is not None
+        return Functionality(
+            model_inferences=has_model_inferences,
+            tracing=has_traces,
+        )
+
+    @strawberry.field
+    def model(self) -> Model:
+        return Model()
+
+    @strawberry.field
+    async def node(self, id: GlobalID, info: Info[Context, None]) -> Node:
+        type_name, node_id = from_global_id(str(id))
+        if type_name == "Dimension":
+            dimension = info.context.model.scalar_dimensions[node_id]
+            return to_gql_dimension(node_id, dimension)
+        elif type_name == "EmbeddingDimension":
+            embedding_dimension = info.context.model.embedding_dimensions[node_id]
+            return to_gql_embedding_dimension(node_id, embedding_dimension)
+        elif type_name == "Project":
+            project_stmt = select(
+                models.Project.id,
+                models.Project.name,
+                models.Project.gradient_start_color,
+                models.Project.gradient_end_color,
+            ).where(models.Project.id == node_id)
+            async with info.context.db() as session:
+                project = (await session.execute(project_stmt)).first()
+            if project is None:
+                raise ValueError(f"Unknown project: {id}")
+            return Project(
+                id_attr=project.id,
+                name=project.name,
+                gradient_start_color=project.gradient_start_color,
+                gradient_end_color=project.gradient_end_color,
+            )
+        elif type_name == "Trace":
+            trace_stmt = select(models.Trace.id).where(models.Trace.id == node_id)
+            async with info.context.db() as session:
+                id_attr = await session.scalar(trace_stmt)
+            if id_attr is None:
+                raise ValueError(f"Unknown trace: {id}")
+            return Trace(id_attr=id_attr)
+        elif type_name == "Span":
+            span_stmt = (
+                select(models.Span)
+                .join(models.Trace)
+                .options(contains_eager(models.Span.trace))
+                .where(models.Span.id == node_id)
+            )
+            async with info.context.db() as session:
+                span = await session.scalar(span_stmt)
+            if span is None:
+                raise ValueError(f"Unknown span: {id}")
+            return to_gql_span(span)
+        raise Exception(f"Unknown node type: {type_name}")
+
+    @strawberry.field
+    def clusters(
+        self,
+        clusters: List[ClusterInput],
+    ) -> List[Cluster]:
+        clustered_events: Dict[str, Set[ID]] = defaultdict(set)
+        for i, cluster in enumerate(clusters):
+            clustered_events[cluster.id or str(i)].update(cluster.event_ids)
+        return to_gql_clusters(
+            clustered_events=clustered_events,
+        )
+
+    @strawberry.field
+    def hdbscan_clustering(
+        self,
+        info: Info[Context, None],
+        event_ids: Annotated[
+            List[ID],
+            strawberry.argument(
+                description="Event ID of the coordinates",
+            ),
+        ],
+        coordinates_2d: Annotated[
+            Optional[List[InputCoordinate2D]],
+            strawberry.argument(
+                description="Point coordinates. Must be either 2D or 3D.",
+            ),
+        ] = UNSET,
+        coordinates_3d: Annotated[
+            Optional[List[InputCoordinate3D]],
+            strawberry.argument(
+                description="Point coordinates. Must be either 2D or 3D.",
+            ),
+        ] = UNSET,
+        min_cluster_size: Annotated[
+            int,
+            strawberry.argument(
+                description="HDBSCAN minimum cluster size",
+            ),
+        ] = DEFAULT_MIN_CLUSTER_SIZE,
+        cluster_min_samples: Annotated[
+            int,
+            strawberry.argument(
+                description="HDBSCAN minimum samples",
+            ),
+        ] = DEFAULT_MIN_SAMPLES,
+        cluster_selection_epsilon: Annotated[
+            float,
+            strawberry.argument(
+                description="HDBSCAN cluster selection epsilon",
+            ),
+        ] = DEFAULT_CLUSTER_SELECTION_EPSILON,
+    ) -> List[Cluster]:
+        coordinates_3d = ensure_list(coordinates_3d)
+        coordinates_2d = ensure_list(coordinates_2d)
+
+        if len(coordinates_3d) > 0 and len(coordinates_2d) > 0:
+            raise ValueError("must specify only one of 2D or 3D coordinates")
+
+        if len(coordinates_3d) > 0:
+            coordinates = list(
+                map(
+                    lambda coord: np.array(
+                        [coord.x, coord.y, coord.z],
+                    ),
+                    coordinates_3d,
+                )
+            )
+        else:
+            coordinates = list(
+                map(
+                    lambda coord: np.array(
+                        [coord.x, coord.y],
+                    ),
+                    coordinates_2d,
+                )
+            )
+
+        if len(event_ids) != len(coordinates):
+            raise ValueError(
+                f"length mismatch between "
+                f"event_ids ({len(event_ids)}) "
+                f"and coordinates ({len(coordinates)})"
+            )
+
+        if len(event_ids) == 0:
+            return []
+
+        grouped_event_ids: Dict[
+            Union[DatasetRole, AncillaryDatasetRole],
+            List[ID],
+        ] = defaultdict(list)
+        grouped_coordinates: Dict[
+            Union[DatasetRole, AncillaryDatasetRole],
+            List[npt.NDArray[np.float64]],
+        ] = defaultdict(list)
+
+        for event_id, coordinate in zip(event_ids, coordinates):
+            row_id, dataset_role = unpack_event_id(event_id)
+            grouped_coordinates[dataset_role].append(coordinate)
+            grouped_event_ids[dataset_role].append(create_event_id(row_id, dataset_role))
+
+        stacked_event_ids = (
+            grouped_event_ids[DatasetRole.primary]
+            + grouped_event_ids[DatasetRole.reference]
+            + grouped_event_ids[AncillaryDatasetRole.corpus]
+        )
+        stacked_coordinates = np.stack(
+            grouped_coordinates[DatasetRole.primary]
+            + grouped_coordinates[DatasetRole.reference]
+            + grouped_coordinates[AncillaryDatasetRole.corpus]
+        )
+
+        clusters = Hdbscan(
+            min_cluster_size=min_cluster_size,
+            min_samples=cluster_min_samples,
+            cluster_selection_epsilon=cluster_selection_epsilon,
+        ).find_clusters(stacked_coordinates)
+
+        clustered_events = {
+            str(i): {stacked_event_ids[row_idx] for row_idx in cluster}
+            for i, cluster in enumerate(clusters)
+        }
+
+        return to_gql_clusters(
+            clustered_events=clustered_events,
+        )
+
+
+@strawberry.type
+class Mutation(ExportEventsMutation):
+    @strawberry.mutation
+    async def delete_project(self, info: Info[Context, None], id: GlobalID) -> Query:
+        if info.context.read_only:
+            return Query()
+        node_id = from_global_id_with_expected_type(str(id), "Project")
+        async with info.context.db() as session:
+            project = await session.scalar(
+                select(models.Project)
+                .where(models.Project.id == node_id)
+                .options(load_only(models.Project.name))
+            )
+            if project is None:
+                raise ValueError(f"Unknown project: {id}")
+            if project.name == DEFAULT_PROJECT_NAME:
+                raise ValueError(f"Cannot delete the {DEFAULT_PROJECT_NAME} project")
+            await session.delete(project)
+        return Query()
+
+    @strawberry.mutation
+    async def clear_project(self, info: Info[Context, None], id: GlobalID) -> Query:
+        if info.context.read_only:
+            return Query()
+        project_id = from_global_id_with_expected_type(str(id), "Project")
+        delete_statement = delete(models.Trace).where(models.Trace.project_rowid == project_id)
+        async with info.context.db() as session:
+            await session.execute(delete_statement)
+            if cache := info.context.cache_for_dataloaders:
+                cache.invalidate(ClearProjectSpansEvent(project_rowid=project_id))
+        return Query()
 
-from phoenix.server.api.mutations import Mutation
-from phoenix.server.api.queries import Query
 
 # This is the schema for generating `schema.graphql`.
 # See https://strawberry.rocks/docs/guides/schema-export