arize-phoenix 6.1.0__py3-none-any.whl → 7.0.0__py3-none-any.whl

phoenix/server/api/dataloaders/trace_root_spans.py

@@ -0,0 +1,32 @@
+from typing import List, Optional
+
+from sqlalchemy import select
+from sqlalchemy.orm import contains_eager
+from strawberry.dataloader import DataLoader
+from typing_extensions import TypeAlias
+
+from phoenix.db import models
+from phoenix.server.types import DbSessionFactory
+
+Key: TypeAlias = int
+Result: TypeAlias = Optional[models.Span]
+
+
+class TraceRootSpansDataLoader(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]:
+        stmt = (
+            select(models.Span)
+            .join(models.Trace)
+            .where(models.Span.parent_id.is_(None))
+            .where(models.Trace.id.in_(keys))
+            .options(contains_eager(models.Span.trace).load_only(models.Trace.trace_id))
+        )
+        async with self._db() as session:
+            result: dict[Key, models.Span] = {
+                span.trace_rowid: span async for span in await session.stream_scalars(stmt)
+            }
+        return [result.get(key) for key in keys]

phoenix/server/api/input_types/ProjectSessionSort.py

@@ -0,0 +1,29 @@
+from enum import Enum, auto
+
+import strawberry
+from typing_extensions import assert_never
+
+from phoenix.server.api.types.pagination import CursorSortColumnDataType
+from phoenix.server.api.types.SortDir import SortDir
+
+
+@strawberry.enum
+class ProjectSessionColumn(Enum):
+    startTime = auto()
+    endTime = auto()
+    tokenCountTotal = auto()
+    numTraces = auto()
+
+    @property
+    def data_type(self) -> CursorSortColumnDataType:
+        if self is ProjectSessionColumn.tokenCountTotal or self is ProjectSessionColumn.numTraces:
+            return CursorSortColumnDataType.INT
+        if self is ProjectSessionColumn.startTime or self is ProjectSessionColumn.endTime:
+            return CursorSortColumnDataType.DATETIME
+        assert_never(self)
+
+
+@strawberry.input(description="The sort key and direction for ProjectSession connections.")
+class ProjectSessionSort:
+    col: ProjectSessionColumn
+    dir: SortDir

phoenix/server/api/mutations/chat_mutations.py

@@ -318,6 +318,9 @@ class ChatCompletionMutationMixin:
         ]
         if template_options := input.template:
             messages = list(_formatted_messages(messages, template_options))
+            attributes.update(
+                {PROMPT_TEMPLATE_VARIABLES: safe_json_dumps(template_options.variables)}
+            )
 
         invocation_parameters = llm_client.construct_invocation_parameters(
             input.invocation_parameters
@@ -584,5 +587,7 @@ TOOL_CALL_FUNCTION_NAME = ToolCallAttributes.TOOL_CALL_FUNCTION_NAME
 TOOL_CALL_FUNCTION_ARGUMENTS_JSON = ToolCallAttributes.TOOL_CALL_FUNCTION_ARGUMENTS_JSON
 
 TOOL_JSON_SCHEMA = ToolAttributes.TOOL_JSON_SCHEMA
+PROMPT_TEMPLATE_VARIABLES = SpanAttributes.LLM_PROMPT_TEMPLATE_VARIABLES
+
 
 PLAYGROUND_PROJECT_NAME = "playground"

phoenix/server/api/mutations/project_mutations.py

@@ -38,10 +38,20 @@ class ProjectMutationMixin:
         project_id = from_global_id_with_expected_type(
             global_id=input.id, expected_type_name="Project"
         )
-        delete_statement = delete(models.Trace).where(models.Trace.project_rowid == project_id)
+        delete_statement = (
+            delete(models.Trace)
+            .where(models.Trace.project_rowid == project_id)
+            .returning(models.Trace.project_session_rowid)
+        )
         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)
+            deleted_trace_project_session_ids = await session.scalars(delete_statement)
+            if deleted_trace_project_session_ids:
+                await session.execute(
+                    delete(models.ProjectSession).where(
+                        models.ProjectSession.id.in_(set(deleted_trace_project_session_ids))
+                    )
+                )
         info.context.event_queue.put(SpanDeleteEvent((project_id,)))
         return Query()

phoenix/server/api/queries.py

@@ -78,10 +78,11 @@ from phoenix.server.api.types.pagination import (
     connection_from_list,
 )
 from phoenix.server.api.types.Project import Project
