arize-phoenix 4.8.1__tar.gz → 4.10.0__tar.gz

{arize_phoenix-4.8.1 → arize_phoenix-4.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arize-phoenix
-Version: 4.8.1
+Version: 4.10.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.8.1 → arize_phoenix-4.10.0}/pyproject.toml

@@ -403,3 +403,6 @@ select = ["E", "F", "W", "I", "NPY201"]
 
 [tool.ruff.lint.isort]
 force-single-line = false
+
+[tool.ruff.format]
+line-ending = "lf"

{arize_phoenix-4.8.1 → arize_phoenix-4.10.0}/src/phoenix/db/insertion/evaluation.py

@@ -6,7 +6,7 @@ from typing_extensions import assert_never
 
 from phoenix.db import models
 from phoenix.db.helpers import SupportedSQLDialect, num_docs_col
-from phoenix.db.insertion.helpers import OnConflict, insert_on_conflict
+from phoenix.db.insertion.helpers import insert_on_conflict
 from phoenix.exceptions import PhoenixException
 from phoenix.trace import v1 as pb
 
@@ -87,18 +87,12 @@ async def _insert_trace_evaluation(
         metadata_={},  # `metadata_` must match ORM
         annotator_kind="LLM",
     )
-    set_ = dict(values)
-    set_.pop("metadata_")
-    set_["metadata"] = values["metadata_"]  # `metadata` must match database
     await session.execute(
         insert_on_conflict(
+            values,
             dialect=dialect,
             table=models.TraceAnnotation,
-            values=values,
-            constraint="uq_trace_annotations_name_trace_rowid",
-            column_names=("name", "trace_rowid"),
-            on_conflict=OnConflict.DO_UPDATE,
-            set_=set_,
+            unique_by=("name", "trace_rowid"),
         )
     )
     return TraceEvaluationInsertionEvent(project_rowid, evaluation_name)
@@ -135,18 +129,12 @@ async def _insert_span_evaluation(
         metadata_={},  # `metadata_` must match ORM
         annotator_kind="LLM",
     )
-    set_ = dict(values)
-    set_.pop("metadata_")
-    set_["metadata"] = values["metadata_"]  # `metadata` must match database
     await session.execute(
         insert_on_conflict(
+            values,
             dialect=dialect,
             table=models.SpanAnnotation,
-            values=values,
-            constraint="uq_span_annotations_name_span_rowid",
-            column_names=("name", "span_rowid"),
-            on_conflict=OnConflict.DO_UPDATE,
-            set_=set_,
+            unique_by=("name", "span_rowid"),
         )
     )
     return SpanEvaluationInsertionEvent(project_rowid, evaluation_name)
@@ -192,18 +180,12 @@ async def _insert_document_evaluation(
         metadata_={},  # `metadata_` must match ORM
         annotator_kind="LLM",
     )
-    set_ = dict(values)
-    set_.pop("metadata_")
-    set_["metadata"] = values["metadata_"]  # `metadata` must match database
     await session.execute(
         insert_on_conflict(
+            values,
             dialect=dialect,
             table=models.DocumentAnnotation,
-            values=values,
-            constraint="uq_document_annotations_name_span_rowid_document_position",
-            column_names=("name", "span_rowid", "document_position"),
-            on_conflict=OnConflict.DO_UPDATE,
-            set_=set_,
+            unique_by=("name", "span_rowid", "document_position"),
         )
     )
     return DocumentEvaluationInsertionEvent(project_rowid, evaluation_name)

arize_phoenix-4.10.0/src/phoenix/db/insertion/helpers.py

