arize-phoenix 5.5.2__py3-none-any.whl → 5.6.0__py3-none-any.whl

phoenix/session/evaluation.py

@@ -13,7 +13,6 @@ from typing import (
     Iterator,
     Optional,
     Sequence,
-    Tuple,
     Union,
     cast,
 )
@@ -44,7 +43,7 @@ def encode_evaluations(evaluations: Evaluations) -> Iterator[pb.Evaluation]:
     for index, row in dataframe.iterrows():
         subject_id = _extract_subject_id_from_index(
             index_names,
-            cast(Union[str, Tuple[Any]], index),
+            cast(Union[str, tuple[Any]], index),
         )
         if (result := _extract_result(row)) is None:
             continue

phoenix/session/session.py

@@ -5,23 +5,14 @@ import shutil
 import warnings
 from abc import ABC, abstractmethod
 from collections import UserList
+from collections.abc import Iterable, Mapping
 from datetime import datetime
 from enum import Enum
 from importlib.util import find_spec
 from itertools import chain
 from pathlib import Path
 from tempfile import TemporaryDirectory
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Iterable,
-    List,
-    Mapping,
-    NamedTuple,
-    Optional,
-    Set,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, NamedTuple, Optional, Union
 from urllib.parse import urljoin
 
 import pandas as pd
@@ -88,8 +79,8 @@ class NotebookEnvironment(Enum):
 
 class ExportedData(_BaseList):
     def __init__(self) -> None:
-        self.paths: Set[Path] = set()
-        self.names: List[str] = []
+        self.paths: set[Path] = set()
+        self.names: list[str] = []
         super().__init__()
 
     def __repr__(self) -> str:
@@ -112,7 +103,7 @@ class Session(TraceDataExtractor, ABC):
     notebook_env: NotebookEnvironment
     """The notebook environment that the session is running in."""
 
-    def __dir__(self) -> List[str]:
+    def __dir__(self) -> list[str]:
         return ["exports", "view", "url"]
 
     def __init__(
@@ -157,7 +148,7 @@ class Session(TraceDataExtractor, ABC):
         # Deprecated fields
         stop_time: Optional[datetime] = None,
         timeout: Optional[int] = DEFAULT_TIMEOUT_IN_SECONDS,
-    ) -> Optional[Union[pd.DataFrame, List[pd.DataFrame]]]:
+    ) -> Optional[Union[pd.DataFrame, list[pd.DataFrame]]]:
         """
         Queries the spans in the project based on the provided parameters.
 
@@ -203,7 +194,7 @@ class Session(TraceDataExtractor, ABC):
     def get_evaluations(
         self,
         project_name: Optional[str] = None,
-    ) -> List[Evaluations]:
+    ) -> list[Evaluations]:
         """
         Get the evaluations for a project.
 
@@ -216,7 +207,7 @@ class Session(TraceDataExtractor, ABC):
 
         Returns
         -------