+from phoenix.server.api.types.ProjectSession import ProjectSession, to_gql_project_session
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span, to_gql_span
 from phoenix.server.api.types.SystemApiKey import SystemApiKey
-from phoenix.server.api.types.Trace import Trace
+from phoenix.server.api.types.Trace import to_gql_trace
 from phoenix.server.api.types.User import User, to_gql_user
 from phoenix.server.api.types.UserApiKey import UserApiKey, to_gql_api_key
 from phoenix.server.api.types.UserRole import UserRole
@@ -445,17 +446,12 @@ class Query:
                 gradient_end_color=project.gradient_end_color,
             )
         elif type_name == "Trace":
-            trace_stmt = select(
-                models.Trace.id,
-                models.Trace.project_rowid,
-            ).where(models.Trace.id == node_id)
+            trace_stmt = select(models.Trace).filter_by(id=node_id)
             async with info.context.db() as session:
-                trace = (await session.execute(trace_stmt)).first()
+                trace = await session.scalar(trace_stmt)
             if trace is None:
                 raise NotFound(f"Unknown trace: {id}")
-            return Trace(
-                id_attr=trace.id, trace_id=trace.trace_id, project_rowid=trace.project_rowid
-            )
+            return to_gql_trace(trace)
         elif type_name == Span.__name__:
             span_stmt = (
                 select(models.Span)
@@ -544,6 +540,15 @@ class Query:
                 ):
                     raise NotFound(f"Unknown user: {id}")
             return to_gql_user(user)
+        elif type_name == ProjectSession.__name__:
+            async with info.context.db() as session:
+                if not (
+                    project_session := await session.scalar(
+                        select(models.ProjectSession).filter_by(id=node_id)
+                    )
+                ):
+                    raise NotFound(f"Unknown user: {id}")
+            return to_gql_project_session(project_session)
         raise NotFound(f"Unknown node type: {type_name}")
 
     @strawberry.field

phoenix/server/api/subscriptions.py

@@ -15,6 +15,7 @@ from typing import (
 )
 
 import strawberry
+from openinference.instrumentation import safe_json_dumps
 from openinference.semconv.trace import SpanAttributes
 from sqlalchemy import and_, func, insert, select
 from sqlalchemy.orm import load_only
@@ -118,6 +119,7 @@ class Subscription:
             )
             for message in input.messages
         ]
+        attributes = None
         if template_options := input.template:
             messages = list(
                 _formatted_messages(
@@ -126,6 +128,7 @@ class Subscription:
                     template_variables=template_options.variables,
                 )
             )
+            attributes = {PROMPT_TEMPLATE_VARIABLES: safe_json_dumps(template_options.variables)}
         invocation_parameters = llm_client.construct_invocation_parameters(
             input.invocation_parameters
         )
@@ -133,6 +136,7 @@ class Subscription:
             input=input,
             messages=messages,
             invocation_parameters=invocation_parameters,