@@ -0,0 +1,95 @@
+from abc import ABC
+from enum import Enum, auto
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Iterable,
+    Iterator,
+    Mapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+)
+
+from sqlalchemy import Insert
+from sqlalchemy.dialects.postgresql import insert as insert_postgresql
+from sqlalchemy.dialects.sqlite import insert as insert_sqlite
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.sql.elements import KeyedColumnElement
+from typing_extensions import TypeAlias, assert_never
+
+from phoenix.db.helpers import SupportedSQLDialect
+from phoenix.db.models import Base
+
+
+class DataManipulationEvent(ABC):
+    """
+    Execution of DML (Data Manipulation Language) statements.
+    """
+
+
+DataManipulation: TypeAlias = Callable[[AsyncSession], Awaitable[Optional[DataManipulationEvent]]]
+
+
+class OnConflict(Enum):
+    DO_NOTHING = auto()
+    DO_UPDATE = auto()
+
+
+def insert_on_conflict(
+    *records: Mapping[str, Any],
+    table: Type[Base],
+    dialect: SupportedSQLDialect,
+    unique_by: Sequence[str],
+    on_conflict: OnConflict = OnConflict.DO_UPDATE,
+    set_: Optional[Mapping[str, Any]] = None,
+) -> Insert:
+    """
+    Dialect specific insertion statement using ON CONFLICT DO syntax.
+    """
+    if on_conflict is OnConflict.DO_UPDATE:
+        # postegresql rejects duplicate updates for the same record
+        seen = set()
+        unique_records = []
+        for v in reversed(records):
+            if (k := tuple(v.get(name) for name in unique_by)) in seen:
+                continue
+            unique_records.append(v)
+            seen.add(k)
+        records = tuple(reversed(unique_records))
+    constraint = "_".join(("uq", table.__tablename__, *unique_by))
+    if dialect is SupportedSQLDialect.POSTGRESQL:
+        stmt_postgresql = insert_postgresql(table).values(records)
+        if on_conflict is OnConflict.DO_NOTHING:
+            return stmt_postgresql.on_conflict_do_nothing(constraint=constraint)
+        if on_conflict is OnConflict.DO_UPDATE:
+            return stmt_postgresql.on_conflict_do_update(
+                constraint=constraint,
+                set_=set_ if set_ else dict(_clean(stmt_postgresql.excluded.items())),
+            )
+        assert_never(on_conflict)
+    if dialect is SupportedSQLDialect.SQLITE:
+        stmt_sqlite = insert_sqlite(table).values(records)
+        if on_conflict is OnConflict.DO_NOTHING:
+            return stmt_sqlite.on_conflict_do_nothing(unique_by)
+        if on_conflict is OnConflict.DO_UPDATE:
+            return stmt_sqlite.on_conflict_do_update(
+                unique_by,
+                set_=set_ if set_ else dict(_clean(stmt_sqlite.excluded.items())),
+            )
+        assert_never(on_conflict)
+    assert_never(dialect)
+
+
+def _clean(
+    kv: Iterable[Tuple[str, KeyedColumnElement[Any]]],
+) -> Iterator[Tuple[str, KeyedColumnElement[Any]]]:
+    for k, v in kv:
+        if v.primary_key or v.foreign_keys or k == "created_at":
+            continue
+        if k == "metadata_":
+            yield "metadata", v
+        else:
+            yield k, v

{arize_phoenix-4.8.1 → arize_phoenix-4.10.0}/src/phoenix/db/insertion/span.py

@@ -26,17 +26,14 @@ async def insert_span(
     project_name: str,
 ) -> Optional[SpanInsertionEvent]:
     dialect = SupportedSQLDialect(session.bind.dialect.name)
