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

phoenix/server/api/dataloaders/annotation_summaries.py

@@ -1,13 +1,6 @@
 from collections import defaultdict
 from datetime import datetime
-from typing import (
-    Any,
-    DefaultDict,
-    List,
-    Literal,
-    Optional,
-    Tuple,
-)
+from typing import Any, Literal, Optional
 
 import pandas as pd
 from aioitertools.itertools import groupby
@@ -25,20 +18,20 @@ from phoenix.trace.dsl import SpanFilter
 
 Kind: TypeAlias = Literal["span", "trace"]
 ProjectRowId: TypeAlias = int
-TimeInterval: TypeAlias = Tuple[Optional[datetime], Optional[datetime]]
+TimeInterval: TypeAlias = tuple[Optional[datetime], Optional[datetime]]
 FilterCondition: TypeAlias = Optional[str]
 AnnotationName: TypeAlias = str
 
-Segment: TypeAlias = Tuple[Kind, ProjectRowId, TimeInterval, FilterCondition]
+Segment: TypeAlias = tuple[Kind, ProjectRowId, TimeInterval, FilterCondition]
 Param: TypeAlias = AnnotationName
 
-Key: TypeAlias = Tuple[Kind, ProjectRowId, Optional[TimeRange], FilterCondition, AnnotationName]
+Key: TypeAlias = tuple[Kind, ProjectRowId, Optional[TimeRange], FilterCondition, AnnotationName]
 Result: TypeAlias = Optional[AnnotationSummary]
 ResultPosition: TypeAlias = int
 DEFAULT_VALUE: Result = None
 
 
