arize-phoenix 11.8.0__tar.gz → 11.10.0__tar.gz

{arize_phoenix-11.8.0 → arize_phoenix-11.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arize-phoenix
-Version: 11.8.0
+Version: 11.10.0
 Summary: AI Observability and Evaluation
 Project-URL: Documentation, https://arize.com/docs/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-11.8.0 → arize_phoenix-11.10.0}/src/phoenix/db/insertion/span.py

@@ -28,15 +28,6 @@ async def insert_span(
     project_name: str,
 ) -> Optional[SpanInsertionEvent]:
     dialect = SupportedSQLDialect(session.bind.dialect.name)
-    if (
-        project_rowid := await session.scalar(
-            select(models.Project.id).filter_by(name=project_name)
-        )
-    ) is None:
-        project_rowid = await session.scalar(
-            insert(models.Project).values(name=project_name).returning(models.Project.id)
-        )
-    assert project_rowid is not None
 
     trace_id = span.context.trace_id
     trace: models.Trace = await session.scalar(
@@ -44,16 +35,27 @@ async def insert_span(
     ) or models.Trace(trace_id=trace_id)
 
     if trace.id is not None:
+        # We use the existing project_rowid on the trace because we allow users to transfer traces
+        # between projects, so the project_name parameter is ignored for existing traces.
+        project_rowid = trace.project_rowid
         # Trace record may need to be updated.
         if trace.end_time < span.end_time:
             trace.end_time = span.end_time
-            trace.project_rowid = project_rowid
         if span.start_time < trace.start_time:
             trace.start_time = span.start_time
     else:
         # Trace record needs to be persisted for the first time.
         trace.start_time = span.start_time
         trace.end_time = span.end_time
+        if (
+            project_rowid := await session.scalar(
+                select(models.Project.id).filter_by(name=project_name)
+            )
+        ) is None:
+            project_rowid = await session.scalar(
+                insert(models.Project).values(name=project_name).returning(models.Project.id)
+            )
+            assert project_rowid is not None
         trace.project_rowid = project_rowid
         session.add(trace)
 

{arize_phoenix-11.8.0 → arize_phoenix-11.10.0}/src/phoenix/db/insertion/types.py

@@ -94,7 +94,10 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
     async def insert(self) -> Optional[list[_DmlEventT]]:
         if not self._queue:
             return None
-        self._queue, parcels = [], self._queue
+        parcels = self._queue.copy()
+        # IMPORTANT: Use .clear() instead of reassignment, i.e. self._queue = [], to
+        # avoid potential race conditions when appending postponed items to the queue.
+        self._queue.clear()
         events: list[_DmlEventT] = []
         async with self._db() as session:
             to_insert, to_postpone, _ = await self._partition(session, *parcels)
@@ -104,9 +107,13 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
                     to_postpone.extend(to_retry)
         if to_postpone:
             loop = asyncio.get_running_loop()
-            loop.call_later(self._retry_delay_sec, self._queue.extend, to_postpone)
+            loop.call_later(self._retry_delay_sec, self._add_postponed_to_queue, to_postpone)
         return events
 
+    def _add_postponed_to_queue(self, items: list[Postponed[_PrecursorT]]) -> None:
+        """Add postponed items back to the queue for retry."""
+        self._queue.extend(items)
+
     def _insert_on_conflict(self, *records: Mapping[str, Any]) -> Insert:
         return insert_on_conflict(
             *records,

arize_phoenix-11.10.0/src/phoenix/server/api/input_types/CreateProjectInput.py

@@ -0,0 +1,27 @@
+import re
+from typing import Optional
+
+import strawberry
+from strawberry import UNSET
+
+from phoenix.server.api.exceptions import BadRequest
+
+
+@strawberry.input
+class CreateProjectInput:
+    name: str
+    description: Optional[str] = UNSET
+    gradient_start_color: Optional[str] = UNSET
+    gradient_end_color: Optional[str] = UNSET
+
+    def __post_init__(self) -> None:
+        if not self.name.strip():
+            raise BadRequest("Name cannot be empty")
+        if self.gradient_start_color and not re.match(
+            r"^#([0-9a-fA-F]{6})$", self.gradient_start_color
+        ):
+            raise BadRequest("Gradient start color must be a valid hex color")
+        if self.gradient_end_color and not re.match(
+            r"^#([0-9a-fA-F]{6})$", self.gradient_end_color
+        ):
+            raise BadRequest("Gradient end color must be a valid hex color")

{arize_phoenix-11.8.0 → arize_phoenix-11.10.0}/src/phoenix/server/api/mutations/project_mutations.py

@@ -1,6 +1,8 @@
 import strawberry
 from sqlalchemy import delete, select
+from sqlalchemy.exc import IntegrityError as PostgreSQLIntegrityError
 from sqlalchemy.orm import load_only
+from sqlean.dbapi2 import IntegrityError as SQLiteIntegrityError  # type: ignore[import-untyped]
 from strawberry.relay import GlobalID
 from strawberry.types import Info
 
@@ -8,14 +10,48 @@ from phoenix.config import DEFAULT_PROJECT_NAME
 from phoenix.db import models
 from phoenix.server.api.auth import IsNotReadOnly
 from phoenix.server.api.context import Context
+from phoenix.server.api.exceptions import BadRequest, Conflict
 from phoenix.server.api.input_types.ClearProjectInput import ClearProjectInput
+from phoenix.server.api.input_types.CreateProjectInput import CreateProjectInput
 from phoenix.server.api.queries import Query
 from phoenix.server.api.types.node import from_global_id_with_expected_type
-from phoenix.server.dml_event import ProjectDeleteEvent, SpanDeleteEvent
+from phoenix.server.api.types.Project import Project, to_gql_project
+from phoenix.server.dml_event import ProjectDeleteEvent, ProjectInsertEvent, SpanDeleteEvent
+
+
+@strawberry.type
+class ProjectMutationPayload:
+    project: Project
+    query: Query
 
 
 @strawberry.type
 class ProjectMutationMixin:
+    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore
+    async def create_project(
+        self,
+        info: Info[Context, None],
+        input: CreateProjectInput,
+    ) -> ProjectMutationPayload:
+        if not (name := input.name.strip()):
+            raise BadRequest("Name cannot be empty")
+        description = (input.description or "").strip() or None
+        gradient_start_color = (input.gradient_start_color or "").strip() or None
+        gradient_end_color = (input.gradient_end_color or "").strip() or None
+        project = models.Project(
+            name=name,
+            description=description,
+            gradient_start_color=gradient_start_color,
+            gradient_end_color=gradient_end_color,
+        )
+        try:
+            async with info.context.db() as session:
+                session.add(project)
+        except (PostgreSQLIntegrityError, SQLiteIntegrityError):
+            raise Conflict(f"Project with name '{name}' already exists")
+        info.context.event_queue.put(ProjectInsertEvent((project.id,)))
+        return ProjectMutationPayload(project=to_gql_project(project), query=Query())
+
     @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore
     async def delete_project(self, info: Info[Context, None], id: GlobalID) -> Query:
         project_id = from_global_id_with_expected_type(global_id=id, expected_type_name="Project")

{arize_phoenix-11.8.0 → arize_phoenix-11.10.0}/src/phoenix/server/api/mutations/trace_mutations.py

@@ -1,5 +1,5 @@
 import strawberry
-from sqlalchemy import and_, delete, not_, select
+from sqlalchemy import and_, delete, not_, select, update
 from sqlalchemy.orm import load_only
 from sqlalchemy.sql import literal
 from strawberry.relay import GlobalID
@@ -72,3 +72,47 @@ class TraceMutationMixin:
                 )
             info.context.event_queue.put(SpanDeleteEvent(project_ids))
         return Query()
+
+    @strawberry.mutation(permission_classes=[IsNotReadOnly])  # type: ignore
+    async def transfer_traces_to_project(
+        self,
+        info: Info[Context, None],
+        trace_ids: list[GlobalID],
+        project_id: GlobalID,
+    ) -> Query:
+        if not trace_ids:
+            raise BadRequest("Must provide at least one trace ID to transfer")
+        trace_ids = list(set(trace_ids))
+        try:
+            trace_rowids = [
+                from_global_id_with_expected_type(global_id=id, expected_type_name="Trace")
+                for id in trace_ids
+            ]
+            dest_project_rowid = from_global_id_with_expected_type(
+                global_id=project_id, expected_type_name="Project"
+            )
+        except ValueError as error:
+            raise BadRequest(str(error))
+
+        async with info.context.db() as session:
+            dest_project = await session.get(models.Project, dest_project_rowid)
+            if dest_project is None:
+                raise BadRequest("Destination project does not exist")
+
+            traces = (
+                await session.scalars(select(models.Trace).where(models.Trace.id.in_(trace_rowids)))
+            ).all()
+            if len(traces) < len(trace_rowids):
+                raise BadRequest("Invalid trace IDs provided")
+
+            source_project_ids = set(trace.project_rowid for trace in traces)
+            if len(source_project_ids) > 1:
+                raise BadRequest("Cannot transfer traces from multiple projects")
+
+            await session.execute(
+                update(models.Trace)
+                .where(models.Trace.id.in_(trace_rowids))
+                .values(project_rowid=dest_project_rowid)
+            )
+
+        return Query()