-            evaluations : List[Evaluations]
+            evaluations : list[Evaluations]
                 A list of evaluations for the specified project.
 
         """
@@ -471,7 +462,7 @@ def launch_app(
         Defaults to 6006.
     run_in_thread: bool, optional, default=True
         Whether the server should run in a Thread or Process.
-    default_umap_parameters: Dict[str, Union[int, float]], optional, default=None
+    default_umap_parameters: dict[str, Union[int, float]], optional, default=None
         User specified default UMAP parameters
         eg: {"n_neighbors": 10, "n_samples": 5, "min_dist": 0.5}
     notebook_environment: str, optional, default=None
@@ -638,7 +629,7 @@ def close_app(delete_data: bool = False) -> None:
 def _get_url(host: str, port: int, notebook_env: NotebookEnvironment) -> str:
     """Determines the IFrame URL based on whether this is in a Colab or in a local notebook"""
     if notebook_env == NotebookEnvironment.COLAB:
-        from google.colab.output import eval_js  # type: ignore
+        from google.colab.output import eval_js
 
         return str(eval_js(f"google.colab.kernel.proxyPort({port}, {{'cache': true}})"))
     if notebook_env == NotebookEnvironment.SAGEMAKER:
@@ -656,7 +647,7 @@ def _get_url(host: str, port: int, notebook_env: NotebookEnvironment) -> str:
 def _is_colab() -> bool:
     """Determines whether this is in a Colab"""
     try:
-        import google.colab  # type: ignore # noqa: F401
+        import google.colab  # noqa: F401
     except ImportError:
         return False
     try:

phoenix/trace/attributes.py

@@ -17,21 +17,9 @@ them into a nested list of dictionaries i.e.
 
 import inspect
 import json
-from typing import (
-    Any,
-    DefaultDict,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
-    cast,
-)
+from collections import defaultdict
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from typing import Any, Optional, Union, cast
 
 import numpy as np
 from openinference.semconv import trace
@@ -51,7 +39,7 @@ JSON_STRING_ATTRIBUTES = (
     TOOL_PARAMETERS,
 )
 
-SEMANTIC_CONVENTIONS: List[str] = sorted(
+SEMANTIC_CONVENTIONS: list[str] = sorted(
     # e.g. "input.value", "llm.token_count.total", etc.
     (
         cast(str, getattr(klass, attr))
@@ -66,11 +54,11 @@ SEMANTIC_CONVENTIONS: List[str] = sorted(
 
 
 def unflatten(
-    key_value_pairs: Iterable[Tuple[str, Any]],
+    key_value_pairs: Iterable[tuple[str, Any]],
     *,
     prefix_exclusions: Sequence[str] = (),
     separator: str = ".",
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     # `prefix_exclusions` is intended to contain the semantic conventions
     trie = _build_trie(key_value_pairs, separator=separator, prefix_exclusions=prefix_exclusions)
     return dict(_walk(trie, separator=separator))
@@ -83,7 +71,7 @@ def flatten(
     separator: str = ".",
     recurse_on_sequence: bool = False,
     json_string_attributes: Optional[Sequence[str]] = None,
-) -> Iterator[Tuple[str, Any]]:
+) -> Iterator[tuple[str, Any]]:
     """
     Flatten a nested dictionary or a sequence of dictionaries into a list of
     key value pairs. If `recurse_on_sequence` is True, then the function will
@@ -149,7 +137,7 @@ def get_attribute_value(
     return attributes.get(sub_keys[-1])
 
 
-def load_json_strings(key_values: Iterable[Tuple[str, Any]]) -> Iterator[Tuple[str, Any]]:
+def load_json_strings(key_values: Iterable[tuple[str, Any]]) -> Iterator[tuple[str, Any]]:
     for key, value in key_values:
         if key.endswith(JSON_STRING_ATTRIBUTES):
             try:
@@ -167,7 +155,7 @@ def _partition_with_prefix_exclusion(
     key: str,
     separator: str = ".",
     prefix_exclusions: Sequence[str] = (),
-) -> Tuple[str, str, str]:
+) -> tuple[str, str, str]:
     """
     Partition `key` by `separator`, but exclude prefixes in `prefix_exclusions`,
     which is usually the list of semantic conventions. `prefix_exclusions` should
@@ -181,7 +169,7 @@ def _partition_with_prefix_exclusion(
     return key.partition(separator)
 
 
-class _Trie(DefaultDict[Union[str, int], "_Trie"]):
+class _Trie(defaultdict[Union[str, int], "_Trie"]):
     """
     Prefix Tree with special handling for indices (i.e. all-digit keys). Indices
     represent the position of an element in a nested list, while branches represent
@@ -191,8 +179,8 @@ class _Trie(DefaultDict[Union[str, int], "_Trie"]):
     def __init__(self) -> None:
         super().__init__(_Trie)
         self.value: Any = None
-        self.indices: Set[int] = set()
-        self.branches: Set[Union[str, int]] = set()
+        self.indices: set[int] = set()
+        self.branches: set[Union[str, int]] = set()
 
     def set_value(self, value: Any) -> None:
         self.value = value