-    project_rowid = await session.scalar(
-        insert_on_conflict(
-            dialect=dialect,
-            table=models.Project,
-            constraint="uq_projects_name",
-            column_names=("name",),
-            values=dict(name=project_name),
-            on_conflict=OnConflict.DO_UPDATE,
-            set_=dict(name=project_name),
-        ).returning(models.Project.id)
-    )
+    if (
+        project_rowid := await session.scalar(
+            select(models.Project.id).where(models.Project.name == project_name)
+        )
+    ) is None:
+        project_rowid = await session.scalar(
+            insert(models.Project).values(dict(name=project_name)).returning(models.Project.id)
+        )
     assert project_rowid is not None
     if trace := await session.scalar(
         select(models.Trace).where(models.Trace.trace_id == span.context.trace_id)
@@ -88,11 +85,7 @@ async def insert_span(
         cumulative_llm_token_count_completion += cast(int, accumulation[2] or 0)
     span_rowid = await session.scalar(
         insert_on_conflict(
-            dialect=dialect,
-            table=models.Span,
-            constraint="uq_spans_span_id",
-            column_names=("span_id",),
-            values=dict(
+            dict(
                 span_id=span.context.span_id,
                 trace_rowid=trace_rowid,
                 parent_id=span.parent_id,
@@ -108,6 +101,9 @@ async def insert_span(
                 cumulative_llm_token_count_prompt=cumulative_llm_token_count_prompt,
                 cumulative_llm_token_count_completion=cumulative_llm_token_count_completion,
             ),
+            dialect=dialect,
+            table=models.Span,
+            unique_by=("span_id",),
             on_conflict=OnConflict.DO_NOTHING,
         ).returning(models.Span.id)
     )

{arize_phoenix-4.8.1 → arize_phoenix-4.10.0}/src/phoenix/inferences/inferences.py

@@ -42,7 +42,13 @@ SchemaLike: TypeAlias = Any
 class Inferences:
     """
     A dataset to use for analysis using phoenix.
-    Used to construct a phoenix session via px.launch_app
+    Used to construct a phoenix session via px.launch_app.
+
+    Typical usage example::
+
+        primary_inferences = px.Inferences(
+            dataframe=production_dataframe, schema=schema, name="primary"
+        )
 
     Parameters
     ----------
@@ -62,9 +68,15 @@ class Inferences:
 
     Examples
     --------
-    >>> primary_inferences = px.Inferences(
-    >>>    dataframe=production_dataframe, schema=schema, name="primary"
-    >>> )
+    Define inferences ds from a pandas dataframe df and a schema object schema by running::
+
+        ds = px.Inferences(df, schema)
+
+    Alternatively, provide a name for the inferences that will appear in the application::
+
+        ds = px.Inferences(df, schema, name="training")
+
+    ds is then passed as the primary or reference argument to launch_app.
     """
 
     _data_file_name: str = "data.parquet"

{arize_phoenix-4.8.1 → arize_phoenix-4.10.0}/src/phoenix/pointcloud/umap_parameters.py

@@ -1,52 +1,52 @@
-from dataclasses import dataclass
-from typing import Any, Mapping, Optional
-
-DEFAULT_MIN_DIST = 0.0
-DEFAULT_N_NEIGHBORS = 30
-DEFAULT_N_SAMPLES = 500
-
-MIN_NEIGHBORS = 5
-MAX_NEIGHBORS = 100
-MIN_SAMPLES = 1
-MAX_SAMPLES = 1000
-MIN_MIN_DIST = 0.0
-MAX_MIN_DIST = 0.99
-
-
-@dataclass
-class UMAPParameters:
-    min_dist: float = DEFAULT_MIN_DIST
-    n_neighbors: int = DEFAULT_N_NEIGHBORS
-    n_samples: int = DEFAULT_N_SAMPLES
-
-    def __post_init__(self) -> None:
-        if not isinstance(self.min_dist, float) or not (
-            MIN_MIN_DIST <= self.min_dist <= MAX_MIN_DIST
-        ):
-            raise ValueError(
-                f"minDist must be float type, and between {MIN_MIN_DIST} and {MAX_MIN_DIST}"
-            )
-
-        if not isinstance(self.n_neighbors, int) or not (
-            MIN_NEIGHBORS <= self.n_neighbors <= MAX_NEIGHBORS
-        ):
-            raise ValueError(
-                f"nNeighbors must be int type, and between {MIN_NEIGHBORS} and {MAX_NEIGHBORS}"
-            )
-
-        if not isinstance(self.n_samples, int) or not (
-            MIN_SAMPLES <= self.n_samples <= MAX_SAMPLES
-        ):
-            raise ValueError(
-                f"nSamples must be int type, and between {MIN_SAMPLES} and {MAX_SAMPLES}"
-            )
-
-
-def get_umap_parameters(default_umap_parameters: Optional[Mapping[str, Any]]) -> UMAPParameters:
-    if not default_umap_parameters:
-        return UMAPParameters()
-    return UMAPParameters(
-        min_dist=float(default_umap_parameters.get("min_dist", DEFAULT_MIN_DIST)),
-        n_neighbors=int(default_umap_parameters.get("n_neighbors", DEFAULT_N_NEIGHBORS)),
-        n_samples=int(default_umap_parameters.get("n_samples", DEFAULT_N_SAMPLES)),
-    )
+from dataclasses import dataclass
+from typing import Any, Mapping, Optional
+
+DEFAULT_MIN_DIST = 0.0
+DEFAULT_N_NEIGHBORS = 30
+DEFAULT_N_SAMPLES = 500
+
+MIN_NEIGHBORS = 5
+MAX_NEIGHBORS = 100
+MIN_SAMPLES = 1
+MAX_SAMPLES = 1000
+MIN_MIN_DIST = 0.0
+MAX_MIN_DIST = 0.99
+
+
+@dataclass
+class UMAPParameters:
+    min_dist: float = DEFAULT_MIN_DIST
+    n_neighbors: int = DEFAULT_N_NEIGHBORS
+    n_samples: int = DEFAULT_N_SAMPLES
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.min_dist, float) or not (
+            MIN_MIN_DIST <= self.min_dist <= MAX_MIN_DIST
+        ):
+            raise ValueError(
+                f"minDist must be float type, and between {MIN_MIN_DIST} and {MAX_MIN_DIST}"
+            )
+
+        if not isinstance(self.n_neighbors, int) or not (
+            MIN_NEIGHBORS <= self.n_neighbors <= MAX_NEIGHBORS
+        ):
+            raise ValueError(
+                f"nNeighbors must be int type, and between {MIN_NEIGHBORS} and {MAX_NEIGHBORS}"
+            )
+
+        if not isinstance(self.n_samples, int) or not (
+            MIN_SAMPLES <= self.n_samples <= MAX_SAMPLES
+        ):
+            raise ValueError(
+                f"nSamples must be int type, and between {MIN_SAMPLES} and {MAX_SAMPLES}"
+            )
+
+
+def get_umap_parameters(default_umap_parameters: Optional[Mapping[str, Any]]) -> UMAPParameters:
+    if not default_umap_parameters:
+        return UMAPParameters()
+    return UMAPParameters(
+        min_dist=float(default_umap_parameters.get("min_dist", DEFAULT_MIN_DIST)),
+        n_neighbors=int(default_umap_parameters.get("n_neighbors", DEFAULT_N_NEIGHBORS)),
+        n_samples=int(default_umap_parameters.get("n_samples", DEFAULT_N_SAMPLES)),
+    )

arize_phoenix-4.10.0/src/phoenix/server/api/input_types/CreateSpanAnnotationsInput.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+import strawberry
+from strawberry.relay import GlobalID
+from strawberry.scalars import JSON
+
+
+@strawberry.input
+class CreateSpanAnnotationsInput:
+    span_id: GlobalID
+    name: str
+    annotator_kind: str
+    label: Optional[str] = None
+    score: Optional[float] = None
+    explanation: Optional[str] = None
+    metadata: JSON = strawberry.field(default_factory=dict)

arize_phoenix-4.10.0/src/phoenix/server/api/input_types/CreateTraceAnnotationsInput.py

@@ -0,0 +1,16 @@
+from typing import Optional
+
+import strawberry
+from strawberry.relay import GlobalID
+from strawberry.scalars import JSON
+
+
+@strawberry.input
+class CreateTraceAnnotationsInput:
+    trace_id: GlobalID
+    name: str
+    annotator_kind: str
+    label: Optional[str] = None
+    score: Optional[float] = None
+    explanation: Optional[str] = None
+    metadata: JSON = strawberry.field(default_factory=dict)

arize_phoenix-4.10.0/src/phoenix/server/api/input_types/DeleteAnnotationsInput.py

@@ -0,0 +1,9 @@
+from typing import List
+
+import strawberry
+from strawberry.relay import GlobalID
+
+
+@strawberry.input
+class DeleteAnnotationsInput:
+    annotation_ids: List[GlobalID]

arize_phoenix-4.10.0/src/phoenix/server/api/input_types/PatchAnnotationsInput.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+import strawberry
+from strawberry import UNSET
+from strawberry.relay import GlobalID
+from strawberry.scalars import JSON
+
+
+@strawberry.input
+class PatchAnnotationsInput:
+    annotation_id: GlobalID
+    name: Optional[str] = UNSET
+    annotator_kind: Optional[str] = UNSET
+    label: Optional[str] = UNSET
+    score: Optional[float] = UNSET
+    explanation: Optional[str] = UNSET
+    metadata: Optional[JSON] = UNSET

{arize_phoenix-4.8.1 → arize_phoenix-4.10.0}/src/phoenix/server/api/mutations/__init__.py

@@ -4,10 +4,17 @@ from phoenix.server.api.mutations.dataset_mutations import DatasetMutationMixin
 from phoenix.server.api.mutations.experiment_mutations import ExperimentMutationMixin
 from phoenix.server.api.mutations.export_events_mutations import ExportEventsMutationMixin
 from phoenix.server.api.mutations.project_mutations import ProjectMutationMixin
+from phoenix.server.api.mutations.span_annotations_mutations import SpanAnnotationMutationMixin
+from phoenix.server.api.mutations.trace_annotations_mutations import TraceAnnotationMutationMixin
 
 
 @strawberry.type
 class Mutation(
-    ProjectMutationMixin, DatasetMutationMixin, ExperimentMutationMixin, ExportEventsMutationMixin
+    ProjectMutationMixin,
+    DatasetMutationMixin,
+    ExperimentMutationMixin,
+    ExportEventsMutationMixin,
+    SpanAnnotationMutationMixin,
+    TraceAnnotationMutationMixin,
 ):
     pass

{arize_phoenix-4.8.1 → arize_phoenix-4.10.0}/src/phoenix/server/api/mutations/project_mutations.py

@@ -38,7 +38,7 @@ class ProjectMutationMixin:
             global_id=input.id, expected_type_name="Project"
         )
         delete_statement = delete(models.Trace).where(models.Trace.project_rowid == project_id)
-        if input.end_time is not None:
+        if input.end_time:
             delete_statement = delete_statement.where(models.Trace.start_time < input.end_time)
         async with info.context.db() as session:
             await session.execute(delete_statement)

arize_phoenix-4.10.0/src/phoenix/server/api/mutations/span_annotations_mutations.py

@@ -0,0 +1,108 @@
+from typing import List, Sequence
+
+import strawberry
+from sqlalchemy import delete, insert, update
+from strawberry import UNSET
+from strawberry.types import Info
+
+from phoenix.db import models
+from phoenix.server.api.context import Context
+from phoenix.server.api.input_types.CreateSpanAnnotationsInput import CreateSpanAnnotationsInput
+from phoenix.server.api.input_types.DeleteAnnotationsInput import DeleteAnnotationsInput
+from phoenix.server.api.input_types.PatchAnnotationsInput import PatchAnnotationsInput
+from phoenix.server.api.mutations.auth import IsAuthenticated
+from phoenix.server.api.types.node import from_global_id_with_expected_type
+from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
+
+
+@strawberry.type
+class SpanAnnotationMutationPayload:
+    span_annotations: List[SpanAnnotation]
+
+
+@strawberry.type
+class SpanAnnotationMutationMixin:
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def create_span_annotations(
+        self, info: Info[Context, None], input: List[CreateSpanAnnotationsInput]
+    ) -> SpanAnnotationMutationPayload:
+        inserted_annotations: Sequence[models.SpanAnnotation] = []
+        async with info.context.db() as session:
+            values_list = [
+                dict(
+                    span_rowid=from_global_id_with_expected_type(annotation.span_id, "Span"),
+                    name=annotation.name,
+                    label=annotation.label,
+                    score=annotation.score,
+                    explanation=annotation.explanation,
+                    annotator_kind=annotation.annotator_kind,
+                    metadata_=annotation.metadata,
+                )
+                for annotation in input
+            ]
+            stmt = (
+                insert(models.SpanAnnotation).values(values_list).returning(models.SpanAnnotation)
+            )
+            result = await session.scalars(stmt)
+            inserted_annotations = result.all()
+
+        return SpanAnnotationMutationPayload(
+            span_annotations=[
+                to_gql_span_annotation(annotation) for annotation in inserted_annotations
+            ]
+        )
+
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def patch_span_annotations(
+        self, info: Info[Context, None], input: List[PatchAnnotationsInput]
+    ) -> SpanAnnotationMutationPayload:
+        patched_annotations = []
+        async with info.context.db() as session:
+            for annotation in input:
+                span_annotation_id = from_global_id_with_expected_type(
+                    annotation.annotation_id, "SpanAnnotation"
+                )
+                patch = {
+                    column.key: patch_value
+                    for column, patch_value, column_is_nullable in (
+                        (models.SpanAnnotation.name, annotation.name, False),
+                        (models.SpanAnnotation.annotator_kind, annotation.annotator_kind, False),
+                        (models.SpanAnnotation.label, annotation.label, True),
+                        (models.SpanAnnotation.score, annotation.score, True),
+                        (models.SpanAnnotation.explanation, annotation.explanation, True),
+                        (models.SpanAnnotation.metadata_, annotation.metadata, False),
+                    )
+                    if patch_value is not UNSET and (patch_value is not None or column_is_nullable)
+                }
+                span_annotation = await session.scalar(
+                    update(models.SpanAnnotation)
+                    .where(models.SpanAnnotation.id == span_annotation_id)
+                    .values(**patch)
+                    .returning(models.SpanAnnotation)
+                )
+                if span_annotation is not None:
+                    patched_annotations.append(to_gql_span_annotation(span_annotation))
+
+        return SpanAnnotationMutationPayload(span_annotations=patched_annotations)
+
+    @strawberry.mutation(permission_classes=[IsAuthenticated])  # type: ignore
+    async def delete_span_annotations(
+        self, info: Info[Context, None], input: DeleteAnnotationsInput
+    ) -> SpanAnnotationMutationPayload:
+        span_annotation_ids = [
+            from_global_id_with_expected_type(global_id, "SpanAnnotation")
+            for global_id in input.annotation_ids
+        ]
+        async with info.context.db() as session:
+            stmt = (
+                delete(models.SpanAnnotation)
+                .where(models.SpanAnnotation.id.in_(span_annotation_ids))
+                .returning(models.SpanAnnotation)
+            )
+            result = await session.scalars(stmt)
+            deleted_annotations = result.all()
+
+            deleted_annotations_gql = [
+                to_gql_span_annotation(annotation) for annotation in deleted_annotations
+            ]
+        return SpanAnnotationMutationPayload(span_annotations=deleted_annotations_gql)