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

phoenix/db/insertion/dataset.py

@@ -1,20 +1,10 @@
 import logging
+from collections.abc import Awaitable, Iterable, Iterator, Mapping
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from enum import Enum
 from itertools import chain
-from typing import (
-    Any,
-    Awaitable,
-    Dict,
-    FrozenSet,
-    Iterable,
-    Iterator,
-    Mapping,
-    Optional,
-    Union,
-    cast,
-)
+from typing import Any, Optional, Union, cast
 
 from sqlalchemy import insert, select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -34,9 +24,9 @@ SpanRowId: TypeAlias = int
 
 @dataclass(frozen=True)
 class ExampleContent:
-    input: Dict[str, Any] = field(default_factory=dict)
-    output: Dict[str, Any] = field(default_factory=dict)
-    metadata: Dict[str, Any] = field(default_factory=dict)
+    input: dict[str, Any] = field(default_factory=dict)
+    output: dict[str, Any] = field(default_factory=dict)
+    metadata: dict[str, Any] = field(default_factory=dict)
 
 
 Examples: TypeAlias = Iterable[ExampleContent]
@@ -220,14 +210,14 @@ async def add_dataset_examples(
 
 @dataclass(frozen=True)
 class DatasetKeys:
-    input: FrozenSet[str]
-    output: FrozenSet[str]
-    metadata: FrozenSet[str]
+    input: frozenset[str]
+    output: frozenset[str]
+    metadata: frozenset[str]
 
     def __iter__(self) -> Iterator[str]:
         yield from sorted(set(chain(self.input, self.output, self.metadata)))
 
-    def check_differences(self, column_headers_set: FrozenSet[str]) -> None:
+    def check_differences(self, column_headers_set: frozenset[str]) -> None:
         for category, keys in (
             ("input", self.input),
             ("output", self.output),

phoenix/db/insertion/document_annotation.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from datetime import datetime
-from typing import Any, List, Mapping, NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional
 
 from sqlalchemy import Row, Select, and_, select, tuple_
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -24,9 +25,9 @@ _DocumentPosition: TypeAlias = int
 _AnnoRowId: TypeAlias = int
 _NumDocs: TypeAlias = int
 
-_Key: TypeAlias = Tuple[_Name, _SpanId, _DocumentPosition]
-_UniqueBy: TypeAlias = Tuple[_Name, _SpanRowId, _DocumentPosition]
-_Existing: TypeAlias = Tuple[
+_Key: TypeAlias = tuple[_Name, _SpanId, _DocumentPosition]
+_UniqueBy: TypeAlias = tuple[_Name, _SpanRowId, _DocumentPosition]
+_Existing: TypeAlias = tuple[
     _SpanRowId,
     _SpanId,
     _NumDocs,
@@ -51,7 +52,7 @@ class DocumentAnnotationQueueInserter(
         self,
         session: AsyncSession,
         *insertions: Insertables.DocumentAnnotation,
-    ) -> List[DocumentAnnotationDmlEvent]:
+    ) -> list[DocumentAnnotationDmlEvent]:
         records = [dict(as_kv(ins.row)) for ins in insertions]
         stmt = self._insert_on_conflict(*records).returning(self.table.id)
         ids = tuple([_ async for _ in await session.stream_scalars(stmt)])
@@ -61,17 +62,17 @@ class DocumentAnnotationQueueInserter(
         self,
         session: AsyncSession,
         *parcels: Received[Precursors.DocumentAnnotation],
-    ) -> Tuple[
-        List[Received[Insertables.DocumentAnnotation]],
-        List[Postponed[Precursors.DocumentAnnotation]],
-        List[Received[Precursors.DocumentAnnotation]],
+    ) -> tuple[
+        list[Received[Insertables.DocumentAnnotation]],
+        list[Postponed[Precursors.DocumentAnnotation]],
+        list[Received[Precursors.DocumentAnnotation]],
     ]:
-        to_insert: List[Received[Insertables.DocumentAnnotation]] = []
-        to_postpone: List[Postponed[Precursors.DocumentAnnotation]] = []
-        to_discard: List[Received[Precursors.DocumentAnnotation]] = []
+        to_insert: list[Received[Insertables.DocumentAnnotation]] = []
+        to_postpone: list[Postponed[Precursors.DocumentAnnotation]] = []
+        to_discard: list[Received[Precursors.DocumentAnnotation]] = []
 
         stmt = self._select_existing(*map(_key, parcels))
-        existing: List[Row[_Existing]] = [_ async for _ in await session.stream(stmt)]
+        existing: list[Row[_Existing]] = [_ async for _ in await session.stream(stmt)]
         existing_spans: Mapping[str, _SpanAttr] = {
             e.span_id: _SpanAttr(e.span_rowid, e.num_docs) for e in existing
         }

phoenix/db/insertion/helpers.py

@@ -1,17 +1,7 @@
 from abc import ABC
+from collections.abc import Awaitable, Callable, Iterable, Iterator, Mapping, Sequence
 from enum import Enum, auto
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Iterable,
-    Iterator,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-)
+from typing import Any, Optional
 
 from sqlalchemy import Insert
 from sqlalchemy.dialects.postgresql import insert as insert_postgresql
@@ -41,7 +31,7 @@ class OnConflict(Enum):
 
 def insert_on_conflict(
     *records: Mapping[str, Any],
-    table: Type[Base],
+    table: type[Base],
     dialect: SupportedSQLDialect,
     unique_by: Sequence[str],
     on_conflict: OnConflict = OnConflict.DO_UPDATE,
@@ -85,8 +75,8 @@ def insert_on_conflict(
 
 
 def _clean(
-    kv: Iterable[Tuple[str, KeyedColumnElement[Any]]],
-) -> Iterator[Tuple[str, KeyedColumnElement[Any]]]:
+    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
@@ -96,7 +86,7 @@ def _clean(
             yield k, v
 
 
-def as_kv(obj: models.Base) -> Iterator[Tuple[str, Any]]:
+def as_kv(obj: models.Base) -> Iterator[tuple[str, Any]]:
     for k, c in obj.__table__.c.items():
         if k in ["created_at", "updated_at"]:
             continue

phoenix/db/insertion/span_annotation.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from datetime import datetime
-from typing import Any, List, Mapping, NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional
 
 from sqlalchemy import Row, Select, and_, select, tuple_
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -22,9 +23,9 @@ _SpanId: TypeAlias = str
 _SpanRowId: TypeAlias = int
 _AnnoRowId: TypeAlias = int
 
-_Key: TypeAlias = Tuple[_Name, _SpanId]
-_UniqueBy: TypeAlias = Tuple[_Name, _SpanRowId]
-_Existing: TypeAlias = Tuple[
+_Key: TypeAlias = tuple[_Name, _SpanId]
+_UniqueBy: TypeAlias = tuple[_Name, _SpanRowId]
+_Existing: TypeAlias = tuple[
     _SpanRowId,
     _SpanId,
     Optional[_AnnoRowId],
@@ -47,7 +48,7 @@ class SpanAnnotationQueueInserter(
         self,
         session: AsyncSession,
         *insertions: Insertables.SpanAnnotation,
-    ) -> List[SpanAnnotationDmlEvent]:
+    ) -> list[SpanAnnotationDmlEvent]:
         records = [dict(as_kv(ins.row)) for ins in insertions]
         stmt = self._insert_on_conflict(*records).returning(self.table.id)
         ids = tuple([_ async for _ in await session.stream_scalars(stmt)])
@@ -57,17 +58,17 @@ class SpanAnnotationQueueInserter(
         self,
         session: AsyncSession,
         *parcels: Received[Precursors.SpanAnnotation],
-    ) -> Tuple[
-        List[Received[Insertables.SpanAnnotation]],
-        List[Postponed[Precursors.SpanAnnotation]],
-        List[Received[Precursors.SpanAnnotation]],
+    ) -> tuple[
+        list[Received[Insertables.SpanAnnotation]],
+        list[Postponed[Precursors.SpanAnnotation]],
+        list[Received[Precursors.SpanAnnotation]],
     ]:
-        to_insert: List[Received[Insertables.SpanAnnotation]] = []
-        to_postpone: List[Postponed[Precursors.SpanAnnotation]] = []
-        to_discard: List[Received[Precursors.SpanAnnotation]] = []
+        to_insert: list[Received[Insertables.SpanAnnotation]] = []
+        to_postpone: list[Postponed[Precursors.SpanAnnotation]] = []
+        to_discard: list[Received[Precursors.SpanAnnotation]] = []
 
         stmt = self._select_existing(*map(_key, parcels))
-        existing: List[Row[_Existing]] = [_ async for _ in await session.stream(stmt)]
+        existing: list[Row[_Existing]] = [_ async for _ in await session.stream(stmt)]
         existing_spans: Mapping[str, _SpanAttr] = {
             e.span_id: _SpanAttr(e.span_rowid) for e in existing
         }

phoenix/db/insertion/trace_annotation.py

@@ -1,5 +1,6 @@
+from collections.abc import Mapping
 from datetime import datetime
-from typing import Any, List, Mapping, NamedTuple, Optional, Tuple
+from typing import Any, NamedTuple, Optional
 
 from sqlalchemy import Row, Select, and_, select, tuple_
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -22,9 +23,9 @@ _TraceId: TypeAlias = str
 _TraceRowId: TypeAlias = int
 _AnnoRowId: TypeAlias = int
 
-_Key: TypeAlias = Tuple[_Name, _TraceId]
-_UniqueBy: TypeAlias = Tuple[_Name, _TraceRowId]
-_Existing: TypeAlias = Tuple[
+_Key: TypeAlias = tuple[_Name, _TraceId]
+_UniqueBy: TypeAlias = tuple[_Name, _TraceRowId]
+_Existing: TypeAlias = tuple[
     _TraceRowId,
     _TraceId,
     Optional[_AnnoRowId],
@@ -47,7 +48,7 @@ class TraceAnnotationQueueInserter(
         self,
         session: AsyncSession,
         *insertions: Insertables.TraceAnnotation,
-    ) -> List[TraceAnnotationDmlEvent]:
+    ) -> list[TraceAnnotationDmlEvent]:
         records = [dict(as_kv(ins.row)) for ins in insertions]
         stmt = self._insert_on_conflict(*records).returning(self.table.id)
         ids = tuple([_ async for _ in await session.stream_scalars(stmt)])
@@ -57,17 +58,17 @@ class TraceAnnotationQueueInserter(
         self,
         session: AsyncSession,
         *parcels: Received[Precursors.TraceAnnotation],
-    ) -> Tuple[
-        List[Received[Insertables.TraceAnnotation]],
-        List[Postponed[Precursors.TraceAnnotation]],
-        List[Received[Precursors.TraceAnnotation]],
+    ) -> tuple[
+        list[Received[Insertables.TraceAnnotation]],
+        list[Postponed[Precursors.TraceAnnotation]],
+        list[Received[Precursors.TraceAnnotation]],
     ]:
-        to_insert: List[Received[Insertables.TraceAnnotation]] = []
-        to_postpone: List[Postponed[Precursors.TraceAnnotation]] = []
-        to_discard: List[Received[Precursors.TraceAnnotation]] = []
+        to_insert: list[Received[Insertables.TraceAnnotation]] = []
+        to_postpone: list[Postponed[Precursors.TraceAnnotation]] = []
+        to_discard: list[Received[Precursors.TraceAnnotation]] = []
 
         stmt = self._select_existing(*map(_key, parcels))
-        existing: List[Row[_Existing]] = [_ async for _ in await session.stream(stmt)]
+        existing: list[Row[_Existing]] = [_ async for _ in await session.stream(stmt)]
         existing_traces: Mapping[str, _TraceAttr] = {
             e.trace_id: _TraceAttr(e.trace_rowid) for e in existing
         }

phoenix/db/insertion/types.py

@@ -3,22 +3,11 @@ from __future__ import annotations
 import asyncio
 import logging
 from abc import ABC, abstractmethod
+from collections.abc import Mapping, Sequence
 from copy import copy
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import (
-    Any,
-    Generic,
-    List,
-    Mapping,
-    Optional,
-    Protocol,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-    cast,
-)
+from typing import Any, Generic, Optional, Protocol, TypeVar, cast
 
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.sql.dml import Insert
@@ -59,12 +48,12 @@ class Postponed(Received[_AnyT]):
 
 
 class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
-    table: Type[_RowT]
+    table: type[_RowT]
     unique_by: Sequence[str]
 
     def __init_subclass__(
         cls,
-        table: Type[_RowT],
+        table: type[_RowT],
         unique_by: Sequence[str],
     ) -> None:
         cls.table = table
@@ -76,7 +65,7 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
         retry_delay_sec: float = DEFAULT_RETRY_DELAY_SEC,
         retry_allowance: int = DEFAULT_RETRY_ALLOWANCE,
     ) -> None:
-        self._queue: List[Received[_PrecursorT]] = []
+        self._queue: list[Received[_PrecursorT]] = []
         self._db = db
         self._retry_delay_sec = retry_delay_sec
         self._retry_allowance = retry_allowance
@@ -93,17 +82,17 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
         self,
         session: AsyncSession,
         *parcels: Received[_PrecursorT],
-    ) -> Tuple[
-        List[Received[_InsertableT]],
-        List[Postponed[_PrecursorT]],
-        List[Received[_PrecursorT]],
+    ) -> tuple[
+        list[Received[_InsertableT]],
+        list[Postponed[_PrecursorT]],
+        list[Received[_PrecursorT]],
     ]: ...
 
-    async def insert(self) -> Optional[List[_DmlEventT]]:
+    async def insert(self) -> Optional[list[_DmlEventT]]:
         if not self._queue:
             return None
         self._queue, parcels = [], self._queue
-        events: List[_DmlEventT] = []
+        events: list[_DmlEventT] = []
         async with self._db() as session:
             to_insert, to_postpone, _ = await self._partition(session, *parcels)
             if to_insert:
@@ -128,20 +117,20 @@ class QueueInserter(ABC, Generic[_PrecursorT, _InsertableT, _RowT, _DmlEventT]):
         self,
         session: AsyncSession,
         *insertions: _InsertableT,
-    ) -> List[_DmlEventT]: ...
+    ) -> list[_DmlEventT]: ...
 
     async def _insert(
         self,
         session: AsyncSession,
         *parcels: Received[_InsertableT],
-    ) -> Tuple[
-        List[_DmlEventT],
-        List[Postponed[_PrecursorT]],
-        List[Received[_InsertableT]],
+    ) -> tuple[
+        list[_DmlEventT],
+        list[Postponed[_PrecursorT]],
+        list[Received[_InsertableT]],
     ]:
-        to_retry: List[Postponed[_PrecursorT]] = []
-        failures: List[Received[_InsertableT]] = []
-        events: List[_DmlEventT] = []
+        to_retry: list[Postponed[_PrecursorT]] = []
+        failures: list[Received[_InsertableT]] = []
+        events: list[_DmlEventT] = []
         try:
             async with session.begin_nested():
                 events.extend(await self._events(session, *(p.item for p in parcels)))

phoenix/db/migrations/versions/3be8647b87d8_add_token_columns_to_spans_table.py

@@ -6,7 +6,7 @@ Create Date: 2024-08-03 22:11:28.733133
 
 """
 
-from typing import Any, Dict, List, Optional, Sequence, TypedDict, Union
+from typing import Any, Optional, Sequence, TypedDict, Union
 
 import sqlalchemy as sa
 from alembic import op
@@ -51,21 +51,21 @@ JSON_ = (
 )
 
 
-class JsonDict(TypeDecorator[Dict[str, Any]]):
+class JsonDict(TypeDecorator[dict[str, Any]]):
     # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
     cache_ok = True
     impl = JSON_
 
-    def process_bind_param(self, value: Optional[Dict[str, Any]], _: Dialect) -> Dict[str, Any]:
+    def process_bind_param(self, value: Optional[dict[str, Any]], _: Dialect) -> dict[str, Any]:
         return value if isinstance(value, dict) else {}
 
 
-class JsonList(TypeDecorator[List[Any]]):
+class JsonList(TypeDecorator[list[Any]]):
     # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
     cache_ok = True
     impl = JSON_
 
-    def process_bind_param(self, value: Optional[List[Any]], _: Dialect) -> List[Any]:
+    def process_bind_param(self, value: Optional[list[Any]], _: Dialect) -> list[Any]:
         return value if isinstance(value, list) else []
 
 
@@ -86,8 +86,8 @@ class Base(DeclarativeBase):
         }
     )
     type_annotation_map = {
-        Dict[str, Any]: JsonDict,
-        List[Dict[str, Any]]: JsonList,
+        dict[str, Any]: JsonDict,
+        list[dict[str, Any]]: JsonList,
         ExperimentRunOutput: JsonDict,
     }
 
@@ -95,7 +95,7 @@ class Base(DeclarativeBase):
 class Span(Base):
     __tablename__ = "spans"
     id: Mapped[int] = mapped_column(primary_key=True)
-    attributes: Mapped[Dict[str, Any]]
+    attributes: Mapped[dict[str, Any]]
     llm_token_count_prompt: Mapped[Optional[int]]
     llm_token_count_completion: Mapped[Optional[int]]
 

phoenix/db/models.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Dict, List, Optional, TypedDict
+from typing import Any, Optional, TypedDict
 
 from sqlalchemy import (
     JSON,
@@ -69,21 +69,21 @@ JSON_ = (
 )
 
 
-class JsonDict(TypeDecorator[Dict[str, Any]]):
+class JsonDict(TypeDecorator[dict[str, Any]]):
     # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
     cache_ok = True
     impl = JSON_
 
-    def process_bind_param(self, value: Optional[Dict[str, Any]], _: Dialect) -> Dict[str, Any]:
+    def process_bind_param(self, value: Optional[dict[str, Any]], _: Dialect) -> dict[str, Any]:
         return value if isinstance(value, dict) else {}
 
 
-class JsonList(TypeDecorator[List[Any]]):
+class JsonList(TypeDecorator[list[Any]]):
     # See # See https://docs.sqlalchemy.org/en/20/core/custom_types.html
     cache_ok = True
     impl = JSON_
 
-    def process_bind_param(self, value: Optional[List[Any]], _: Dialect) -> List[Any]:
+    def process_bind_param(self, value: Optional[list[Any]], _: Dialect) -> list[Any]:
         return value if isinstance(value, list) else []
 
 
@@ -117,8 +117,8 @@ class Base(DeclarativeBase):
         },
     )
     type_annotation_map = {
-        Dict[str, Any]: JsonDict,
-        List[Dict[str, Any]]: JsonList,
+        dict[str, Any]: JsonDict,
+        list[dict[str, Any]]: JsonList,
         ExperimentRunOutput: JsonDict,
     }
 
@@ -142,7 +142,7 @@ class Project(Base):
         UtcTimeStamp, server_default=func.now(), onupdate=func.now()
     )
 
-    traces: WriteOnlyMapped[List["Trace"]] = relationship(
+    traces: WriteOnlyMapped[list["Trace"]] = relationship(
         "Trace",
         back_populates="project",
         cascade="all, delete-orphan",
@@ -182,13 +182,13 @@ class Trace(Base):
         "Project",
         back_populates="traces",
     )
-    spans: Mapped[List["Span"]] = relationship(
+    spans: Mapped[list["Span"]] = relationship(
         "Span",
         back_populates="trace",
         cascade="all, delete-orphan",
         uselist=True,
     )
-    experiment_runs: Mapped[List["ExperimentRun"]] = relationship(
+    experiment_runs: Mapped[list["ExperimentRun"]] = relationship(
         primaryjoin="foreign(ExperimentRun.trace_id) == Trace.trace_id",
         back_populates="trace",
     )
@@ -212,8 +212,8 @@ class Span(Base):
     span_kind: Mapped[str]
     start_time: Mapped[datetime] = mapped_column(UtcTimeStamp, index=True)
     end_time: Mapped[datetime] = mapped_column(UtcTimeStamp)
-    attributes: Mapped[Dict[str, Any]]
-    events: Mapped[List[Dict[str, Any]]]
+    attributes: Mapped[dict[str, Any]]
+    events: Mapped[list[dict[str, Any]]]
     status_code: Mapped[str] = mapped_column(
         CheckConstraint("status_code IN ('OK', 'ERROR', 'UNSET')", name="valid_status")
     )
@@ -248,8 +248,8 @@ class Span(Base):
         return (self.llm_token_count_prompt or 0) + (self.llm_token_count_completion or 0)
 
     trace: Mapped["Trace"] = relationship("Trace", back_populates="spans")
-    document_annotations: Mapped[List["DocumentAnnotation"]] = relationship(back_populates="span")
-    dataset_examples: Mapped[List["DatasetExample"]] = relationship(back_populates="span")
+    document_annotations: Mapped[list["DocumentAnnotation"]] = relationship(back_populates="span")
+    dataset_examples: Mapped[list["DatasetExample"]] = relationship(back_populates="span")
 
     __table_args__ = (
         UniqueConstraint(
@@ -351,7 +351,7 @@ class SpanAnnotation(Base):
     label: Mapped[Optional[str]] = mapped_column(String, index=True)
     score: Mapped[Optional[float]] = mapped_column(Float, index=True)
     explanation: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     annotator_kind: Mapped[str] = mapped_column(
         CheckConstraint("annotator_kind IN ('LLM', 'HUMAN')", name="valid_annotator_kind"),
     )
@@ -378,7 +378,7 @@ class TraceAnnotation(Base):
     label: Mapped[Optional[str]] = mapped_column(String, index=True)
     score: Mapped[Optional[float]] = mapped_column(Float, index=True)
     explanation: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     annotator_kind: Mapped[str] = mapped_column(
         CheckConstraint("annotator_kind IN ('LLM', 'HUMAN')", name="valid_annotator_kind"),
     )
@@ -406,7 +406,7 @@ class DocumentAnnotation(Base):
     label: Mapped[Optional[str]] = mapped_column(String, index=True)
     score: Mapped[Optional[float]] = mapped_column(Float, index=True)
     explanation: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     annotator_kind: Mapped[str] = mapped_column(
         CheckConstraint("annotator_kind IN ('LLM', 'HUMAN')", name="valid_annotator_kind"),
     )
@@ -430,7 +430,7 @@ class Dataset(Base):
     id: Mapped[int] = mapped_column(primary_key=True)
     name: Mapped[str] = mapped_column(unique=True)
     description: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
     updated_at: Mapped[datetime] = mapped_column(
         UtcTimeStamp, server_default=func.now(), onupdate=func.now()
@@ -493,7 +493,7 @@ class DatasetVersion(Base):
         index=True,
     )
     description: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
 
 
@@ -525,9 +525,9 @@ class DatasetExampleRevision(Base):
         ForeignKey("dataset_versions.id", ondelete="CASCADE"),
         index=True,
     )
-    input: Mapped[Dict[str, Any]]
-    output: Mapped[Dict[str, Any]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    input: Mapped[dict[str, Any]]
+    output: Mapped[dict[str, Any]]
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     revision_kind: Mapped[str] = mapped_column(
         CheckConstraint(
             "revision_kind IN ('CREATE', 'PATCH', 'DELETE')", name="valid_revision_kind"
@@ -557,7 +557,7 @@ class Experiment(Base):
     name: Mapped[str]
     description: Mapped[Optional[str]]
     repetitions: Mapped[int]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     project_name: Mapped[Optional[str]] = mapped_column(index=True)
     created_at: Mapped[datetime] = mapped_column(UtcTimeStamp, server_default=func.now())
     updated_at: Mapped[datetime] = mapped_column(
@@ -615,7 +615,7 @@ class ExperimentRunAnnotation(Base):
     explanation: Mapped[Optional[str]]
     trace_id: Mapped[Optional[str]]
     error: Mapped[Optional[str]]
-    metadata_: Mapped[Dict[str, Any]] = mapped_column("metadata")
+    metadata_: Mapped[dict[str, Any]] = mapped_column("metadata")
     start_time: Mapped[datetime] = mapped_column(UtcTimeStamp)
     end_time: Mapped[datetime] = mapped_column(UtcTimeStamp)
 
@@ -631,7 +631,7 @@ class UserRole(Base):
     __tablename__ = "user_roles"
     id: Mapped[int] = mapped_column(primary_key=True)
     name: Mapped[str] = mapped_column(unique=True, index=True)
-    users: Mapped[List["User"]] = relationship("User", back_populates="role")
+    users: Mapped[list["User"]] = relationship("User", back_populates="role")
 
 
 class User(Base):
@@ -659,11 +659,11 @@ class User(Base):
         back_populates="user",
         uselist=False,
     )
-    access_tokens: Mapped[List["AccessToken"]] = relationship("AccessToken", back_populates="user")
-    refresh_tokens: Mapped[List["RefreshToken"]] = relationship(
+    access_tokens: Mapped[list["AccessToken"]] = relationship("AccessToken", back_populates="user")
+    refresh_tokens: Mapped[list["RefreshToken"]] = relationship(
         "RefreshToken", back_populates="user"
     )
-    api_keys: Mapped[List["ApiKey"]] = relationship("ApiKey", back_populates="user")
+    api_keys: Mapped[list["ApiKey"]] = relationship("ApiKey", back_populates="user")
 
     @hybrid_property
     def auth_method(self) -> Optional[str]:

phoenix/experiments/evaluators/base.py

@@ -1,8 +1,9 @@
 import functools
 import inspect
 from abc import ABC
+from collections.abc import Awaitable, Callable
 from types import MappingProxyType
-from typing import Any, Awaitable, Callable, Optional, Union
+from typing import Any, Optional, Union
 
 from typing_extensions import TypeAlias
 

phoenix/experiments/evaluators/code_evaluators.py

@@ -4,7 +4,6 @@ import json
 import re
 from typing import (
     Any,
-    List,
     Optional,
     Pattern,  # import from re module when we drop support for 3.8
     Union,
@@ -78,7 +77,7 @@ class ContainsAnyKeyword(CodeEvaluator):
     An evaluator that checks if any of the keywords are present in the output of an experiment run.
 
     Args:
-        keywords (List[str]): The keywords to search for in the output.
+        keywords (list[str]): The keywords to search for in the output.
         name (str, optional): An optional name for the evaluator. Defaults to
             "ContainsAny(<keywords>)".
 
@@ -91,7 +90,7 @@ class ContainsAnyKeyword(CodeEvaluator):
             run_experiment(dataset, task, evaluators=[ContainsAnyKeyword(["foo", "bar"])])
     """
 
-    def __init__(self, keywords: List[str], name: Optional[str] = None) -> None:
+    def __init__(self, keywords: list[str], name: Optional[str] = None) -> None:
         self.keywords = keywords
         self._name = name or f"ContainsAny({keywords})"
 
@@ -113,7 +112,7 @@ class ContainsAllKeywords(CodeEvaluator):
     An evaluator that checks if all of the keywords are present in the output of an experiment run.
 
     Args:
-        keywords (List[str]): The keywords to search for in the output.
+        keywords (list[str]): The keywords to search for in the output.
         name (str, optional): An optional name for the evaluator. Defaults to
             "ContainsAll(<keywords>)".
 
@@ -126,7 +125,7 @@ class ContainsAllKeywords(CodeEvaluator):
             run_experiment(dataset, task, evaluators=[ContainsAllKeywords(["foo", "bar"])])
     """
 
-    def __init__(self, keywords: List[str], name: Optional[str] = None) -> None:
+    def __init__(self, keywords: list[str], name: Optional[str] = None) -> None:
         self.keywords = keywords
         self._name = name or f"ContainsAll({keywords})"