@@ -215,7 +203,7 @@ class _Trie(DefaultDict[Union[str, int], "_Trie"]):
 
 
 def _build_trie(
-    key_value_pairs: Iterable[Tuple[str, Any]],
+    key_value_pairs: Iterable[tuple[str, Any]],
     *,
     prefix_exclusions: Sequence[str] = (),
     separator: str = ".",
@@ -254,7 +242,7 @@ def _walk(
     *,
     prefix: str = "",
     separator: str = ".",
-) -> Iterator[Tuple[str, Any]]:
+) -> Iterator[tuple[str, Any]]:
     """
     Walk the Trie and yield key value pairs. If the Trie node has a value, then
     yield the prefix and the value. If the Trie node has indices, then yield the
@@ -286,7 +274,7 @@ def _flatten_mapping(
     recurse_on_sequence: bool = False,
     json_string_attributes: Optional[Sequence[str]] = None,
     separator: str = ".",
-) -> Iterator[Tuple[str, Any]]:
+) -> Iterator[tuple[str, Any]]:
     """
     Flatten a nested dictionary into a list of key value pairs. If `recurse_on_sequence`
     is True, then the function will also recursively flatten nested sequences of dictionaries.
@@ -327,7 +315,7 @@ def _flatten_sequence(
     recurse_on_sequence: bool = False,
     json_string_attributes: Optional[Sequence[str]] = None,
     separator: str = ".",
-) -> Iterator[Tuple[str, Any]]:
+) -> Iterator[tuple[str, Any]]:
     """
     Flatten a sequence of dictionaries into a list of key value pairs. If `recurse_on_sequence`
     is True, then the function will also recursively flatten nested sequences of dictionaries.

phoenix/trace/dsl/filter.py

@@ -17,7 +17,7 @@ from typing_extensions import TypeAlias, TypeGuard, assert_never
 import phoenix.trace.v1 as pb
 from phoenix.db import models
 
-_VALID_EVAL_ATTRIBUTES: typing.Tuple[str, ...] = tuple(
+_VALID_EVAL_ATTRIBUTES: tuple[str, ...] = tuple(
     field.name for field in pb.Evaluation.Result.DESCRIPTOR.fields
 )
 
@@ -59,7 +59,7 @@ class AliasedAnnotationRelation:
         object.__setattr__(self, "table", table)
 
     @property
-    def attributes(self) -> typing.Iterator[typing.Tuple[str, Mapped[typing.Any]]]:
+    def attributes(self) -> typing.Iterator[tuple[str, Mapped[typing.Any]]]:
         """
         Alias names and attributes (i.e., columns) of the `span_annotation`
         relation.
@@ -80,7 +80,7 @@ class AliasedAnnotationRelation:
 
 # Because postgresql is strongly typed, we cast JSON values to string
 # by default unless it's hinted otherwise as done here.
