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

phoenix/server/api/types/User.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List, Optional
+from typing import Optional
 
 import strawberry
 from sqlalchemy import select
@@ -35,7 +35,7 @@ class User(Node):
         return to_gql_user_role(role)
 
     @strawberry.field
-    async def api_keys(self, info: Info[Context, None]) -> List[UserApiKey]:
+    async def api_keys(self, info: Info[Context, None]) -> list[UserApiKey]:
         async with info.context.db() as session:
             api_keys = await session.scalars(
                 select(models.ApiKey).where(models.ApiKey.user_id == self.id_attr)
@@ -43,7 +43,7 @@ class User(Node):
         return [to_gql_api_key(api_key) for api_key in api_keys]
 
 
-def to_gql_user(user: models.User, api_keys: Optional[List[models.ApiKey]] = None) -> User:
+def to_gql_user(user: models.User, api_keys: Optional[list[models.ApiKey]] = None) -> User:
     """
     Converts an ORM user to a GraphQL user.
     """

phoenix/server/api/types/node.py

@@ -1,9 +1,7 @@
-from typing import Tuple
-
 from strawberry.relay import GlobalID
 
 
-def from_global_id(global_id: GlobalID) -> Tuple[str, int]:
+def from_global_id(global_id: GlobalID) -> tuple[str, int]:
     """
     Decode the given global id into a type and id.
 

phoenix/server/api/types/pagination.py

@@ -2,7 +2,7 @@ import base64
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum, auto
-from typing import Any, ClassVar, List, Optional, Tuple, Union
+from typing import Any, ClassVar, Optional, Union
 
 from strawberry import UNSET
 from strawberry.relay.types import Connection, Edge, NodeType, PageInfo
@@ -176,7 +176,7 @@ class ConnectionArgs:
 
 
 def connection_from_list(
-    data: List[NodeType],
+    data: list[NodeType],
     args: ConnectionArgs,
 ) -> Connection[NodeType]:
     """
@@ -188,7 +188,7 @@ def connection_from_list(
 
 
 def connection_from_list_slice(
-    list_slice: List[NodeType],
+    list_slice: list[NodeType],
     args: ConnectionArgs,
     slice_start: int,
     list_length: int,
@@ -254,7 +254,7 @@ def connection_from_list_slice(
 
 
 def connection_from_cursors_and_nodes(
-    cursors_and_nodes: List[Tuple[Any, NodeType]],
+    cursors_and_nodes: list[tuple[Any, NodeType]],
     has_previous_page: bool,
     has_next_page: bool,
 ) -> Connection[NodeType]:

phoenix/server/api/utils.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from sqlalchemy import delete
 
 from phoenix.db import models
@@ -9,7 +7,7 @@ from phoenix.server.types import DbSessionFactory
 async def delete_projects(
     db: DbSessionFactory,
     *project_names: str,
-) -> List[int]:
+) -> list[int]:
     if not project_names:
         return []
     stmt = (
@@ -24,7 +22,7 @@ async def delete_projects(
 async def delete_traces(
     db: DbSessionFactory,
     *trace_ids: str,
-) -> List[int]:
+) -> list[int]:
     if not trace_ids:
         return []
     stmt = (

phoenix/server/app.py

@@ -2,7 +2,8 @@ import asyncio
 import contextlib
 import json
 import logging
-from contextlib import AsyncExitStack
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
+from contextlib import AbstractAsyncContextManager, AsyncExitStack
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from functools import cached_property
@@ -11,18 +12,8 @@ from types import MethodType
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncContextManager,
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    Dict,
-    Iterable,
-    List,
     NamedTuple,
     Optional,
-    Sequence,
-    Tuple,
-    Type,
     TypedDict,
     Union,
     cast,
@@ -188,10 +179,10 @@ class Static(StaticFiles):
         super().__init__(**kwargs)
 
     @cached_property
-    def _web_manifest(self) -> Dict[str, Any]:
+    def _web_manifest(self) -> dict[str, Any]:
         try:
             with open(self._app_config.web_manifest_path, "r") as f:
-                return cast(Dict[str, Any], json.load(f))
+                return cast(dict[str, Any], json.load(f))
         except FileNotFoundError as e:
             if self._app_config.is_development:
                 return {}
@@ -233,7 +224,7 @@ class Static(StaticFiles):
 
 
 class RequestOriginHostnameValidator(BaseHTTPMiddleware):
-    def __init__(self, trusted_hostnames: List[str], *args: Any, **kwargs: Any) -> None:
+    def __init__(self, trusted_hostnames: list[str], *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._trusted_hostnames = trusted_hostnames
 
@@ -278,7 +269,7 @@ DB_MUTEX: Optional[asyncio.Lock] = None
 
 def _db(
     engine: AsyncEngine, bypass_lock: bool = False
-) -> Callable[[], AsyncContextManager[AsyncSession]]:
+) -> Callable[[], AbstractAsyncContextManager[AsyncSession]]:
     Session = async_sessionmaker(engine, expire_on_commit=False)
 
     @contextlib.asynccontextmanager
@@ -420,7 +411,7 @@ def _lifespan(
     scaffolder_config: Optional[ScaffolderConfig] = None,
 ) -> StatefulLifespan[FastAPI]:
     @contextlib.asynccontextmanager
-    async def lifespan(_: FastAPI) -> AsyncIterator[Dict[str, Any]]:
+    async def lifespan(_: FastAPI) -> AsyncIterator[dict[str, Any]]:
         for callback in startup_callbacks:
             if isinstance((res := callback()), Awaitable):
                 await res
@@ -449,7 +440,7 @@ def _lifespan(
                     queue_evaluation=queue_evaluation,
                 )
                 await stack.enter_async_context(scaffolder)
-            if isinstance(token_store, AsyncContextManager):
+            if isinstance(token_store, AbstractAsyncContextManager):
                 await stack.enter_async_context(token_store)
             yield {
                 "event_queue": dml_event_handler,
@@ -607,7 +598,7 @@ def create_engine_and_run_migrations(
         raise PhoenixMigrationError(msg) from e
 
 
-def instrument_engine_if_enabled(engine: AsyncEngine) -> List[Callable[[], None]]:
+def instrument_engine_if_enabled(engine: AsyncEngine) -> list[Callable[[], None]]:
     instrumentation_cleanups = []
     if server_instrumentation_is_enabled():
         from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
@@ -667,7 +658,7 @@ def create_app(
     dev: bool = False,
     read_only: bool = False,
     enable_prometheus: bool = False,
-    initial_spans: Optional[Iterable[Union[Span, Tuple[Span, str]]]] = None,
+    initial_spans: Optional[Iterable[Union[Span, tuple[Span, str]]]] = None,
     initial_evaluations: Optional[Iterable[pb.Evaluation]] = None,
     serve_ui: bool = True,
     startup_callbacks: Iterable[_Callback] = (),
@@ -678,7 +669,7 @@ def create_app(
     refresh_token_expiry: Optional[timedelta] = None,
     scaffolder_config: Optional[ScaffolderConfig] = None,
     email_sender: Optional[EmailSender] = None,
-    oauth2_client_configs: Optional[List[OAuth2ClientConfig]] = None,
+    oauth2_client_configs: Optional[list[OAuth2ClientConfig]] = None,
     bulk_inserter_factory: Optional[Callable[..., BulkInserter]] = None,
 ) -> FastAPI:
     if model.embedding_dimensions:
@@ -692,10 +683,10 @@ def create_app(
             ) from exc
     logger.info(f"Server umap params: {umap_params}")
     bulk_inserter_factory = bulk_inserter_factory or BulkInserter
-    startup_callbacks_list: List[_Callback] = list(startup_callbacks)
-    shutdown_callbacks_list: List[_Callback] = list(shutdown_callbacks)
+    startup_callbacks_list: list[_Callback] = list(startup_callbacks)
+    shutdown_callbacks_list: list[_Callback] = list(shutdown_callbacks)
     startup_callbacks_list.append(Facilitator(db=db))
-    initial_batch_of_spans: Iterable[Tuple[Span, str]] = (
+    initial_batch_of_spans: Iterable[tuple[Span, str]] = (
         ()
         if initial_spans is None
         else (
@@ -708,7 +699,7 @@ def create_app(
         CacheForDataLoaders() if db.dialect is SupportedSQLDialect.SQLITE else None
     )
     last_updated_at = LastUpdatedAt()
-    middlewares: List[Middleware] = [Middleware(HeadersMiddleware)]
+    middlewares: list[Middleware] = [Middleware(HeadersMiddleware)]
     if origins := get_env_csrf_trusted_origins():
         trusted_hostnames = [h for o in origins if o and (h := urlparse(o).hostname)]
         middlewares.append(Middleware(RequestOriginHostnameValidator, trusted_hostnames))
@@ -742,7 +733,7 @@ def create_app(
         initial_batch_of_evaluations=initial_batch_of_evaluations,
     )
     tracer_provider = None
-    strawberry_extensions: List[Union[Type[SchemaExtension], SchemaExtension]] = []
+    strawberry_extensions: list[Union[type[SchemaExtension], SchemaExtension]] = []
     strawberry_extensions.extend(schema.get_extensions())
     if server_instrumentation_is_enabled():
         tracer_provider = initialize_opentelemetry_tracer_provider()

phoenix/server/bearer_auth.py

@@ -1,14 +1,8 @@
 from abc import ABC
+from collections.abc import Awaitable, Callable
 from datetime import datetime, timedelta, timezone
 from functools import cached_property
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Optional,
-    Tuple,
-    cast,
-)
+from typing import Any, Optional, cast
 
 import grpc
 from fastapi import HTTPException, Request, WebSocket, WebSocketException
@@ -51,7 +45,7 @@ class BearerTokenAuthBackend(HasTokenStore, AuthenticationBackend):
     async def authenticate(
         self,
         conn: HTTPConnection,
-    ) -> Optional[Tuple[AuthCredentials, BaseUser]]:
+    ) -> Optional[tuple[AuthCredentials, BaseUser]]:
         if header := conn.headers.get("Authorization"):
             scheme, _, token = header.partition(" ")
             if scheme.lower() != "bearer" or not token:
@@ -143,7 +137,7 @@ async def create_access_and_refresh_tokens(
     user: OrmUser,
     access_token_expiry: timedelta,
     refresh_token_expiry: timedelta,
-) -> Tuple[AccessToken, RefreshToken]:
+) -> tuple[AccessToken, RefreshToken]:
     issued_at = datetime.now(timezone.utc)
     user_id = UserId(user.id)
     user_role = UserRole(user.role.name)

phoenix/server/dml_event.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from abc import ABC
 from dataclasses import dataclass, field
-from typing import ClassVar, Tuple, Type
+from typing import ClassVar
 
 from phoenix.db import models
 
@@ -14,8 +14,8 @@ class DmlEvent(ABC):
     operation, e.g. insertion, update, or deletion.
     """
 
-    table: ClassVar[Type[models.Base]]
-    ids: Tuple[int, ...] = field(default_factory=tuple)
+    table: ClassVar[type[models.Base]]
+    ids: tuple[int, ...] = field(default_factory=tuple)
 
     def __bool__(self) -> bool:
         return bool(self.ids)

phoenix/server/dml_event_handler.py

@@ -2,24 +2,10 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from asyncio import gather
+from collections.abc import Callable, Iterable, Iterator, Mapping
 from inspect import getmro
 from itertools import chain
-from typing import (
-    Any,
-    Callable,
-    Generic,
-    Iterable,
-    Iterator,
-    Mapping,
-    Optional,
-    Set,
-    Tuple,
-    Type,
-    TypedDict,
-    TypeVar,
-    Union,
-    cast,
-)
+from typing import Any, Generic, Optional, TypedDict, TypeVar, Union, cast
 
 from sqlalchemy import Select, select
 from typing_extensions import TypeAlias, Unpack
@@ -54,7 +40,7 @@ _DmlEventT = TypeVar("_DmlEventT", bound=DmlEvent)
 class _DmlEventQueue(Generic[_DmlEventT]):
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
-        self._events: Set[_DmlEventT] = set()
+        self._events: set[_DmlEventT] = set()
 
     @property
     def empty(self) -> bool:
@@ -120,7 +106,7 @@ class _GenericDmlEventHandler(_DmlEventHandler[DmlEvent]):
             for id_ in e.ids:
                 self._update(e.table, id_)
 
-    def _update(self, table: Type[Base], id_: int) -> None:
+    def _update(self, table: type[Base], id_: int) -> None:
         self._last_updated_at.set(table, id_)
 
 
@@ -146,9 +132,9 @@ class _SpanDeleteEventHandler(_SpanDmlEventHandler):
 
 
 _AnnotationTable: TypeAlias = Union[
-    Type[SpanAnnotation],
-    Type[TraceAnnotation],
-    Type[DocumentAnnotation],
+    type[SpanAnnotation],
+    type[TraceAnnotation],
+    type[DocumentAnnotation],
 ]
 
 _AnnotationDmlEventT = TypeVar(
@@ -165,7 +151,7 @@ class _AnnotationDmlEventHandler(
     ABC,
 ):
     _table: _AnnotationTable
-    _base_stmt: Union[Select[Tuple[int, str]], Select[Tuple[int]]] = (
+    _base_stmt: Union[Select[tuple[int, str]], Select[tuple[int]]] = (
         select(Project.id).join_from(Project, Trace).distinct()
     )
 
@@ -175,7 +161,7 @@ class _AnnotationDmlEventHandler(
         if self._cache_for_dataloaders:
             self._stmt = self._stmt.add_columns(self._table.name)
 
-    def _get_stmt(self) -> Union[Select[Tuple[int, str]], Select[Tuple[int]]]:
+    def _get_stmt(self) -> Union[Select[tuple[int, str]], Select[tuple[int]]]:
         ids = set(chain.from_iterable(e.ids for e in self._batch))
         return self._stmt.where(self._table.id.in_(ids))
 
@@ -242,7 +228,7 @@ class DmlEventHandler:
             cache_for_dataloaders=cache_for_dataloaders,
             sleep_seconds=sleep_seconds,
         )
-        self._handlers: Mapping[Type[DmlEvent], Iterable[_DmlEventHandler[Any]]] = {
+        self._handlers: Mapping[type[DmlEvent], Iterable[_DmlEventHandler[Any]]] = {
             DmlEvent: [_GenericDmlEventHandler(**kwargs)],
             SpanDmlEvent: [_SpanDmlEventHandler(**kwargs)],
             SpanDeleteEvent: [_SpanDeleteEventHandler(**kwargs)],

phoenix/server/grpc_server.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, List, Optional
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any, Optional
 
 import grpc
 from grpc.aio import RpcContext, Server, ServerInterceptor
@@ -66,7 +67,7 @@ class GrpcServer:
     async def __aenter__(self) -> None:
         if self._disabled:
             return
-        interceptors: List[ServerInterceptor] = []
+        interceptors: list[ServerInterceptor] = []
         if self._token_store:
             interceptors.append(ApiKeyInterceptor(self._token_store))
         if self._enable_prometheus:

phoenix/server/jwt_store.py

@@ -1,11 +1,12 @@
 import logging
 from abc import ABC, abstractmethod
 from asyncio import create_task, gather, sleep
+from collections.abc import Callable, Coroutine
 from copy import deepcopy
 from dataclasses import replace
 from datetime import datetime, timezone
 from functools import cached_property, singledispatchmethod
-from typing import Any, Callable, Coroutine, Dict, Generic, List, Optional, Tuple, Type, TypeVar
+from typing import Any, Generic, Optional, TypeVar
 
 from authlib.jose import jwt
 from authlib.jose.errors import JoseError
@@ -65,7 +66,7 @@ class JwtStore:
         self._api_key_store = _ApiKeyStore(*args, **kwargs)
 
     @cached_property
-    def _stores(self) -> Tuple[DaemonTask, ...]:
+    def _stores(self) -> tuple[DaemonTask, ...]:
         return tuple(dt for dt in self.__dict__.values() if isinstance(dt, _Store))
 
     async def __aenter__(self) -> None:
@@ -131,34 +132,34 @@ class JwtStore:
     async def create_password_reset_token(
         self,
         claim: PasswordResetTokenClaims,
-    ) -> Tuple[PasswordResetToken, PasswordResetTokenId]:
+    ) -> tuple[PasswordResetToken, PasswordResetTokenId]:
         return await self._password_reset_token_store.create(claim)
 
     async def create_access_token(
         self,
         claim: AccessTokenClaims,
-    ) -> Tuple[AccessToken, AccessTokenId]:
+    ) -> tuple[AccessToken, AccessTokenId]:
         return await self._access_token_store.create(claim)
 
     async def create_refresh_token(
         self,
         claim: RefreshTokenClaims,
-    ) -> Tuple[RefreshToken, RefreshTokenId]:
+    ) -> tuple[RefreshToken, RefreshTokenId]:
         return await self._refresh_token_store.create(claim)
 
     async def create_api_key(
         self,
         claim: ApiKeyClaims,
-    ) -> Tuple[ApiKey, ApiKeyId]:
+    ) -> tuple[ApiKey, ApiKeyId]:
         return await self._api_key_store.create(claim)
 
     async def revoke(self, *token_ids: TokenId) -> None:
         if not token_ids:
             return
-        password_reset_token_ids: List[PasswordResetTokenId] = []
-        access_token_ids: List[AccessTokenId] = []
-        refresh_token_ids: List[RefreshTokenId] = []
-        api_key_ids: List[ApiKeyId] = []
+        password_reset_token_ids: list[PasswordResetTokenId] = []
+        access_token_ids: list[AccessTokenId] = []
+        refresh_token_ids: list[RefreshTokenId] = []
+        api_key_ids: list[ApiKeyId] = []
         for token_id in token_ids:
             if isinstance(token_id, PasswordResetTokenId):
                 password_reset_token_ids.append(token_id)
@@ -168,7 +169,7 @@ class JwtStore:
                 refresh_token_ids.append(token_id)
             elif isinstance(token_id, ApiKeyId):
                 api_key_ids.append(token_id)
-        coroutines: List[Coroutine[None, None, None]] = []
+        coroutines: list[Coroutine[None, None, None]] = []
         if password_reset_token_ids:
             coroutines.append(self._password_reset_token_store.revoke(*password_reset_token_ids))
         if access_token_ids:
@@ -202,7 +203,7 @@ _RecordT = TypeVar(
 
 class _Claims(Generic[_TokenIdT, _ClaimSetT]):
     def __init__(self) -> None:
-        self._cache: Dict[_TokenIdT, _ClaimSetT] = {}
+        self._cache: dict[_TokenIdT, _ClaimSetT] = {}
 
     def __getitem__(self, token_id: _TokenIdT) -> Optional[_ClaimSetT]:
         claim = self._cache.get(token_id)
@@ -223,7 +224,7 @@ class _Claims(Generic[_TokenIdT, _ClaimSetT]):
 
 
 class _Store(DaemonTask, Generic[_ClaimSetT, _TokenT, _TokenIdT, _RecordT], ABC):
-    _table: Type[_RecordT]
+    _table: type[_RecordT]
     _token_id: Callable[[int], _TokenIdT]
     _token: Callable[[str], _TokenT]
 
@@ -244,7 +245,7 @@ class _Store(DaemonTask, Generic[_ClaimSetT, _TokenT, _TokenIdT, _RecordT], ABC)
         self._algorithm = algorithm
 
     def _encode(self, claim: ClaimSet) -> str:
-        payload: Dict[str, Any] = dict(jti=claim.token_id)
+        payload: dict[str, Any] = dict(jti=claim.token_id)
         header = {"alg": self._algorithm}
         jwt_bytes: bytes = jwt.encode(header=header, payload=payload, key=self._secret)
         return jwt_bytes.decode()
@@ -275,12 +276,12 @@ class _Store(DaemonTask, Generic[_ClaimSetT, _TokenT, _TokenIdT, _RecordT], ABC)
             await session.execute(stmt)
 
     @abstractmethod
-    def _from_db(self, record: _RecordT, role: UserRole) -> Tuple[_TokenIdT, _ClaimSetT]: ...
+    def _from_db(self, record: _RecordT, role: UserRole) -> tuple[_TokenIdT, _ClaimSetT]: ...
 
     @abstractmethod
     def _to_db(self, claims: _ClaimSetT) -> _RecordT: ...
 
-    async def create(self, claim: _ClaimSetT) -> Tuple[_TokenT, _TokenIdT]:
+    async def create(self, claim: _ClaimSetT) -> tuple[_TokenT, _TokenIdT]:
         record = self._to_db(claim)
         async with self._db() as session:
             session.add(record)
@@ -303,7 +304,7 @@ class _Store(DaemonTask, Generic[_ClaimSetT, _TokenT, _TokenIdT, _RecordT], ABC)
         self._claims = claims
 
     @cached_property
-    def _update_stmt(self) -> Select[Tuple[_RecordT, str]]:
+    def _update_stmt(self) -> Select[tuple[_RecordT, str]]:
         return (
             select(self._table, models.UserRole.name)
             .join_from(self._table, models.User)
@@ -340,7 +341,7 @@ class _PasswordResetTokenStore(
         self,
         record: models.PasswordResetToken,
         user_role: UserRole,
-    ) -> Tuple[PasswordResetTokenId, PasswordResetTokenClaims]:
+    ) -> tuple[PasswordResetTokenId, PasswordResetTokenClaims]:
         token_id = PasswordResetTokenId(record.id)
         return token_id, PasswordResetTokenClaims(
             token_id=token_id,
@@ -379,7 +380,7 @@ class _AccessTokenStore(
         self,
         record: models.AccessToken,
         user_role: UserRole,
-    ) -> Tuple[AccessTokenId, AccessTokenClaims]:
+    ) -> tuple[AccessTokenId, AccessTokenClaims]:
         token_id = AccessTokenId(record.id)
         refresh_token_id = RefreshTokenId(record.refresh_token_id)
         return token_id, AccessTokenClaims(
@@ -423,7 +424,7 @@ class _RefreshTokenStore(
         self,
         record: models.RefreshToken,
         user_role: UserRole,
-    ) -> Tuple[RefreshTokenId, RefreshTokenClaims]:
+    ) -> tuple[RefreshTokenId, RefreshTokenClaims]:
         token_id = RefreshTokenId(record.id)
         return token_id, RefreshTokenClaims(
             token_id=token_id,
@@ -469,7 +470,7 @@ class _ApiKeyStore(
         self,
         record: models.ApiKey,
         user_role: UserRole,
-    ) -> Tuple[ApiKeyId, ApiKeyClaims]:
+    ) -> tuple[ApiKeyId, ApiKeyClaims]:
         token_id = ApiKeyId(record.id)
         return token_id, ApiKeyClaims(
             token_id=token_id,

phoenix/server/main.py

@@ -6,7 +6,7 @@ from argparse import SUPPRESS, ArgumentParser
 from pathlib import Path
 from threading import Thread
 from time import sleep, time
-from typing import List, Optional
+from typing import Optional
 from urllib.parse import urljoin
 
 from jinja2 import BaseLoader, Environment
@@ -312,8 +312,8 @@ def main() -> None:
 
     authentication_enabled, secret = get_env_auth_settings()
 
-    fixture_spans: List[Span] = []
-    fixture_evals: List[pb.Evaluation] = []
+    fixture_spans: list[Span] = []
+    fixture_evals: list[pb.Evaluation] = []
     if trace_dataset_name is not None:
         fixture_spans, fixture_evals = reset_fixture_span_ids_and_timestamps(
             (

phoenix/server/oauth2.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 from authlib.integrations.base_client import BaseApp
 from authlib.integrations.base_client.async_app import AsyncOAuth2Mixin
@@ -24,7 +25,7 @@ class OAuth2Client(AsyncOAuth2Mixin, AsyncOpenIDMixin, BaseApp):  # type:ignore[
 
 class OAuth2Clients:
     def __init__(self) -> None:
-        self._clients: Dict[str, OAuth2Client] = {}
+        self._clients: dict[str, OAuth2Client] = {}
 
     def add_client(self, config: OAuth2ClientConfig) -> None:
         if (idp_name := config.idp_name) in self._clients:

phoenix/server/rate_limiters.py

@@ -1,13 +1,10 @@
 import re
 import time
 from collections import defaultdict
+from collections.abc import Callable, Coroutine
 from functools import partial
 from typing import (
     Any,
-    Callable,
-    Coroutine,
-    DefaultDict,
-    List,
     Optional,
     Pattern,  # import from re module when we drop support for 3.8
     Union,
@@ -98,7 +95,7 @@ class ServerRateLimiter:
         self._last_cleanup_time = time.time()
 
     def _reset_rate_limiters(self) -> None:
-        self.cache_partitions: List[DefaultDict[Any, TokenBucket]] = [
+        self.cache_partitions: list[defaultdict[Any, TokenBucket]] = [
             defaultdict(self.bucket_factory) for _ in range(self.num_partitions)
         ]
 
@@ -107,10 +104,10 @@ class ServerRateLimiter:
             int(timestamp // self.partition_seconds) % self.num_partitions
         )  # a cyclic bucket index
 
-    def _active_partition_indices(self, current_index: int) -> List[int]:
+    def _active_partition_indices(self, current_index: int) -> list[int]:
         return [(current_index - ii) % self.num_partitions for ii in range(self.active_partitions)]
 
-    def _inactive_partition_indices(self, current_index: int) -> List[int]:
+    def _inactive_partition_indices(self, current_index: int) -> list[int]:
         active_indices = set(self._active_partition_indices(current_index))
         all_indices = set(range(self.num_partitions))
         return list(all_indices - active_indices)
@@ -156,7 +153,7 @@ class ServerRateLimiter:
 
 
 def fastapi_ip_rate_limiter(
-    rate_limiter: ServerRateLimiter, paths: Optional[List[Union[str, Pattern[str]]]] = None
+    rate_limiter: ServerRateLimiter, paths: Optional[list[Union[str, Pattern[str]]]] = None
 ) -> Callable[[Request], Coroutine[Any, Any, Request]]:
     async def dependency(request: Request) -> Request:
         if paths is None or any(path_match(request.url.path, path) for path in paths):