+            attributes=attributes,
         ) as span:
             async for chunk in llm_client.chat_completion_create(
                 messages=messages, tools=input.tools or [], **invocation_parameters
@@ -424,6 +428,7 @@ async def _stream_chat_completion_over_dataset_example(
         input=input,
         messages=messages,
         invocation_parameters=invocation_parameters,
+        attributes={PROMPT_TEMPLATE_VARIABLES: safe_json_dumps(revision.input)},
     ) as span:
         async for chunk in llm_client.chat_completion_create(
             messages=messages, tools=input.tools or [], **invocation_parameters
@@ -589,3 +594,4 @@ def _default_playground_experiment_metadata(
 LLM_OUTPUT_MESSAGES = SpanAttributes.LLM_OUTPUT_MESSAGES
 LLM_TOKEN_COUNT_COMPLETION = SpanAttributes.LLM_TOKEN_COUNT_COMPLETION
 LLM_TOKEN_COUNT_PROMPT = SpanAttributes.LLM_TOKEN_COUNT_PROMPT
+PROMPT_TEMPLATE_VARIABLES = SpanAttributes.LLM_PROMPT_TEMPLATE_VARIABLES

phoenix/server/api/types/EmbeddingDimension.py

@@ -477,7 +477,7 @@ def _row_indices(
         return
     shuffled_indices = np.arange(start, stop)
     np.random.shuffle(shuffled_indices)
-    yield from shuffled_indices
+    yield from shuffled_indices  # type: ignore[misc,unused-ignore]
 
 
 def to_gql_embedding_dimension(

phoenix/server/api/types/ExperimentRun.py

@@ -20,7 +20,7 @@ from phoenix.server.api.types.pagination import (
     CursorString,
     connection_from_list,
 )
-from phoenix.server.api.types.Trace import Trace
+from phoenix.server.api.types.Trace import Trace, to_gql_trace
 
 if TYPE_CHECKING:
     from phoenix.server.api.types.DatasetExample import DatasetExample
@@ -61,11 +61,10 @@ class ExperimentRun(Node):
     async def trace(self, info: Info) -> Optional[Trace]:
         if not self.trace_id:
             return None
-        dataloader = info.context.data_loaders.trace_row_ids
+        dataloader = info.context.data_loaders.trace_by_trace_ids
         if (trace := await dataloader.load(self.trace_id)) is None:
             return None
-        trace_rowid, project_rowid = trace
-        return Trace(id_attr=trace_rowid, trace_id=self.trace_id, project_rowid=project_rowid)
+        return to_gql_trace(trace)
 
     @strawberry.field
     async def example(

phoenix/server/api/types/ExperimentRunAnnotation.py

@@ -8,7 +8,7 @@ from strawberry.scalars import JSON
 
 from phoenix.db import models
 from phoenix.server.api.types.AnnotatorKind import ExperimentRunAnnotatorKind
-from phoenix.server.api.types.Trace import Trace
+from phoenix.server.api.types.Trace import Trace, to_gql_trace
 
 
 @strawberry.type
@@ -29,11 +29,10 @@ class ExperimentRunAnnotation(Node):
     async def trace(self, info: Info) -> Optional[Trace]:
         if not self.trace_id:
             return None
-        dataloader = info.context.data_loaders.trace_row_ids
+        dataloader = info.context.data_loaders.trace_by_trace_ids
         if (trace := await dataloader.load(self.trace_id)) is None:
             return None
-        trace_row_id, project_row_id = trace
-        return Trace(id_attr=trace_row_id, trace_id=self.trace_id, project_rowid=project_row_id)
+        return to_gql_trace(trace)
 
 
 def to_gql_experiment_run_annotation(

phoenix/server/api/types/Project.py

@@ -1,23 +1,26 @@
 import operator
 from datetime import datetime
-from typing import (
-    Any,
-    ClassVar,
-    Optional,
-)
+from typing import Any, ClassVar, Optional
 
 import strawberry
 from aioitertools.itertools import islice
-from sqlalchemy import and_, desc, distinct, select
+from openinference.semconv.trace import SpanAttributes
+from sqlalchemy import and_, desc, distinct, func, or_, select
 from sqlalchemy.orm import contains_eager
+from sqlalchemy.sql.elements import ColumnElement
 from sqlalchemy.sql.expression import tuple_
 from strawberry import ID, UNSET
 from strawberry.relay import Connection, Node, NodeID
 from strawberry.types import Info
+from typing_extensions import assert_never
 
 from phoenix.datetime_utils import right_open_time_range
 from phoenix.db import models
 from phoenix.server.api.context import Context
+from phoenix.server.api.input_types.ProjectSessionSort import (
+    ProjectSessionColumn,
+    ProjectSessionSort,
+)
 from phoenix.server.api.input_types.SpanSort import SpanSort, SpanSortConfig
 from phoenix.server.api.input_types.TimeRange import TimeRange
 from phoenix.server.api.types.AnnotationSummary import AnnotationSummary
@@ -28,9 +31,10 @@ from phoenix.server.api.types.pagination import (
     CursorString,
     connection_from_cursors_and_nodes,
 )
+from phoenix.server.api.types.ProjectSession import ProjectSession, to_gql_project_session
 from phoenix.server.api.types.SortDir import SortDir
 from phoenix.server.api.types.Span import Span, to_gql_span
-from phoenix.server.api.types.Trace import Trace
+from phoenix.server.api.types.Trace import Trace, to_gql_trace
 from phoenix.server.api.types.ValidationResult import ValidationResult
 from phoenix.trace.dsl import SpanFilter
 
@@ -127,7 +131,13 @@ class Project(Node):
         time_range: Optional[TimeRange] = UNSET,
     ) -> Optional[float]:
         return await info.context.data_loaders.latency_ms_quantile.load(
-            ("trace", self.id_attr, time_range, None, probability),
+            (
+                "trace",
+                self.id_attr,
+                time_range,
+                None,
+                probability,
+            ),
         )
 
     @strawberry.field
@@ -139,20 +149,26 @@ class Project(Node):
         filter_condition: Optional[str] = UNSET,
     ) -> Optional[float]:
         return await info.context.data_loaders.latency_ms_quantile.load(
-            ("span", self.id_attr, time_range, filter_condition, probability),
+            (
+                "span",
+                self.id_attr,
+                time_range,
+                filter_condition,
+                probability,
+            ),
         )
 
     @strawberry.field
     async def trace(self, trace_id: ID, info: Info[Context, None]) -> Optional[Trace]:
         stmt = (
-            select(models.Trace.id)
+            select(models.Trace)
             .where(models.Trace.trace_id == str(trace_id))
             .where(models.Trace.project_rowid == self.id_attr)
         )
         async with info.context.db() as session:
-            if (id_attr := await session.scalar(stmt)) is None:
+            if (trace := await session.scalar(stmt)) is None:
                 return None
-        return Trace(id_attr=id_attr, trace_id=trace_id, project_rowid=self.id_attr)
+        return to_gql_trace(trace)
 
     @strawberry.field
     async def spans(
@@ -241,6 +257,124 @@ class Project(Node):
             has_next_page=has_next_page,
         )
 
+    @strawberry.field
+    async def sessions(
+        self,
+        info: Info[Context, None],
+        time_range: Optional[TimeRange] = UNSET,
+        first: Optional[int] = 50,
+        after: Optional[CursorString] = UNSET,
+        sort: Optional[ProjectSessionSort] = UNSET,
+        filter_io_substring: Optional[str] = UNSET,
+    ) -> Connection[ProjectSession]:
+        table = models.ProjectSession
+        stmt = select(table).filter_by(project_id=self.id_attr)
+        if time_range:
+            if time_range.start:
+                stmt = stmt.where(time_range.start <= table.start_time)
+            if time_range.end:
+                stmt = stmt.where(table.start_time < time_range.end)
+        if filter_io_substring:
+            filter_subq = (
+                stmt.with_only_columns(distinct(table.id).label("id"))
+                .join_from(table, models.Trace)
+                .join_from(models.Trace, models.Span)
+                .where(models.Span.parent_id.is_(None))
+                .where(
+                    or_(
+                        models.TextContains(
+                            models.Span.attributes[INPUT_VALUE].as_string(),
+                            filter_io_substring,
+                        ),
+                        models.TextContains(
+                            models.Span.attributes[OUTPUT_VALUE].as_string(),
+                            filter_io_substring,
+                        ),
+                    )
+                )
+            ).subquery()
+            stmt = stmt.join(filter_subq, table.id == filter_subq.c.id)
+        if sort:
+            key: ColumnElement[Any]
+            if sort.col is ProjectSessionColumn.startTime:
+                key = table.start_time.label("key")
+            elif sort.col is ProjectSessionColumn.endTime:
+                key = table.end_time.label("key")
+            elif (
+                sort.col is ProjectSessionColumn.tokenCountTotal
+                or sort.col is ProjectSessionColumn.numTraces
+            ):
+                if sort.col is ProjectSessionColumn.tokenCountTotal:
+                    sort_subq = (
+                        select(
+                            models.Trace.project_session_rowid.label("id"),
+                            func.sum(models.Span.cumulative_llm_token_count_total).label("key"),
+                        )
+                        .join_from(models.Trace, models.Span)
+                        .where(models.Span.parent_id.is_(None))
+                        .group_by(models.Trace.project_session_rowid)
+                    ).subquery()
+                elif sort.col is ProjectSessionColumn.numTraces:
+                    sort_subq = (
+                        select(
+                            models.Trace.project_session_rowid.label("id"),
+                            func.count(models.Trace.id).label("key"),
+                        ).group_by(models.Trace.project_session_rowid)
+                    ).subquery()
+                else:
+                    assert_never(sort.col)
+                key = sort_subq.c.key
+                stmt = stmt.join(sort_subq, table.id == sort_subq.c.id)
+            else:
+                assert_never(sort.col)
+            stmt = stmt.add_columns(key)
+            if sort.dir is SortDir.asc:
+                stmt = stmt.order_by(key.asc(), table.id.asc())
+            else:
+                stmt = stmt.order_by(key.desc(), table.id.desc())
+            if after:
+                cursor = Cursor.from_string(after)
+                assert cursor.sort_column is not None
+                compare = operator.lt if sort.dir is SortDir.desc else operator.gt
+                stmt = stmt.where(
+                    compare(
+                        tuple_(key, table.id),
+                        (cursor.sort_column.value, cursor.rowid),
+                    )
+                )
+        else:
+            stmt = stmt.order_by(table.id.desc())
+            if after:
+                cursor = Cursor.from_string(after)
+                stmt = stmt.where(table.id < cursor.rowid)
+        if first:
+            stmt = stmt.limit(
+                first + 1  # over-fetch by one to determine whether there's a next page
+            )
+        cursors_and_nodes = []
+        async with info.context.db() as session:
+            records = await session.stream(stmt)
+            async for record in islice(records, first):
+                project_session = record[0]
+                cursor = Cursor(rowid=project_session.id)
+                if sort:
+                    assert len(record) > 1
+                    cursor.sort_column = CursorSortColumn(
+                        type=sort.col.data_type,
+                        value=record[1],
+                    )
+                cursors_and_nodes.append((cursor, to_gql_project_session(project_session)))
+            has_next_page = True
+            try:
+                await records.__anext__()
+            except StopAsyncIteration:
+                has_next_page = False
+        return connection_from_cursors_and_nodes(
+            cursors_and_nodes,
+            has_previous_page=False,
+            has_next_page=has_next_page,
+        )
+
     @strawberry.field(
         description="Names of all available annotations for traces. "
         "(The list contains no duplicates.)"
@@ -363,3 +497,7 @@ def to_gql_project(project: models.Project) -> Project:
         gradient_start_color=project.gradient_start_color,
         gradient_end_color=project.gradient_end_color,
     )
+
+
+INPUT_VALUE = SpanAttributes.INPUT_VALUE.split(".")
+OUTPUT_VALUE = SpanAttributes.OUTPUT_VALUE.split(".")

phoenix/server/api/types/ProjectSession.py

@@ -0,0 +1,139 @@
+from datetime import datetime
+from typing import TYPE_CHECKING, Annotated, ClassVar, Optional, Type
+
+import strawberry
+from openinference.semconv.trace import SpanAttributes
+from sqlalchemy import select
+from strawberry import UNSET, Info, Private, lazy
+from strawberry.relay import Connection, GlobalID, Node, NodeID
+
+from phoenix.db import models
+from phoenix.server.api.context import Context
+from phoenix.server.api.types.MimeType import MimeType
+from phoenix.server.api.types.pagination import ConnectionArgs, CursorString, connection_from_list
+from phoenix.server.api.types.SpanIOValue import SpanIOValue
+from phoenix.server.api.types.TokenUsage import TokenUsage
+
+if TYPE_CHECKING:
+    from phoenix.server.api.types.Trace import Trace
+
+
+@strawberry.type
+class ProjectSession(Node):
+    _table: ClassVar[Type[models.ProjectSession]] = models.ProjectSession
+    id_attr: NodeID[int]
+    project_rowid: Private[int]
+    session_id: str
+    start_time: datetime
+    end_time: datetime
+
+    @strawberry.field
+    async def project_id(self) -> GlobalID:
+        from phoenix.server.api.types.Project import Project
+
+        return GlobalID(type_name=Project.__name__, node_id=str(self.project_rowid))
+
+    @strawberry.field
+    async def num_traces(
+        self,
+        info: Info[Context, None],
+    ) -> int:
+        return await info.context.data_loaders.session_num_traces.load(self.id_attr)
+
+    @strawberry.field
+    async def num_traces_with_error(
+        self,
+        info: Info[Context, None],
+    ) -> int:
+        return await info.context.data_loaders.session_num_traces_with_error.load(self.id_attr)
+
+    @strawberry.field
+    async def first_input(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[SpanIOValue]:
+        record = await info.context.data_loaders.session_first_inputs.load(self.id_attr)
+        if record is None:
+            return None
+        return SpanIOValue(
+            mime_type=MimeType(record.mime_type.value),
+            value=record.value,
+        )
+
+    @strawberry.field
+    async def last_output(
+        self,
+        info: Info[Context, None],
+    ) -> Optional[SpanIOValue]:
+        record = await info.context.data_loaders.session_last_outputs.load(self.id_attr)
+        if record is None:
+            return None
+        return SpanIOValue(
+            mime_type=MimeType(record.mime_type.value),
+            value=record.value,
+        )
+
+    @strawberry.field
+    async def token_usage(
+        self,
+        info: Info[Context, None],
+    ) -> TokenUsage:
+        usage = await info.context.data_loaders.session_token_usages.load(self.id_attr)
+        return TokenUsage(
+            prompt=usage.prompt,
+            completion=usage.completion,
+        )
+
+    @strawberry.field
+    async def traces(
+        self,
+        info: Info[Context, None],
+        first: Optional[int] = 50,
+        last: Optional[int] = UNSET,
+        after: Optional[CursorString] = UNSET,
+        before: Optional[CursorString] = UNSET,
+    ) -> Connection[Annotated["Trace", lazy(".Trace")]]:
+        from phoenix.server.api.types.Trace import to_gql_trace
+
+        args = ConnectionArgs(
+            first=first,
+            after=after if isinstance(after, CursorString) else None,
+            last=last,
+            before=before if isinstance(before, CursorString) else None,
+        )
+        stmt = (
+            select(models.Trace)
+            .filter_by(project_session_rowid=self.id_attr)
+            .order_by(models.Trace.start_time)
+            .limit(first)
+        )
+        async with info.context.db() as session:
+            traces = await session.stream_scalars(stmt)
+            data = [to_gql_trace(trace) async for trace in traces]
+        return connection_from_list(data=data, args=args)
+
+    @strawberry.field
+    async def trace_latency_ms_quantile(
+        self,
+        info: Info[Context, None],
+        probability: float,
+    ) -> Optional[float]:
+        return await info.context.data_loaders.session_trace_latency_ms_quantile.load(
+            (self.id_attr, probability)
+        )
+
+
+def to_gql_project_session(project_session: models.ProjectSession) -> ProjectSession:
+    return ProjectSession(
+        id_attr=project_session.id,
+        session_id=project_session.session_id,
+        start_time=project_session.start_time,
+        project_rowid=project_session.project_id,
+        end_time=project_session.end_time,
+    )
+
+
+INPUT_VALUE = SpanAttributes.INPUT_VALUE.split(".")
+INPUT_MIME_TYPE = SpanAttributes.INPUT_MIME_TYPE.split(".")
+OUTPUT_VALUE = SpanAttributes.OUTPUT_VALUE.split(".")
+OUTPUT_MIME_TYPE = SpanAttributes.OUTPUT_MIME_TYPE.split(".")

phoenix/server/api/types/Span.py

@@ -24,17 +24,16 @@ from phoenix.server.api.input_types.SpanAnnotationSort import (
     SpanAnnotationColumn,
     SpanAnnotationSort,
 )
+from phoenix.server.api.types.DocumentRetrievalMetrics import DocumentRetrievalMetrics
+from phoenix.server.api.types.Evaluation import DocumentEvaluation
+from phoenix.server.api.types.ExampleRevisionInterface import ExampleRevision
 from phoenix.server.api.types.GenerativeProvider import GenerativeProvider
+from phoenix.server.api.types.MimeType import MimeType
 from phoenix.server.api.types.SortDir import SortDir
-from phoenix.server.api.types.SpanAnnotation import to_gql_span_annotation
+from phoenix.server.api.types.SpanAnnotation import SpanAnnotation, to_gql_span_annotation
+from phoenix.server.api.types.SpanIOValue import SpanIOValue
 from phoenix.trace.attributes import get_attribute_value
 
-from .DocumentRetrievalMetrics import DocumentRetrievalMetrics
-from .Evaluation import DocumentEvaluation
-from .ExampleRevisionInterface import ExampleRevision
-from .MimeType import MimeType
-from .SpanAnnotation import SpanAnnotation
-
 if TYPE_CHECKING:
     from phoenix.server.api.types.Project import Project
 
@@ -71,18 +70,6 @@ class SpanContext:
     span_id: ID
 
 
-@strawberry.type
-class SpanIOValue:
-    mime_type: MimeType
-    value: str
-
-    @strawberry.field(
-        description="Truncate value up to `chars` characters, appending '...' if truncated.",
-    )  # type: ignore
-    def truncated_value(self, chars: int = 100) -> str:
-        return f"{self.value[: max(0, chars - 3)]}..." if len(self.value) > chars else self.value
-
-
 @strawberry.enum
 class SpanStatusCode(Enum):
     OK = "OK"

phoenix/server/api/types/SpanIOValue.py

@@ -0,0 +1,15 @@
+import strawberry
+
+from phoenix.server.api.types.MimeType import MimeType
+
+
+@strawberry.type
+class SpanIOValue:
+    mime_type: MimeType
+    value: str
+
+    @strawberry.field(
+        description="Truncate value up to `chars` characters, appending '...' if truncated.",
+    )  # type: ignore
+    def truncated_value(self, chars: int = 100) -> str:
+        return f"{self.value[: max(0, chars - 3)]}..." if len(self.value) > chars else self.value