-_FLOAT_ATTRIBUTES: typing.FrozenSet[str] = frozenset(
+_FLOAT_ATTRIBUTES: frozenset[str] = frozenset(
     {
         "llm.token_count.completion",
         "llm.token_count.prompt",
@@ -142,12 +142,8 @@ class SpanFilter:
     valid_eval_names: typing.Optional[typing.Sequence[str]] = None
     translated: ast.Expression = field(init=False, repr=False)
     compiled: typing.Any = field(init=False, repr=False)
-    _aliased_annotation_relations: typing.Tuple[AliasedAnnotationRelation] = field(
-        init=False, repr=False
-    )
-    _aliased_annotation_attributes: typing.Dict[str, Mapped[typing.Any]] = field(
-        init=False, repr=False
-    )
+    _aliased_annotation_relations: tuple[AliasedAnnotationRelation] = field(init=False, repr=False)
+    _aliased_annotation_attributes: dict[str, Mapped[typing.Any]] = field(init=False, repr=False)
 
     def __bool__(self) -> bool:
         return bool(self.condition)
@@ -198,7 +194,7 @@ class SpanFilter:
             )
         )
 
-    def to_dict(self) -> typing.Dict[str, typing.Any]:
+    def to_dict(self) -> dict[str, typing.Any]:
         return {"condition": self.condition}
 
     @classmethod
@@ -439,7 +435,7 @@ class _ProjectionTranslator(ast.NodeTransformer):
 class _FilterTranslator(_ProjectionTranslator):
     def visit_Compare(self, node: ast.Compare) -> typing.Any:
         if len(node.comparators) > 1:
-            args: typing.List[typing.Any] = []
+            args: list[typing.Any] = []
             left = node.left
             for i, (op, comparator) in enumerate(zip(node.ops, node.comparators)):
                 args.append(self.visit(ast.Compare(left=left, ops=[op], comparators=[comparator])))
@@ -540,7 +536,7 @@ class _FilterTranslator(_ProjectionTranslator):
 def _validate_expression(
     expression: ast.Expression,
     valid_eval_names: typing.Optional[typing.Sequence[str]] = None,
-    valid_eval_attributes: typing.Tuple[str, ...] = _VALID_EVAL_ATTRIBUTES,
+    valid_eval_attributes: tuple[str, ...] = _VALID_EVAL_ATTRIBUTES,
 ) -> None:
     """
     Validate primarily the structural (i.e. not semantic) characteristics of an
@@ -638,7 +634,7 @@ def _validate_expression(
 
 
 def _as_attribute(
-    keys: typing.List[ast.Constant],
+    keys: list[ast.Constant],
     # as_float: typing.Optional[bool] = None,
 ) -> ast.Subscript:
     return ast.Subscript(
@@ -675,14 +671,14 @@ def _is_subscript(
 
 def _get_attribute_keys_list(
     node: typing.Any,
-) -> typing.Optional[typing.List[ast.Constant]]:
+) -> typing.Optional[list[ast.Constant]]:
     # e.g. `attributes["key"]` -> `["key"]`
     # e.g. `attributes["a"]["b.c"][["d"]]` -> `["a", "b.c", "d"]`
     # e.g. `attributes["a"][["b.c", "d"]]` -> `["a", "b.c", "d"]`
     # e.g. `metadata["key"]` -> `["metadata", "key"]`
     # e.g. `metadata["a"]["b.c"][["d"]]` -> `["metadata", "a", "b.c", "d"]`
     # e.g. `metadata["a"][["b.c", "d"]]` -> `["metadata", "a", "b.c", "d"]`
-    keys: typing.List[ast.Constant] = []
+    keys: list[ast.Constant] = []
     if isinstance(node, ast.Attribute):
         while isinstance(node, ast.Attribute):
             keys.append(ast.Constant(value=node.attr, kind=None))
@@ -707,7 +703,7 @@ def _get_attribute_keys_list(
 
 def _get_subscript_keys_list(
     node: ast.Subscript,
-) -> typing.Optional[typing.List[ast.Constant]]:
+) -> typing.Optional[list[ast.Constant]]:
     child = node.slice
     if isinstance(child, ast.Constant):
         if not isinstance(child.value, (str, int)) or isinstance(child.value, bool):
@@ -751,7 +747,7 @@ def _disjunction(choices: typing.Sequence[str]) -> str:
 
 def _find_best_match(
     source: str, choices: typing.Iterable[str]
-) -> typing.Tuple[typing.Optional[str], float]:
+) -> tuple[typing.Optional[str], float]:
     best_choice, best_score = None, 0.0
     for choice in choices:
         score = SequenceMatcher(None, source, choice).ratio()
@@ -762,9 +758,9 @@ def _find_best_match(
 
 def _apply_eval_aliasing(
     source: str,
-) -> typing.Tuple[
+) -> tuple[
     str,
-    typing.Tuple[AliasedAnnotationRelation, ...],
+    tuple[AliasedAnnotationRelation, ...],
 ]:
     """
     Substitutes `evals[<eval-name>].<attribute>` with aliases. Returns the
@@ -784,7 +780,7 @@ def _apply_eval_aliasing(
     span_annotation_0_label_123 == 'correct' or span_annotation_0_score_456 < 0.5
     ```
     """
-    eval_aliases: typing.Dict[AnnotationName, AliasedAnnotationRelation] = {}
+    eval_aliases: dict[AnnotationName, AliasedAnnotationRelation] = {}
     for (
         annotation_expression,
         annotation_type,
@@ -802,7 +798,7 @@ def _apply_eval_aliasing(
 def _parse_annotation_expressions_and_names(
     source: str,
 ) -> typing.Iterator[
-    typing.Tuple[AnnotationExpression, AnnotationType, AnnotationName, AnnotationAttribute]
+    tuple[AnnotationExpression, AnnotationType, AnnotationName, AnnotationAttribute]
 ]:
     """
     Parses filter conditions for evaluation expressions of the form:

phoenix/trace/dsl/helpers.py

@@ -1,6 +1,6 @@
 import warnings
 from datetime import datetime
-from typing import List, Optional, Protocol, Tuple, Union, cast
+from typing import Optional, Protocol, Union, cast
 
 import pandas as pd
 from openinference.semconv.trace import DocumentAttributes, SpanAttributes
@@ -31,7 +31,7 @@ class CanQuerySpans(Protocol):
         start_time: Optional[datetime] = None,
         end_time: Optional[datetime] = None,
         project_name: Optional[str] = None,
-    ) -> Optional[Union[pd.DataFrame, List[pd.DataFrame]]]: ...
+    ) -> Optional[Union[pd.DataFrame, list[pd.DataFrame]]]: ...
 
 
 def get_retrieved_documents(
@@ -94,7 +94,7 @@ def get_qa_with_reference(
         .with_index("trace_id")
     )
     df_qa, df_docs = cast(
-        Tuple[pd.DataFrame, pd.DataFrame],
+        tuple[pd.DataFrame, pd.DataFrame],
         obj.query_spans(
             qa_query,
             docs_query,

phoenix/trace/dsl/query.py

@@ -1,22 +1,13 @@
 import warnings
 from collections import defaultdict
+from collections.abc import Iterable, Mapping, Sequence
 from dataclasses import dataclass, field, replace
 from datetime import datetime
 from functools import cached_property
 from itertools import chain
 from random import randint, random
 from types import MappingProxyType
-from typing import (
-    Any,
-    DefaultDict,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    cast,
-)
+from typing import Any, Optional, cast
 
 import pandas as pd
 from openinference.semconv.trace import SpanAttributes
@@ -83,7 +74,7 @@ class Projection(_Base):
     def __call__(self) -> SQLColumnExpression[Any]:
         return self._projector()
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         return {"key": self.key}
 
     @classmethod
@@ -138,7 +129,7 @@ class Explosion(_HasTmpSuffix, Projection):
         object.__setattr__(self, "_array_tmp_col_label", f"__array_tmp_col_{random()}")
 
     @cached_property
-    def index_keys(self) -> List[str]:
+    def index_keys(self) -> list[str]:
         return [self._primary_index.key, f"{self._position_prefix}position"]
 
     def with_primary_index_key(self, _: str) -> "Explosion":
@@ -215,7 +206,7 @@ class Explosion(_HasTmpSuffix, Projection):
             # Because sqlite doesn't support `WITH ORDINALITY`, the order of
             # the returned (table) values is not guaranteed. So we resort to
             # post hoc processing using pandas.
-            def _extract_values(array: List[Any]) -> List[Dict[str, Any]]:
+            def _extract_values(array: list[Any]) -> list[dict[str, Any]]:
                 if not isinstance(array, Iterable):
                     return []
                 if not self.kwargs:
@@ -227,11 +218,11 @@ class Explosion(_HasTmpSuffix, Projection):
                         for i, obj in enumerate(array)
                         if isinstance(obj, Mapping)
                     ]
-                res: List[Dict[str, Any]] = []
+                res: list[dict[str, Any]] = []
                 for i, obj in enumerate(array):
                     if not isinstance(obj, Mapping):
                         continue
-                    values: Dict[str, Any] = {f"{self._position_prefix}position": i}
+                    values: dict[str, Any] = {f"{self._position_prefix}position": i}
                     for name, key in self.kwargs.items():
                         if (value := get_attribute_value(obj, key)) is not None:
                             values[name] = value
@@ -261,7 +252,7 @@ class Explosion(_HasTmpSuffix, Projection):
         df = df.set_index(self.index_keys)
         return df
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         return {
             **super().to_dict(),
             **({"kwargs": dict(self.kwargs)} if self.kwargs else {}),
@@ -384,12 +375,12 @@ class Concatenation(_HasTmpSuffix, Projection):
             # Because SQLite doesn't support `WITH ORDINALITY`, the order of
             # the returned table-values is not guaranteed. So we resort to
             # post hoc processing using pandas.
-            def _concat_values(array: List[Any]) -> Dict[str, Any]:
+            def _concat_values(array: list[Any]) -> dict[str, Any]:
                 if not isinstance(array, Iterable):
                     return {}
                 if not self.kwargs:
                     return {self.key: self.separator.join(str(obj) for obj in array)}
-                values: DefaultDict[str, List[str]] = defaultdict(list)
+                values: defaultdict[str, list[str]] = defaultdict(list)
                 for i, obj in enumerate(array):
                     if not isinstance(obj, Mapping):
                         continue
@@ -407,7 +398,7 @@ class Concatenation(_HasTmpSuffix, Projection):
             assert_never(dialect)
         return df
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         return {
             **super().to_dict(),
             **({"kwargs": dict(self.kwargs)} if self.kwargs else {}),
@@ -619,7 +610,7 @@ class SpanQuery(_HasTmpSuffix):
         df = df.rename(self._rename, axis=1, errors="ignore")
         return df
 
-    def to_dict(self) -> Dict[str, Any]:
+    def to_dict(self) -> dict[str, Any]:
         return {
             **(
                 {"select": {name: proj.to_dict() for name, proj in self._select.items()}}
@@ -771,7 +762,7 @@ def _outer_join(left: pd.DataFrame, right: pd.DataFrame) -> pd.DataFrame:
     return df
 
 
-def _flatten_semantic_conventions(attributes: Mapping[str, Any]) -> Dict[str, Any]:
+def _flatten_semantic_conventions(attributes: Mapping[str, Any]) -> dict[str, Any]:
     # This may be inefficient, but is needed to preserve backward-compatibility.
     # For example, custom attributes do not get flattened.
     ans = unflatten(

phoenix/trace/fixtures.py

@@ -2,6 +2,7 @@ import logging
 import shutil
 from binascii import hexlify
 from collections import defaultdict
+from collections.abc import Iterable, Iterator, Sequence
 from dataclasses import dataclass, field, replace
 from datetime import datetime, timezone
 from io import StringIO
@@ -9,15 +10,8 @@ from random import getrandbits
 from tempfile import NamedTemporaryFile
 from time import sleep, time
 from typing import (
-    DefaultDict,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
     NamedTuple,
     Optional,
-    Sequence,
-    Tuple,
     cast,
 )
 from urllib.parse import urljoin
@@ -280,7 +274,7 @@ random_fixture = TracesFixture(
     file_name="random.jsonl",
 )
 
-TRACES_FIXTURES: List[TracesFixture] = [
+TRACES_FIXTURES: list[TracesFixture] = [
     demo_llama_index_rag_fixture,
     demo_llama_index_rag_llm_fixture,
     demo_langgraph_agent_fixture,
@@ -298,10 +292,10 @@ TRACES_FIXTURES: List[TracesFixture] = [
     anthropic_tools_fixture,
 ]
 
-NAME_TO_TRACES_FIXTURE: Dict[str, TracesFixture] = {
+NAME_TO_TRACES_FIXTURE: dict[str, TracesFixture] = {
     fixture.name: fixture for fixture in TRACES_FIXTURES
 }
-PROJ_NAME_TO_TRACES_FIXTURE: DefaultDict[str, List[TracesFixture]] = defaultdict(list)
+PROJ_NAME_TO_TRACES_FIXTURE: defaultdict[str, list[TracesFixture]] = defaultdict(list)
 for fixture in TRACES_FIXTURES:
     if fixture.project_name:
         PROJ_NAME_TO_TRACES_FIXTURE[fixture.project_name].append(fixture)
@@ -322,7 +316,7 @@ def get_trace_fixture_by_name(fixture_name: str) -> TracesFixture:
     return NAME_TO_TRACES_FIXTURE[fixture_name]
 
 
-def get_trace_fixtures_by_project_name(proj_name: str) -> List[TracesFixture]:
+def get_trace_fixtures_by_project_name(proj_name: str) -> list[TracesFixture]:
     """
     Returns a dictionary of project name (key) and set of TracesFixtures (value)
     whose project name matches the input name.
@@ -437,7 +431,7 @@ def _read_eval_fixture(eval_fixture: EvaluationFixture) -> Iterator[pb.Evaluatio
             explanation=StringValue(value=cast(str, explanation)) if explanation else None,
         )
         if isinstance(eval_fixture, DocumentEvaluationFixture):
-            span_id, document_position = cast(Tuple[str, int], index)
+            span_id, document_position = cast(tuple[str, int], index)
             # Legacy fixture files contain UUID strings for span_ids. The hyphens in these
             # strings need to be removed because we are also removing the hyphens from the
             # span_ids of their corresponding traces. In general, hyphen is not an allowed
@@ -476,10 +470,10 @@ def _url(
 def reset_fixture_span_ids_and_timestamps(
     spans: Iterable[Span],
     evals: Iterable[pb.Evaluation] = (),
-) -> Tuple[List[Span], List[pb.Evaluation]]:
+) -> tuple[list[Span], list[pb.Evaluation]]:
     old_spans, old_evals = list(spans), list(evals)
-    new_trace_ids: Dict[str, str] = {}
-    new_span_ids: Dict[str, str] = {}
+    new_trace_ids: dict[str, str] = {}
+    new_span_ids: dict[str, str] = {}
     for old_span in old_spans:
         new_trace_ids[old_span.context.trace_id] = _new_trace_id()
         new_span_ids[old_span.context.span_id] = _new_span_id()
@@ -495,8 +489,8 @@ def reset_fixture_span_ids_and_timestamps(
             new_span_ids[span_id] = _new_span_id()
     max_end_time = max(old_span.end_time for old_span in old_spans)
     time_diff = datetime.now(timezone.utc) - max_end_time
-    new_spans: List[Span] = []
-    new_evals: List[pb.Evaluation] = []
+    new_spans: list[Span] = []
+    new_evals: list[pb.Evaluation] = []
     for old_span in old_spans:
         new_trace_id = new_trace_ids[old_span.context.trace_id]
         new_span_id = new_span_ids[old_span.context.span_id]

phoenix/trace/otel.py

@@ -1,19 +1,9 @@
 import json
 from binascii import hexlify, unhexlify
+from collections.abc import Iterable, Iterator, Mapping, Sequence
 from datetime import datetime, timezone
 from types import MappingProxyType
-from typing import (
-    Any,
-    Dict,
-    Iterable,
-    Iterator,
-    Mapping,
-    Optional,
-    Sequence,
-    SupportsFloat,
-    Tuple,
-    cast,
-)
+from typing import Any, Optional, SupportsFloat, cast
 
 import numpy as np
 import opentelemetry.proto.trace.v1.trace_pb2 as otlp
@@ -133,7 +123,7 @@ def _decode_unix_nano(time_unix_nano: int) -> datetime:
 
 def _decode_key_values(
     key_values: Iterable[KeyValue],
-) -> Iterator[Tuple[str, Any]]:
+) -> Iterator[tuple[str, Any]]:
     return ((kv.key, _decode_value(kv.value)) for kv in key_values)
 
 
@@ -169,7 +159,7 @@ _STATUS_DECODING = MappingProxyType(
 )
 
 
-def _decode_status(otlp_status: otlp.Status) -> Tuple[SpanStatusCode, StatusMessage]:
+def _decode_status(otlp_status: otlp.Status) -> tuple[SpanStatusCode, StatusMessage]:
     status_code = _STATUS_DECODING.get(otlp_status.code, SpanStatusCode.UNSET)
     return status_code, otlp_status.message
 
@@ -186,7 +176,7 @@ def encode_span_to_otlp(span: Span) -> otlp.Span:
     start_time_unix_nano: int = int(span.start_time.timestamp() * _BILLION)
     end_time_unix_nano: int = int(span.end_time.timestamp() * _BILLION) if span.end_time else 0
 
-    attributes: Dict[str, Any] = dict(span.attributes)
+    attributes: dict[str, Any] = dict(span.attributes)
 
     for key, value in span.attributes.items():
         if value is None:

phoenix/trace/projects.py

@@ -1,5 +1,6 @@
 import types
-from typing import Any, Callable, Optional, Type
+from collections.abc import Callable
+from typing import Any, Optional
 
 from openinference.semconv.resource import ResourceAttributes
 from opentelemetry.sdk import trace
@@ -58,7 +59,7 @@ class using_project:
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
+        exc_type: Optional[type[BaseException]],
         exc_value: Optional[BaseException],
         traceback: Optional[types.TracebackType],
     ) -> None: