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

phoenix/session/data_extractor.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
-from typing import List, Optional, Union, cast
+from typing import Optional, Union, cast
 
 import pandas as pd
 
@@ -28,7 +28,7 @@ class TraceDataExtractor(ABC):
         root_spans_only: Optional[bool] = None,
         project_name: Optional[str] = None,
         timeout: Optional[int] = DEFAULT_TIMEOUT_IN_SECONDS,
-    ) -> Optional[Union[pd.DataFrame, List[pd.DataFrame]]]: ...
+    ) -> Optional[Union[pd.DataFrame, list[pd.DataFrame]]]: ...
 
     def get_spans_dataframe(
         self,
@@ -58,7 +58,7 @@ class TraceDataExtractor(ABC):
     def get_evaluations(
         self,
         project_name: Optional[str] = None,
-    ) -> List[Evaluations]: ...
+    ) -> list[Evaluations]: ...
 
     def get_trace_dataset(
         self,

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
@@ -33,6 +24,7 @@ from phoenix.config import (
     ENV_PHOENIX_PORT,
     ensure_working_dir,
     get_env_database_connection_str,
+    get_env_enable_websockets,
     get_env_host,
     get_env_port,
     get_exported_files,
@@ -88,8 +80,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 +104,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 +149,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 +195,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 +208,7 @@ class Session(TraceDataExtractor, ABC):
 
         Returns
         -------
-            evaluations : List[Evaluations]
+            evaluations : list[Evaluations]
                 A list of evaluations for the specified project.
 
         """
@@ -278,6 +270,7 @@ class ProcessSession(Session):
         self,
         database_url: str,
         primary_inferences: Inferences,
+        enable_websockets: bool,
         reference_inferences: Optional[Inferences] = None,
         corpus_inferences: Optional[Inferences] = None,
         trace_dataset: Optional[TraceDataset] = None,
@@ -328,6 +321,7 @@ class ProcessSession(Session):
             trace_dataset_name=(
                 self.trace_dataset.name if self.trace_dataset is not None else None
             ),
+            enable_websockets=enable_websockets,
         )
 
     @property
@@ -344,6 +338,7 @@ class ThreadSession(Session):
         self,
         database_url: str,
         primary_inferences: Inferences,
+        enable_websockets: bool,
         reference_inferences: Optional[Inferences] = None,
         corpus_inferences: Optional[Inferences] = None,
         trace_dataset: Optional[TraceDataset] = None,
@@ -384,6 +379,7 @@ class ThreadSession(Session):
             export_path=self.export_path,
             model=self.model,
             authentication_enabled=False,
+            enable_websockets=enable_websockets,
             corpus=self.corpus,
             umap_params=self.umap_parameters,
             initial_spans=trace_dataset.to_spans() if trace_dataset else None,
@@ -447,6 +443,7 @@ def launch_app(
     run_in_thread: bool = True,
     notebook_environment: Optional[Union[NotebookEnvironment, str]] = None,
     use_temp_dir: bool = True,
+    enable_websockets: Optional[bool] = None,
 ) -> Optional[Session]:
     """
     Launches the phoenix application and returns a session to interact with.
@@ -471,7 +468,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
@@ -481,7 +478,8 @@ def launch_app(
     use_temp_dir: bool, optional, default=True
         Whether to use a temporary directory to store the data. If set to False, the data will be
         stored in the directory specified by PHOENIX_WORKING_DIR environment variable via SQLite.
-
+    enable_websockets: bool, optional, default=False
+        Whether to enable websockets.
 
     Returns
     -------
@@ -562,10 +560,16 @@ def launch_app(
     else:
         database_url = get_env_database_connection_str()
 
+    enable_websockets_env = get_env_enable_websockets() or False
+    enable_websockets = (
+        enable_websockets if enable_websockets is not None else enable_websockets_env
+    )
+
     if run_in_thread:
         _session = ThreadSession(
             database_url,
             primary,
+            enable_websockets,
             reference,
             corpus,
             trace,
@@ -579,6 +583,7 @@ def launch_app(
         _session = ProcessSession(
             database_url,
             primary,
+            enable_websockets,
             reference,
             corpus,
             trace,
@@ -638,7 +643,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 +661,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(