-def _cache_key_fn(key: Key) -> Tuple[Segment, Param]:
+def _cache_key_fn(key: Key) -> tuple[Segment, Param]:
     kind, project_rowid, time_range, filter_condition, eval_name = key
     interval = (
         (time_range.start, time_range.end) if isinstance(time_range, TimeRange) else (None, None)
@@ -46,8 +39,8 @@ def _cache_key_fn(key: Key) -> Tuple[Segment, Param]:
     return (kind, project_rowid, interval, filter_condition), eval_name
 
 
-_Section: TypeAlias = Tuple[ProjectRowId, AnnotationName, Kind]
-_SubKey: TypeAlias = Tuple[TimeInterval, FilterCondition]
+_Section: TypeAlias = tuple[ProjectRowId, AnnotationName, Kind]
+_SubKey: TypeAlias = tuple[TimeInterval, FilterCondition]
 
 
 class AnnotationSummaryCache(
@@ -67,7 +60,7 @@ class AnnotationSummaryCache(
             if section[0] == project_rowid:
                 del self._cache[section]
 
-    def _cache_key(self, key: Key) -> Tuple[_Section, _SubKey]:
+    def _cache_key(self, key: Key) -> tuple[_Section, _SubKey]:
         (kind, project_rowid, interval, filter_condition), annotation_name = _cache_key_fn(key)
         return (project_rowid, annotation_name, kind), (interval, filter_condition)
 
@@ -85,11 +78,11 @@ class AnnotationSummaryDataLoader(DataLoader[Key, Result]):
         )
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        results: List[Result] = [DEFAULT_VALUE] * len(keys)
-        arguments: DefaultDict[
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        results: list[Result] = [DEFAULT_VALUE] * len(keys)
+        arguments: defaultdict[
             Segment,
-            DefaultDict[Param, List[ResultPosition]],
+            defaultdict[Param, list[ResultPosition]],
         ] = defaultdict(lambda: defaultdict(list))
         for position, key in enumerate(keys):
             segment, param = _cache_key_fn(key)

phoenix/server/api/dataloaders/average_experiment_run_latency.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Optional
 
 from sqlalchemy import func, select
 from strawberry.dataloader import DataLoader
@@ -21,7 +21,7 @@ class AverageExperimentRunLatencyDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         experiment_ids = keys
         resolved_experiment_ids = (
             select(models.Experiment.id)

phoenix/server/api/dataloaders/cache/two_tier_cache.py

@@ -9,7 +9,8 @@ subset that we want to invalidate.
 
 from abc import ABC, abstractmethod
 from asyncio import Future
-from typing import Any, Callable, Generic, Optional, Tuple, TypeVar
+from collections.abc import Callable
+from typing import Any, Generic, Optional, TypeVar
 
 from cachetools import Cache
 from strawberry.dataloader import AbstractCache
@@ -38,7 +39,7 @@ class TwoTierCache(
         self._sub_cache_factory = sub_cache_factory
 
     @abstractmethod
-    def _cache_key(self, key: _Key) -> Tuple[_Section, _SubKey]: ...
+    def _cache_key(self, key: _Key) -> tuple[_Section, _SubKey]: ...
 
     def invalidate(self, section: _Section) -> None:
         if sub_cache := self._cache.get(section):

phoenix/server/api/dataloaders/dataset_example_revisions.py

@@ -1,9 +1,4 @@
-from typing import (
-    List,
-    Optional,
-    Tuple,
-    Union,
-)
+from typing import Optional, Union
 
 from sqlalchemy import and_, case, func, null, or_, select
 from sqlalchemy.sql.expression import literal
@@ -17,7 +12,7 @@ from phoenix.server.types import DbSessionFactory
 
 ExampleID: TypeAlias = int
 VersionID: TypeAlias = Optional[int]
-Key: TypeAlias = Tuple[ExampleID, Optional[VersionID]]
+Key: TypeAlias = tuple[ExampleID, Optional[VersionID]]
 Result: TypeAlias = DatasetExampleRevision
 
 
@@ -29,7 +24,7 @@ class DatasetExampleRevisionsDataLoader(DataLoader[Key, Result]):
         )
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Union[Result, NotFound]]:
+    async def _load_fn(self, keys: list[Key]) -> list[Union[Result, NotFound]]:
         example_and_version_ids = tuple(
             set(
                 (example_id, version_id)

phoenix/server/api/dataloaders/dataset_example_spans.py

@@ -1,7 +1,4 @@
-from typing import (
-    List,
-    Optional,
-)
+from typing import Optional
 
 from sqlalchemy import select
 from sqlalchemy.orm import joinedload
@@ -21,7 +18,7 @@ class DatasetExampleSpansDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         example_ids = keys
         async with self._db() as session:
             spans = {

phoenix/server/api/dataloaders/document_evaluation_summaries.py

@@ -1,12 +1,6 @@
 from collections import defaultdict
 from datetime import datetime
-from typing import (
-    Any,
-    DefaultDict,
-    List,
-    Optional,
-    Tuple,
-)
+from typing import Any, Optional
 
 import numpy as np
 from aioitertools.itertools import groupby
@@ -25,20 +19,20 @@ from phoenix.server.types import DbSessionFactory
 from phoenix.trace.dsl import SpanFilter
 
 ProjectRowId: TypeAlias = int
-TimeInterval: TypeAlias = Tuple[Optional[datetime], Optional[datetime]]
+TimeInterval: TypeAlias = tuple[Optional[datetime], Optional[datetime]]
 FilterCondition: TypeAlias = Optional[str]
 EvalName: TypeAlias = str
 
-Segment: TypeAlias = Tuple[ProjectRowId, TimeInterval, FilterCondition]
+Segment: TypeAlias = tuple[ProjectRowId, TimeInterval, FilterCondition]
 Param: TypeAlias = EvalName
 
-Key: TypeAlias = Tuple[ProjectRowId, Optional[TimeRange], FilterCondition, EvalName]
+Key: TypeAlias = tuple[ProjectRowId, Optional[TimeRange], FilterCondition, EvalName]
 Result: TypeAlias = Optional[DocumentEvaluationSummary]
 ResultPosition: TypeAlias = int
 DEFAULT_VALUE: Result = None
 
 
-def _cache_key_fn(key: Key) -> Tuple[Segment, Param]:
+def _cache_key_fn(key: Key) -> tuple[Segment, Param]:
     project_rowid, time_range, filter_condition, eval_name = key
     interval = (
         (time_range.start, time_range.end) if isinstance(time_range, TimeRange) else (None, None)
@@ -46,8 +40,8 @@ def _cache_key_fn(key: Key) -> Tuple[Segment, Param]:
     return (project_rowid, interval, filter_condition), eval_name
 
 
-_Section: TypeAlias = Tuple[ProjectRowId, EvalName]
-_SubKey: TypeAlias = Tuple[TimeInterval, FilterCondition]
+_Section: TypeAlias = tuple[ProjectRowId, EvalName]
+_SubKey: TypeAlias = tuple[TimeInterval, FilterCondition]
 
 
 class DocumentEvaluationSummaryCache(
@@ -67,7 +61,7 @@ class DocumentEvaluationSummaryCache(
             if section[0] == project_rowid:
                 del self._cache[section]
 
-    def _cache_key(self, key: Key) -> Tuple[_Section, _SubKey]:
+    def _cache_key(self, key: Key) -> tuple[_Section, _SubKey]:
         (project_rowid, interval, filter_condition), eval_name = _cache_key_fn(key)
         return (project_rowid, eval_name), (interval, filter_condition)
 
@@ -85,11 +79,11 @@ class DocumentEvaluationSummaryDataLoader(DataLoader[Key, Result]):
         )
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        results: List[Result] = [DEFAULT_VALUE] * len(keys)
-        arguments: DefaultDict[
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        results: list[Result] = [DEFAULT_VALUE] * len(keys)
+        arguments: defaultdict[
             Segment,
-            DefaultDict[Param, List[ResultPosition]],
+            defaultdict[Param, list[ResultPosition]],
         ] = defaultdict(lambda: defaultdict(list))
         for position, key in enumerate(keys):
             segment, param = _cache_key_fn(key)

phoenix/server/api/dataloaders/document_evaluations.py

@@ -1,8 +1,4 @@
 from collections import defaultdict
-from typing import (
-    DefaultDict,
-    List,
-)
 
 from sqlalchemy import select
 from strawberry.dataloader import DataLoader
@@ -13,7 +9,7 @@ from phoenix.server.api.types.Evaluation import DocumentEvaluation
 from phoenix.server.types import DbSessionFactory
 
 Key: TypeAlias = int
-Result: TypeAlias = List[DocumentEvaluation]
+Result: TypeAlias = list[DocumentEvaluation]
 
 
 class DocumentEvaluationsDataLoader(DataLoader[Key, Result]):
@@ -21,8 +17,8 @@ class DocumentEvaluationsDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        document_evaluations_by_id: DefaultDict[Key, Result] = defaultdict(list)
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        document_evaluations_by_id: defaultdict[Key, Result] = defaultdict(list)
         mda = models.DocumentAnnotation
         async with self._db() as session:
             data = await session.stream_scalars(

phoenix/server/api/dataloaders/document_retrieval_metrics.py

@@ -1,12 +1,5 @@
 from collections import defaultdict
-from typing import (
-    DefaultDict,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-)
+from typing import Optional
 
 import numpy as np
 from aioitertools.itertools import groupby
@@ -23,8 +16,8 @@ RowId: TypeAlias = int
 NumDocs: TypeAlias = int
 EvalName: TypeAlias = Optional[str]
 
-Key: TypeAlias = Tuple[RowId, EvalName, NumDocs]
-Result: TypeAlias = List[DocumentRetrievalMetrics]
+Key: TypeAlias = tuple[RowId, EvalName, NumDocs]
+Result: TypeAlias = list[DocumentRetrievalMetrics]
 
 
 class DocumentRetrievalMetricsDataLoader(DataLoader[Key, Result]):
@@ -32,7 +25,7 @@ class DocumentRetrievalMetricsDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         mda = models.DocumentAnnotation
         stmt = (
             select(
@@ -57,8 +50,8 @@ class DocumentRetrievalMetricsDataLoader(DataLoader[Key, Result]):
             stmt = stmt.where(mda.name.in_(all_eval_names))
         max_position = max(num_docs for _, _, num_docs in keys)
         stmt = stmt.where(mda.document_position < max_position)
-        results: Dict[Key, Result] = {key: [] for key in keys}
-        requested_num_docs: DefaultDict[Tuple[RowId, EvalName], Set[NumDocs]] = defaultdict(set)
+        results: dict[Key, Result] = {key: [] for key in keys}
+        requested_num_docs: defaultdict[tuple[RowId, EvalName], set[NumDocs]] = defaultdict(set)
         for row_id, eval_name, num_docs in results.keys():
             requested_num_docs[(row_id, eval_name)].add(num_docs)
         async with self._db() as session:

phoenix/server/api/dataloaders/experiment_annotation_summaries.py

@@ -1,10 +1,6 @@
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import (
-    DefaultDict,
-    List,
-    Optional,
-)
+from typing import Optional
 
 from sqlalchemy import func, select
 from strawberry.dataloader import AbstractCache, DataLoader
@@ -26,7 +22,7 @@ class ExperimentAnnotationSummary:
 
 ExperimentID: TypeAlias = int
 Key: TypeAlias = ExperimentID
-Result: TypeAlias = List[ExperimentAnnotationSummary]
+Result: TypeAlias = list[ExperimentAnnotationSummary]
 
 
 class ExperimentAnnotationSummaryDataLoader(DataLoader[Key, Result]):
@@ -38,9 +34,9 @@ class ExperimentAnnotationSummaryDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         experiment_ids = keys
-        summaries: DefaultDict[ExperimentID, Result] = defaultdict(list)
+        summaries: defaultdict[ExperimentID, Result] = defaultdict(list)
         async with self._db() as session:
             async for (
                 experiment_id,

phoenix/server/api/dataloaders/experiment_error_rates.py

@@ -1,7 +1,4 @@
-from typing import (
-    List,
-    Optional,
-)
+from typing import Optional
 
 from sqlalchemy import case, func, select
 from strawberry.dataloader import DataLoader
@@ -24,7 +21,7 @@ class ExperimentErrorRatesDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         experiment_ids = keys
         resolved_experiment_ids = (
             select(models.Experiment.id)

phoenix/server/api/dataloaders/experiment_run_annotations.py

@@ -1,8 +1,4 @@
 from collections import defaultdict
-from typing import (
-    DefaultDict,
-    List,
-)
 
 from sqlalchemy import select
 from strawberry.dataloader import DataLoader
@@ -13,7 +9,7 @@ from phoenix.server.types import DbSessionFactory
 
 ExperimentRunID: TypeAlias = int
 Key: TypeAlias = ExperimentRunID
-Result: TypeAlias = List[OrmExperimentRunAnnotation]
+Result: TypeAlias = list[OrmExperimentRunAnnotation]
 
 
 class ExperimentRunAnnotations(DataLoader[Key, Result]):
@@ -24,9 +20,9 @@ class ExperimentRunAnnotations(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         run_ids = keys
-        annotations: DefaultDict[Key, Result] = defaultdict(list)
+        annotations: defaultdict[Key, Result] = defaultdict(list)
         async with self._db() as session:
             async for run_id, annotation in await session.stream(
                 select(

phoenix/server/api/dataloaders/experiment_run_counts.py

@@ -1,7 +1,3 @@
-from typing import (
-    List,
-)
-
 from sqlalchemy import func, select
 from strawberry.dataloader import DataLoader
 from typing_extensions import TypeAlias
@@ -23,7 +19,7 @@ class ExperimentRunCountsDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         experiment_ids = keys
         resolved_experiment_ids = (
             select(models.Experiment.id)

phoenix/server/api/dataloaders/experiment_sequence_number.py

@@ -1,7 +1,4 @@
-from typing import (
-    List,
-    Optional,
-)
+from typing import Optional
 
 from sqlalchemy import distinct, func, select
 from strawberry.dataloader import DataLoader
@@ -20,7 +17,7 @@ class ExperimentSequenceNumberDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         experiment_ids = keys
         dataset_ids = (
             select(distinct(models.Experiment.dataset_id))

phoenix/server/api/dataloaders/latency_ms_quantile.py

@@ -1,16 +1,7 @@
 from collections import defaultdict
+from collections.abc import AsyncIterator, Mapping
 from datetime import datetime
-from typing import (
-    Any,
-    AsyncIterator,
-    DefaultDict,
-    List,
-    Literal,
-    Mapping,
-    Optional,
-    Tuple,
-    cast,
-)
+from typing import Any, Literal, Optional, cast
 
 from cachetools import LFUCache, TTLCache
 from sqlalchemy import (
@@ -39,15 +30,15 @@ from phoenix.trace.dsl import SpanFilter
 
 Kind: TypeAlias = Literal["span", "trace"]
 ProjectRowId: TypeAlias = int
-TimeInterval: TypeAlias = Tuple[Optional[datetime], Optional[datetime]]
+TimeInterval: TypeAlias = tuple[Optional[datetime], Optional[datetime]]
 FilterCondition: TypeAlias = Optional[str]
 Probability: TypeAlias = float
 QuantileValue: TypeAlias = float
 
-Segment: TypeAlias = Tuple[Kind, TimeInterval, FilterCondition]
-Param: TypeAlias = Tuple[ProjectRowId, Probability]
+Segment: TypeAlias = tuple[Kind, TimeInterval, FilterCondition]
+Param: TypeAlias = tuple[ProjectRowId, Probability]
 
-Key: TypeAlias = Tuple[Kind, ProjectRowId, Optional[TimeRange], FilterCondition, Probability]
+Key: TypeAlias = tuple[Kind, ProjectRowId, Optional[TimeRange], FilterCondition, Probability]
 Result: TypeAlias = Optional[QuantileValue]
 ResultPosition: TypeAlias = int
 DEFAULT_VALUE: Result = None
@@ -55,7 +46,7 @@ DEFAULT_VALUE: Result = None
 FloatCol: TypeAlias = SQLColumnExpression[Float[float]]
 
 
-def _cache_key_fn(key: Key) -> Tuple[Segment, Param]:
+def _cache_key_fn(key: Key) -> tuple[Segment, Param]:
     kind, project_rowid, time_range, filter_condition, probability = key
     interval = (
         (time_range.start, time_range.end) if isinstance(time_range, TimeRange) else (None, None)
@@ -64,7 +55,7 @@ def _cache_key_fn(key: Key) -> Tuple[Segment, Param]:
 
 
 _Section: TypeAlias = ProjectRowId
-_SubKey: TypeAlias = Tuple[TimeInterval, FilterCondition, Kind, Probability]
+_SubKey: TypeAlias = tuple[TimeInterval, FilterCondition, Kind, Probability]
 
 
 class LatencyMsQuantileCache(
@@ -79,7 +70,7 @@ class LatencyMsQuantileCache(
             sub_cache_factory=lambda: LFUCache(maxsize=2 * 2 * 2 * 16),
         )
 
-    def _cache_key(self, key: Key) -> Tuple[_Section, _SubKey]:
+    def _cache_key(self, key: Key) -> tuple[_Section, _SubKey]:
         (kind, interval, filter_condition), (project_rowid, probability) = _cache_key_fn(key)
         return project_rowid, (interval, filter_condition, kind, probability)
 
@@ -97,11 +88,11 @@ class LatencyMsQuantileDataLoader(DataLoader[Key, Result]):
         )
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        results: List[Result] = [DEFAULT_VALUE] * len(keys)
-        arguments: DefaultDict[
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        results: list[Result] = [DEFAULT_VALUE] * len(keys)
+        arguments: defaultdict[
             Segment,
-            DefaultDict[Param, List[ResultPosition]],
+            defaultdict[Param, list[ResultPosition]],
         ] = defaultdict(lambda: defaultdict(list))
         for position, key in enumerate(keys):
             segment, param = _cache_key_fn(key)
@@ -120,8 +111,8 @@ async def _get_results(
     dialect: SupportedSQLDialect,
     session: AsyncSession,
     segment: Segment,
-    params: Mapping[Param, List[ResultPosition]],
-) -> AsyncIterator[Tuple[ResultPosition, QuantileValue]]:
+    params: Mapping[Param, list[ResultPosition]],
+) -> AsyncIterator[tuple[ResultPosition, QuantileValue]]:
     kind, (start_time, end_time), filter_condition = segment
     stmt = select(models.Trace.project_rowid)
     if kind == "trace":
@@ -154,9 +145,9 @@ async def _get_results_sqlite(
     session: AsyncSession,
     base_stmt: Select[Any],
     latency_column: FloatCol,
-    params: Mapping[Param, List[ResultPosition]],
-) -> AsyncIterator[Tuple[ResultPosition, QuantileValue]]:
-    projects_per_prob: DefaultDict[Probability, List[ProjectRowId]] = defaultdict(list)
+    params: Mapping[Param, list[ResultPosition]],
+) -> AsyncIterator[tuple[ResultPosition, QuantileValue]]:
+    projects_per_prob: defaultdict[Probability, list[ProjectRowId]] = defaultdict(list)
     for project_rowid, probability in params.keys():
         projects_per_prob[probability].append(project_rowid)
     pid = models.Trace.project_rowid
@@ -175,9 +166,9 @@ async def _get_results_postgresql(
     session: AsyncSession,
     base_stmt: Select[Any],
     latency_column: FloatCol,
-    params: Mapping[Param, List[ResultPosition]],
-) -> AsyncIterator[Tuple[ResultPosition, QuantileValue]]:
-    probs_per_project: DefaultDict[ProjectRowId, List[Probability]] = defaultdict(list)
+    params: Mapping[Param, list[ResultPosition]],
+) -> AsyncIterator[tuple[ResultPosition, QuantileValue]]:
+    probs_per_project: defaultdict[ProjectRowId, list[Probability]] = defaultdict(list)
     for project_rowid, probability in params.keys():
         probs_per_project[project_rowid].append(probability)
     pp: Values = values(

phoenix/server/api/dataloaders/min_start_or_max_end_times.py

@@ -1,12 +1,6 @@
 from collections import defaultdict
 from datetime import datetime
-from typing import (
-    DefaultDict,
-    List,
-    Literal,
-    Optional,
-    Tuple,
-)
+from typing import Literal, Optional
 
 from cachetools import LFUCache
 from sqlalchemy import func, select
@@ -23,7 +17,7 @@ ProjectRowId: TypeAlias = int
 Segment: TypeAlias = ProjectRowId
 Param: TypeAlias = Kind
 
-Key: TypeAlias = Tuple[ProjectRowId, Kind]
+Key: TypeAlias = tuple[ProjectRowId, Kind]
 Result: TypeAlias = Optional[datetime]
 ResultPosition: TypeAlias = int
 DEFAULT_VALUE: Result = None
@@ -41,7 +35,7 @@ class MinStartOrMaxEndTimeCache(
             sub_cache_factory=lambda: LFUCache(maxsize=2),
         )
 
-    def _cache_key(self, key: Key) -> Tuple[_Section, _SubKey]:
+    def _cache_key(self, key: Key) -> tuple[_Section, _SubKey]:
         return key
 
 
@@ -57,11 +51,11 @@ class MinStartOrMaxEndTimeDataLoader(DataLoader[Key, Result]):
         )
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
-        results: List[Result] = [DEFAULT_VALUE] * len(keys)
-        arguments: DefaultDict[
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
+        results: list[Result] = [DEFAULT_VALUE] * len(keys)
+        arguments: defaultdict[
             Segment,
-            DefaultDict[Param, List[ResultPosition]],
+            defaultdict[Param, list[ResultPosition]],
         ] = defaultdict(lambda: defaultdict(list))
         for position, key in enumerate(keys):
             segment, param = key

phoenix/server/api/dataloaders/project_by_name.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import DefaultDict, List, Optional
+from typing import Optional
 
 from sqlalchemy import select
 from strawberry.dataloader import DataLoader
@@ -18,9 +18,9 @@ class ProjectByNameDataLoader(DataLoader[Key, Result]):
         super().__init__(load_fn=self._load_fn)
         self._db = db
 
-    async def _load_fn(self, keys: List[Key]) -> List[Result]:
+    async def _load_fn(self, keys: list[Key]) -> list[Result]:
         project_names = list(set(keys))
-        projects_by_name: DefaultDict[Key, Result] = defaultdict(None)
+        projects_by_name: defaultdict[Key, Result] = defaultdict(None)
         async with self._db() as session:
             data = await session.stream_scalars(
                 select(models.Project).where(models.Project.name.in_(project_names))