arize-phoenix 4.19.0__tar.gz → 4.20.0__tar.gz

{arize_phoenix-4.19.0 → arize_phoenix-4.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.19.0
+Version: 4.20.0
 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.19.0 → arize_phoenix-4.20.0}/src/phoenix/server/api/dataloaders/span_annotations.py

@@ -8,12 +8,11 @@ from sqlalchemy import select
 from strawberry.dataloader import DataLoader
 from typing_extensions import TypeAlias
 
-from phoenix.db import models
-from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
+from phoenix.db.models import SpanAnnotation as ORMSpanAnnotation
 from phoenix.server.types import DbSessionFactory
 
 Key: TypeAlias = int
-Result: TypeAlias = List[SpanAnnotation]
+Result: TypeAlias = List[ORMSpanAnnotation]
 
 
 class SpanAnnotationsDataLoader(DataLoader[Key, Result]):
@@ -23,11 +22,9 @@ class SpanAnnotationsDataLoader(DataLoader[Key, Result]):
 
     async def _load_fn(self, keys: List[Key]) -> List[Result]:
         span_annotations_by_id: DefaultDict[Key, Result] = defaultdict(list)
-        msa = models.SpanAnnotation
         async with self._db() as session:
-            data = await session.stream_scalars(select(msa).where(msa.span_rowid.in_(keys)))
-            async for span_annotation in data:
-                span_annotations_by_id[span_annotation.span_rowid].append(
-                    to_gql_span_annotation(span_annotation)
-                )
+            async for span_annotation in await session.stream_scalars(
+                select(ORMSpanAnnotation).where(ORMSpanAnnotation.span_rowid.in_(keys))
+            ):
+                span_annotations_by_id[span_annotation.span_rowid].append(span_annotation)
         return [span_annotations_by_id[key] for key in keys]

{arize_phoenix-4.19.0 → arize_phoenix-4.20.0}/src/phoenix/server/api/mutations/dataset_mutations.py

@@ -154,6 +154,36 @@ class DatasetMutationMixin:
                 raise ValueError(
                     f"Could not find spans with rowids: {', '.join(map(str, missing_span_rowids))}"
                 )  # todo: implement error handling types https://github.com/Arize-ai/phoenix/issues/3221
+
+            span_annotations = (
+                await session.execute(
+                    select(
+                        models.SpanAnnotation.span_rowid,
+                        models.SpanAnnotation.name,
+                        models.SpanAnnotation.label,
+                        models.SpanAnnotation.score,
+                        models.SpanAnnotation.explanation,
+                        models.SpanAnnotation.metadata_,
+                        models.SpanAnnotation.annotator_kind,
+                    )
+                    .select_from(models.SpanAnnotation)
+                    .where(models.SpanAnnotation.span_rowid.in_(span_rowids))
+                )
+            ).all()
+
+            span_annotations_by_span: Dict[int, Dict[Any, Any]] = {span.id: {} for span in spans}
+            for annotation in span_annotations:
+                span_id = annotation.span_rowid
+                if span_id not in span_annotations_by_span:
+                    span_annotations_by_span[span_id] = dict()
+                span_annotations_by_span[span_id][annotation.name] = {
+                    "label": annotation.label,
+                    "score": annotation.score,
+                    "explanation": annotation.explanation,
+                    "metadata": annotation.metadata_,
+                    "annotator_kind": annotation.annotator_kind,
+                }
+
             DatasetExample = models.DatasetExample
             dataset_example_rowids = (
                 await session.scalars(
@@ -170,6 +200,7 @@ class DatasetMutationMixin:
             assert len(dataset_example_rowids) == len(spans)
             assert all(map(lambda id: isinstance(id, int), dataset_example_rowids))
             DatasetExampleRevision = models.DatasetExampleRevision
+
             await session.execute(
                 insert(DatasetExampleRevision),
                 [
@@ -178,7 +209,10 @@ class DatasetMutationMixin:
                         DatasetExampleRevision.dataset_version_id.key: dataset_version_rowid,
                         DatasetExampleRevision.input.key: get_dataset_example_input(span),
                         DatasetExampleRevision.output.key: get_dataset_example_output(span),
-                        DatasetExampleRevision.metadata_.key: span.attributes,
+                        DatasetExampleRevision.metadata_.key: {
+                            **span.attributes,
+                            "annotations": span_annotations_by_span[span.id],
+                        },
                         DatasetExampleRevision.revision_kind.key: "CREATE",
                     }
                     for dataset_example_rowid, span in zip(dataset_example_rowids, spans)

{arize_phoenix-4.19.0 → arize_phoenix-4.20.0}/src/phoenix/server/api/routers/v1/spans.py

@@ -23,7 +23,7 @@ from .utils import RequestBody, ResponseBody, add_errors_to_responses
 
 DEFAULT_SPAN_LIMIT = 1000
 
-router = APIRouter(tags=["traces"], include_in_schema=False)
+router = APIRouter(tags=["spans"])
 
 
 class SpanQuery(V1RoutesBaseModel):
@@ -65,6 +65,7 @@ class QuerySpansRequestBody(V1RoutesBaseModel):
     operation_id="querySpans",
     summary="Query spans with query DSL",
     responses=add_errors_to_responses([HTTP_404_NOT_FOUND, HTTP_422_UNPROCESSABLE_ENTITY]),
+    include_in_schema=False,
 )
 async def query_spans_handler(
     request: Request,
@@ -189,6 +190,7 @@ class AnnotateSpansResponseBody(ResponseBody[List[InsertedSpanAnnotation]]):
         [{"status_code": HTTP_404_NOT_FOUND, "description": "Span not found"}]
     ),
     response_description="Span annotations inserted successfully",
+    include_in_schema=True,
 )
 async def annotate_spans(
     request: Request,

{arize_phoenix-4.19.0 → arize_phoenix-4.20.0}/src/phoenix/server/api/routers/v1/traces.py

@@ -30,7 +30,7 @@ from phoenix.utilities.project import get_project_name
 from .pydantic_compat import V1RoutesBaseModel
 from .utils import RequestBody, ResponseBody, add_errors_to_responses
 
-router = APIRouter(tags=["traces"], include_in_schema=False)
+router = APIRouter(tags=["traces"])
 
 
 @router.post(
@@ -57,6 +57,7 @@ router = APIRouter(tags=["traces"], include_in_schema=False)
             },
         }
     },
+    include_in_schema=False,
 )
 async def post_traces(
     request: Request,
@@ -145,6 +146,7 @@ class AnnotateTracesResponseBody(ResponseBody[List[InsertedTraceAnnotation]]):
     responses=add_errors_to_responses(
         [{"status_code": HTTP_404_NOT_FOUND, "description": "Trace not found"}]
     ),
+    include_in_schema=False,
 )
 async def annotate_traces(
     request: Request,

{arize_phoenix-4.19.0 → arize_phoenix-4.20.0}/src/phoenix/server/api/types/Span.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, Any, List, Mapping, Optional, Sized, cast
 import numpy as np
 import strawberry
 from openinference.semconv.trace import EmbeddingAttributes, SpanAttributes
-from sqlalchemy import select
 from strawberry import ID, UNSET
 from strawberry.relay import Node, NodeID
 from strawberry.types import Info
@@ -20,7 +19,10 @@ from phoenix.server.api.helpers.dataset_helpers import (
     get_dataset_example_input,
     get_dataset_example_output,
 )
-from phoenix.server.api.input_types.SpanAnnotationSort import SpanAnnotationSort
+from phoenix.server.api.input_types.SpanAnnotationSort import (
+    SpanAnnotationColumn,
+    SpanAnnotationSort,
+)
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.SpanAnnotation import to_gql_span_annotation
 from phoenix.trace.attributes import get_attribute_value
@@ -190,17 +192,16 @@ class Span(Node):
         info: Info[Context, None],
         sort: Optional[SpanAnnotationSort] = UNSET,
     ) -> List[SpanAnnotation]:
-        async with info.context.db() as session:
-            stmt = select(models.SpanAnnotation).filter_by(span_rowid=self.id_attr)
-            if sort:
-                sort_col = getattr(models.SpanAnnotation, sort.col.value)
-                if sort.dir is SortDir.desc:
-                    stmt = stmt.order_by(sort_col.desc(), models.SpanAnnotation.id.desc())
-                else:
-                    stmt = stmt.order_by(sort_col.asc(), models.SpanAnnotation.id.asc())
-            else:
-                stmt = stmt.order_by(models.SpanAnnotation.created_at.desc())
-            annotations = await session.scalars(stmt)
+        span_id = self.id_attr
+        annotations = await info.context.data_loaders.span_annotations.load(span_id)
+        sort_key = SpanAnnotationColumn.createdAt.value
+        sort_descending = True
+        if sort:
+            sort_key = sort.col.value
+            sort_descending = sort.dir is SortDir.desc
+        annotations.sort(
+            key=lambda annotation: getattr(annotation, sort_key), reverse=sort_descending
+        )
         return [to_gql_span_annotation(annotation) for annotation in annotations]
 
     @strawberry.field(

{arize_phoenix-4.19.0 → arize_phoenix-4.20.0}/src/phoenix/session/client.py

@@ -324,7 +324,7 @@ class Client(TraceDataExtractor):
              Dataset: The dataset object.
         """
         response = self._client.get(
-            urljoin(self._base_url, "/v1/datasets"),
+            urljoin(self._base_url, "v1/datasets"),
             params={"name": name},
         )
         response.raise_for_status()
@@ -366,7 +366,7 @@ class Client(TraceDataExtractor):
             raise ValueError("Dataset id or name must be provided.")
 
         response = self._client.get(
-            urljoin(self._base_url, f"/v1/datasets/{quote(id)}/examples"),
+            urljoin(self._base_url, f"v1/datasets/{quote(id)}/examples"),
             params={"version_id": version_id} if version_id else None,
         )
         response.raise_for_status()

arize_phoenix-4.20.0/src/phoenix/version.py

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

arize_phoenix-4.19.0/src/phoenix/version.py

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

{arize_phoenix-4.19.0 → arize_phoenix-4.20.0}/src/phoenix/server/api/context.py

@@ -54,6 +54,7 @@ class DataLoaders:
     latency_ms_quantile: LatencyMsQuantileDataLoader
     min_start_or_max_end_times: MinStartOrMaxEndTimeDataLoader
     record_counts: RecordCountDataLoader
+    span_annotations: SpanAnnotationsDataLoader
     span_dataset_examples: SpanDatasetExamplesDataLoader
     span_descendants: SpanDescendantsDataLoader
     span_evaluations: SpanEvaluationsDataLoader
@@ -62,7 +63,6 @@ class DataLoaders:
     trace_evaluations: TraceEvaluationsDataLoader
     trace_row_ids: TraceRowIdsDataLoader
     project_by_name: ProjectByNameDataLoader
-    span_annotations: SpanAnnotationsDataLoader
 
 
 ProjectRowId: TypeAlias = int