cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520181654__py3-none-any.whl

cirq/sim/state_vector_simulator.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import abc
 import warnings
 from functools import cached_property
-from typing import Any, Dict, Generic, Iterator, Sequence, Type, TYPE_CHECKING, TypeVar
+from typing import Any, Generic, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 import numpy as np
 
@@ -50,7 +50,7 @@ class SimulatesIntermediateStateVector(
     def __init__(
         self,
         *,
-        dtype: Type[np.complexfloating] = np.complex64,
+        dtype: type[np.complexfloating] = np.complex64,
         noise: cirq.NOISE_MODEL_LIKE = None,
         seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = False,
@@ -62,7 +62,7 @@ class SimulatesIntermediateStateVector(
     def _create_simulator_trial_result(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
     ) -> cirq.StateVectorTrialResult:
         return StateVectorTrialResult(
@@ -116,7 +116,7 @@ class StateVectorTrialResult(
     def __init__(
         self,
         params: cirq.ParamResolver,
-        measurements: Dict[str, np.ndarray],
+        measurements: dict[str, np.ndarray],
         final_simulator_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
     ) -> None:
         super().__init__(

cirq/study/flatten_expressions.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import numbers
-from typing import Any, Callable, List, Optional, Tuple, TYPE_CHECKING, Union
+from typing import Any, Callable, TYPE_CHECKING
 
 import sympy
 
@@ -28,7 +28,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def flatten(val: Any) -> Tuple[Any, ExpressionMap]:
+def flatten(val: Any) -> tuple[Any, ExpressionMap]:
     """Creates a copy of `val` with any symbols or expressions replaced with
     new symbols.  `val` can be a `Circuit`, `Gate`, `Operation`, or other
     type.
@@ -114,8 +114,8 @@ def flatten(val: Any) -> Tuple[Any, ExpressionMap]:
 
 
 def flatten_with_sweep(
-    val: Any, sweep: Union[sweeps.Sweep, List[resolver.ParamResolver]]
-) -> Tuple[Any, sweeps.Sweep]:
+    val: Any, sweep: sweeps.Sweep | list[resolver.ParamResolver]
+) -> tuple[Any, sweeps.Sweep]:
     """Creates a copy of `val` with any symbols or expressions replaced with
     new symbols.  `val` can be a `Circuit`, `Gate`, `Operation`, or other
     type.  Also transforms a sweep over the symbols in `val` to a sweep over the
@@ -149,7 +149,7 @@ def flatten_with_sweep(
 
 def flatten_with_params(
     val: Any, params: resolver.ParamResolverOrSimilarType
-) -> Tuple[Any, resolver.ParamDictType]:
+) -> tuple[Any, resolver.ParamDictType]:
     """Creates a copy of `val` with any symbols or expressions replaced with
     new symbols.  `val` can be a `Circuit`, `Gate`, `Operation`, or other
     type.  Also transforms a dictionary of symbol values for `val` to an
@@ -201,9 +201,9 @@ class _ParamFlattener(resolver.ParamResolver):
 
     def __init__(
         self,
-        param_dict: Optional[resolver.ParamResolverOrSimilarType] = None,
+        param_dict: resolver.ParamResolverOrSimilarType | None = None,
         *,  # Force keyword args
-        get_param_name: Optional[Callable[[sympy.Expr], str]] = None,
+        get_param_name: Callable[[sympy.Expr], str] | None = None,
     ):
         """Initializes a new _ParamFlattener.
 
@@ -253,7 +253,7 @@ class _ParamFlattener(resolver.ParamResolver):
         return symbol
 
     def value_of(
-        self, value: Union[cirq.TParamKey, cirq.TParamValComplex], recursive: bool = False
+        self, value: cirq.TParamKey | cirq.TParamValComplex, recursive: bool = False
     ) -> cirq.TParamValComplex:
         """Resolves a symbol or expression to a new symbol unique to that value.
 
@@ -329,9 +329,7 @@ class ExpressionMap(dict):
         """
         super().__init__(*args, **kwargs)
 
-    def transform_sweep(
-        self, sweep: Union[sweeps.Sweep, List[resolver.ParamResolver]]
-    ) -> sweeps.Sweep:
+    def transform_sweep(self, sweep: sweeps.Sweep | list[resolver.ParamResolver]) -> sweeps.Sweep:
         """Returns a sweep to use with a circuit flattened earlier with
         `cirq.flatten`.
 
@@ -346,7 +344,7 @@ class ExpressionMap(dict):
             sweep: The sweep to transform.
         """
         sweep = sweepable.to_sweep(sweep)
-        param_list: List[resolver.ParamDictType] = []
+        param_list: list[resolver.ParamDictType] = []
         for r in sweep:
             param_dict: resolver.ParamDictType = {}
             for formula, sym in self.items():
@@ -383,8 +381,8 @@ class ExpressionMap(dict):
 
 
 def _ensure_not_str(
-    param: Union[sympy.Expr, cirq.TParamValComplex, str],
-) -> Union[sympy.Expr, cirq.TParamValComplex]:
+    param: sympy.Expr | cirq.TParamValComplex | str,
+) -> sympy.Expr | cirq.TParamValComplex:
     if isinstance(param, str):
         return sympy.Symbol(param)
     return param

cirq/study/resolver.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import numbers
-from typing import Any, cast, Dict, Iterator, Mapping, Optional, TYPE_CHECKING, Union
+from typing import Any, cast, Iterator, Mapping, TYPE_CHECKING, Union
 
 import numpy as np
 import sympy
@@ -30,7 +30,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-ParamDictType = Dict['cirq.TParamKey', 'cirq.TParamValComplex']
+ParamDictType = dict['cirq.TParamKey', 'cirq.TParamValComplex']
 ParamMappingType = Mapping['cirq.TParamKey', 'cirq.TParamValComplex']
 document(ParamDictType, """Dictionary from symbols to values.""")
 document(ParamMappingType, """Immutable map from symbols to values.""")
@@ -73,7 +73,7 @@ class ParamResolver:
         if hasattr(self, 'param_dict'):
             return  # Already initialized. Got wrapped as part of the __new__.
 
-        self._param_hash: Optional[int] = None
+        self._param_hash: int | None = None
         self._param_dict = cast(ParamDictType, {} if param_dict is None else param_dict)
         for key in self._param_dict:
             if isinstance(key, sympy.Expr) and not isinstance(key, sympy.Symbol):
@@ -85,7 +85,7 @@ class ParamResolver:
         return self._param_dict
 
     def value_of(
-        self, value: Union[cirq.TParamKey, cirq.TParamValComplex], recursive: bool = True
+        self, value: cirq.TParamKey | cirq.TParamValComplex, recursive: bool = True
     ) -> cirq.TParamValComplex:
         """Attempt to resolve a parameter to its assigned value.
 
@@ -217,7 +217,7 @@ class ParamResolver:
         return self._deep_eval_map[value]
 
     def _resolve_parameters_(self, resolver: ParamResolver, recursive: bool) -> ParamResolver:
-        new_dict: Dict[cirq.TParamKey, Union[float, str, sympy.Symbol, sympy.Expr]] = {
+        new_dict: dict[cirq.TParamKey, float | str | sympy.Symbol | sympy.Expr] = {
             k: k for k in resolver
         }
         new_dict.update({k: self.value_of(k, recursive) for k in self})
@@ -228,15 +228,13 @@ class ParamResolver:
             return ParamResolver()._resolve_parameters_(new_resolver, recursive=True)
         return ParamResolver(cast(ParamDictType, new_dict))
 
-    def __iter__(self) -> Iterator[Union[str, sympy.Expr]]:
+    def __iter__(self) -> Iterator[str | sympy.Expr]:
         return iter(self._param_dict)
 
     def __bool__(self) -> bool:
         return bool(self._param_dict)
 
-    def __getitem__(
-        self, key: Union[cirq.TParamKey, cirq.TParamValComplex]
-    ) -> cirq.TParamValComplex:
+    def __getitem__(self, key: cirq.TParamKey | cirq.TParamValComplex) -> cirq.TParamValComplex:
         return self.value_of(key)
 
     def __hash__(self) -> int:
@@ -244,7 +242,7 @@ class ParamResolver:
             self._param_hash = hash(frozenset(self._param_dict.items()))
         return self._param_hash
 
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         # clear cached hash value when pickling, see #6674
         state = self.__dict__
         if state["_param_hash"] is not None:
@@ -268,7 +266,7 @@ class ParamResolver:
         )
         return f'cirq.ParamResolver({param_dict_repr})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             # JSON requires mappings to have keys of basic types.
             'param_dict': list(self._param_dict.items())

cirq/study/result.py

@@ -19,20 +19,7 @@ from __future__ import annotations
 import abc
 import collections
 import io
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, cast, Iterable, Mapping, Sequence, TYPE_CHECKING, TypeVar, Union
 
 import numpy as np
 import pandas as pd
@@ -48,7 +35,7 @@ T = TypeVar('T')
 TMeasurementKey = Union[str, 'cirq.Qid', Iterable['cirq.Qid']]
 
 
-def _tuple_of_big_endian_int(bit_groups: Iterable[Any]) -> Tuple[int, ...]:
+def _tuple_of_big_endian_int(bit_groups: Iterable[Any]) -> tuple[int, ...]:
     """Returns the big-endian integers specified by groups of bits.
 
     Args:
@@ -170,7 +157,7 @@ class Result(abc.ABC):
         self,
         *,  # Forces keyword args.
         keys: Iterable[TMeasurementKey],
-        fold_func: Callable[[Tuple], T] = cast(Callable[[Tuple], T], _tuple_of_big_endian_int),
+        fold_func: Callable[[tuple], T] = cast(Callable[[tuple], T], _tuple_of_big_endian_int),
     ) -> collections.Counter:
         """Counts the number of times combined measurement results occurred.
 
@@ -229,7 +216,7 @@ class Result(abc.ABC):
         self,
         *,  # Forces keyword args.
         key: TMeasurementKey,
-        fold_func: Callable[[Tuple], T] = cast(Callable[[Tuple], T], value.big_endian_bits_to_int),
+        fold_func: Callable[[tuple], T] = cast(Callable[[tuple], T], value.big_endian_bits_to_int),
     ) -> collections.Counter:
         """Counts the number of times a measurement result occurred.
 
@@ -291,7 +278,7 @@ class Result(abc.ABC):
             raise ValueError(
                 f'Cannot add results with different measurement shapes: {shape} != {other_shape}'
             )
-        all_records: Dict[str, np.ndarray] = {}
+        all_records: dict[str, np.ndarray] = {}
         for key in other.records:
             all_records[key] = np.append(self.records[key], other.records[key], axis=0)
         return ResultDict(params=self.params, records=all_records)
@@ -312,9 +299,9 @@ class ResultDict(Result):
     def __init__(
         self,
         *,  # Forces keyword args.
-        params: Optional[resolver.ParamResolver] = None,
-        measurements: Optional[Mapping[str, np.ndarray]] = None,
-        records: Optional[Mapping[str, np.ndarray]] = None,
+        params: resolver.ParamResolver | None = None,
+        measurements: Mapping[str, np.ndarray] | None = None,
+        records: Mapping[str, np.ndarray] | None = None,
     ) -> None:
         """Inits Result.
 
@@ -341,7 +328,7 @@ class ResultDict(Result):
         self._params = params
         self._measurements = measurements
         self._records = records
-        self._data: Optional[pd.DataFrame] = None
+        self._data: pd.DataFrame | None = None
 
     @property
     def params(self) -> cirq.ParamResolver:
@@ -435,7 +422,7 @@ class ResultDict(Result):
         return cls._from_packed_records(params=params, records=kwargs['records'])
 
 
-def _pack_digits(digits: np.ndarray, pack_bits: str = 'auto') -> Tuple[str, bool]:
+def _pack_digits(digits: np.ndarray, pack_bits: str = 'auto') -> tuple[str, bool]:
     """Returns a string of packed digits and a boolean indicating whether the
     digits were packed as binary values.
 
@@ -474,7 +461,7 @@ def _pack_bits(bits: np.ndarray) -> str:
 
 
 def _unpack_digits(
-    packed_digits: str, binary: bool, dtype: Union[None, str], shape: Union[None, Sequence[int]]
+    packed_digits: str, binary: bool, dtype: None | str, shape: None | Sequence[int]
 ) -> np.ndarray:
     """The opposite of `_pack_digits`.
 

cirq/study/sweepable.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import warnings
-from typing import cast, Iterable, Iterator, List, Optional, Sequence, Union
+from typing import cast, Iterable, Iterator, Sequence, Union
 
 from typing_extensions import Protocol
 
@@ -25,7 +25,7 @@ from cirq._doc import document
 from cirq.study.resolver import ParamResolver, ParamResolverOrSimilarType
 from cirq.study.sweeps import dict_to_product_sweep, ListSweep, Points, Sweep, UnitSweep, Zip
 
-SweepLike = Union[ParamResolverOrSimilarType, Sweep]
+SweepLike = ParamResolverOrSimilarType | Sweep
 document(SweepLike, """An object similar to an iterable of parameter resolvers.""")
 
 
@@ -37,7 +37,7 @@ class _Sweepable(Protocol):
         pass
 
 
-Sweepable = Union[SweepLike, _Sweepable]
+Sweepable = SweepLike | _Sweepable
 document(Sweepable, """An object or collection of objects representing a parameter sweep.""")
 
 
@@ -47,7 +47,7 @@ def to_resolvers(sweepable: Sweepable) -> Iterator[ParamResolver]:
         yield from sweep
 
 
-def to_sweeps(sweepable: Sweepable, metadata: Optional[dict] = None) -> List[Sweep]:
+def to_sweeps(sweepable: Sweepable, metadata: dict | None = None) -> list[Sweep]:
     """Converts a Sweepable to a list of Sweeps."""
     if sweepable is None:
         return [UnitSweep]
@@ -101,7 +101,7 @@ def to_sweep(
     raise TypeError(f'Unexpected sweep-like value: {sweep_or_resolver_list}')
 
 
-def _resolver_to_sweep(resolver: ParamResolver, metadata: Optional[dict]) -> Sweep:
+def _resolver_to_sweep(resolver: ParamResolver, metadata: dict | None) -> Sweep:
     params = resolver.param_dict
     if not params:
         return UnitSweep

cirq/study/sweeps.py

@@ -17,20 +17,7 @@ from __future__ import annotations
 import abc
 import collections
 import itertools
-from typing import (
-    Any,
-    cast,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    overload,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, cast, Iterable, Iterator, overload, Sequence, TYPE_CHECKING, Union
 
 import sympy
 
@@ -41,8 +28,8 @@ from cirq.study import resolver
 if TYPE_CHECKING:
     import cirq
 
-Params = Iterable[Tuple['cirq.TParamKey', 'cirq.TParamVal']]
-ProductOrZipSweepLike = Dict['cirq.TParamKey', Union['cirq.TParamVal', Sequence['cirq.TParamVal']]]
+Params = Iterable[tuple['cirq.TParamKey', 'cirq.TParamVal']]
+ProductOrZipSweepLike = dict['cirq.TParamKey', Union['cirq.TParamVal', Sequence['cirq.TParamVal']]]
 
 
 def _check_duplicate_keys(sweeps):
@@ -75,7 +62,7 @@ class Sweep(metaclass=abc.ABCMeta):
     """
 
     def __mul__(self, other: Sweep) -> Sweep:
-        factors: List[Sweep] = []
+        factors: list[Sweep] = []
         if isinstance(self, Product):
             factors.extend(self.factors)
         else:
@@ -89,7 +76,7 @@ class Sweep(metaclass=abc.ABCMeta):
         return Product(*factors)
 
     def __add__(self, other: Sweep) -> Sweep:
-        sweeps: List[Sweep] = []
+        sweeps: list[Sweep] = []
         if isinstance(self, Zip):
             sweeps.extend(self.sweeps)
         else:
@@ -111,7 +98,7 @@ class Sweep(metaclass=abc.ABCMeta):
 
     @property
     @abc.abstractmethod
-    def keys(self) -> List[cirq.TParamKey]:
+    def keys(self) -> list[cirq.TParamKey]:
         """The keys for the all of the sympy.Symbols that are resolved."""
 
     @abc.abstractmethod
@@ -131,7 +118,7 @@ class Sweep(metaclass=abc.ABCMeta):
     def __getitem__(self, val: slice) -> Sweep:
         pass
 
-    def __getitem__(self, val: Union[int, slice]) -> Union[resolver.ParamResolver, Sweep]:
+    def __getitem__(self, val: int | slice) -> resolver.ParamResolver | Sweep:
         n = len(self)
         if isinstance(val, int):
             if val < -n or val >= n:
@@ -142,7 +129,7 @@ class Sweep(metaclass=abc.ABCMeta):
         if not isinstance(val, slice):
             raise TypeError(f'Sweep indices must be either int or slices, not {type(val)}')
 
-        inds_map: Dict[int, int] = {
+        inds_map: dict[int, int] = {
             sweep_i: slice_i for slice_i, sweep_i in enumerate(range(n)[val])
         }
         results = [resolver.ParamResolver()] * len(inds_map)
@@ -189,7 +176,7 @@ class _Unit(Sweep):
         return True
 
     @property
-    def keys(self) -> List[cirq.TParamKey]:
+    def keys(self) -> list[cirq.TParamKey]:
         return []
 
     def __len__(self) -> int:
@@ -201,7 +188,7 @@ class _Unit(Sweep):
     def __repr__(self) -> str:
         return 'cirq.UnitSweep'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {}
 
 
@@ -236,7 +223,7 @@ class Product(Sweep):
         return hash(tuple(self.factors))
 
     @property
-    def keys(self) -> List[cirq.TParamKey]:
+    def keys(self) -> list[cirq.TParamKey]:
         return list(itertools.chain.from_iterable(factor.keys for factor in self.factors))
 
     def __len__(self) -> int:
@@ -272,7 +259,7 @@ class Product(Sweep):
             factor_strs.append(factor_str)
         return ' * '.join(factor_strs)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['factors'])
 
     @classmethod
@@ -311,7 +298,7 @@ class Concat(Sweep):
         return hash(tuple(self.sweeps))
 
     @property
-    def keys(self) -> List[cirq.TParamKey]:
+    def keys(self) -> list[cirq.TParamKey]:
         return self.sweeps[0].keys
 
     def __len__(self) -> int:
@@ -329,7 +316,7 @@ class Concat(Sweep):
         sweeps_repr = ', '.join(repr(s) for s in self.sweeps)
         return f'Concat({sweeps_repr})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['sweeps'])
 
     @classmethod
@@ -364,7 +351,7 @@ class Zip(Sweep):
         return hash(tuple(self.sweeps))
 
     @property
-    def keys(self) -> List[cirq.TParamKey]:
+    def keys(self) -> list[cirq.TParamKey]:
         return list(itertools.chain.from_iterable(sweep.keys for sweep in self.sweeps))
 
     def __len__(self) -> int:
@@ -386,7 +373,7 @@ class Zip(Sweep):
             return 'Zip()'
         return ' + '.join(str(s) if isinstance(s, Product) else repr(s) for s in self.sweeps)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['sweeps'])
 
     @classmethod
@@ -466,11 +453,11 @@ class SingleSweep(Sweep):
         return hash((self.__class__, self._tuple()))
 
     @abc.abstractmethod
-    def _tuple(self) -> Tuple[Any, ...]:
+    def _tuple(self) -> tuple[Any, ...]:
         pass
 
     @property
-    def keys(self) -> List[cirq.TParamKey]:
+    def keys(self) -> list[cirq.TParamKey]:
         return [self.key]
 
     def param_tuples(self) -> Iterator[Params]:
@@ -486,7 +473,7 @@ class Points(SingleSweep):
     """A simple sweep with explicitly supplied values."""
 
     def __init__(
-        self, key: cirq.TParamKey, points: Sequence[float], metadata: Optional[Any] = None
+        self, key: cirq.TParamKey, points: Sequence[float], metadata: Any | None = None
     ) -> None:
         """Creates a sweep on a variable with supplied values.
 
@@ -503,7 +490,7 @@ class Points(SingleSweep):
         self.points = points
         self.metadata = metadata
 
-    def _tuple(self) -> Tuple[Union[str, sympy.Expr], Sequence[float]]:
+    def _tuple(self) -> tuple[str | sympy.Expr, Sequence[float]]:
         return self.key, tuple(self.points)
 
     def __len__(self) -> int:
@@ -516,7 +503,7 @@ class Points(SingleSweep):
         metadata_repr = f', metadata={self.metadata!r}' if self.metadata is not None else ""
         return f'cirq.Points({self.key!r}, {self.points!r}{metadata_repr})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if self.metadata is not None:
             return protocols.obj_to_dict_helper(self, ["key", "points", "metadata"])
         return protocols.obj_to_dict_helper(self, ["key", "points"])
@@ -531,7 +518,7 @@ class Linspace(SingleSweep):
         start: float,
         stop: float,
         length: int,
-        metadata: Optional[Any] = None,
+        metadata: Any | None = None,
     ) -> None:
         """Creates a linear-spaced sweep for a given key.
 
@@ -552,7 +539,7 @@ class Linspace(SingleSweep):
         self.length = length
         self.metadata = metadata
 
-    def _tuple(self) -> Tuple[Union[str, sympy.Expr], float, float, int]:
+    def _tuple(self) -> tuple[str | sympy.Expr, float, float, int]:
         return (self.key, self.start, self.stop, self.length)
 
     def __len__(self) -> int:
@@ -573,7 +560,7 @@ class Linspace(SingleSweep):
             f'stop={self.stop!r}, length={self.length!r}{metadata_repr})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if self.metadata is not None:
             return protocols.obj_to_dict_helper(
                 self, ["key", "start", "stop", "length", "metadata"]
@@ -595,7 +582,7 @@ class ListSweep(Sweep):
             TypeError: If `resolver_list` is not a `cirq.ParamResolver` or a
                 dict.
         """
-        self.resolver_list: List[resolver.ParamResolver] = []
+        self.resolver_list: list[resolver.ParamResolver] = []
         for r in resolver_list:
             if not isinstance(r, (dict, resolver.ParamResolver)):
                 raise TypeError(f'Not a ParamResolver or dict: <{r!r}>')
@@ -610,7 +597,7 @@ class ListSweep(Sweep):
         return not self == other
 
     @property
-    def keys(self) -> List[cirq.TParamKey]:
+    def keys(self) -> list[cirq.TParamKey]:
         if not self.resolver_list:
             return []
         return list(map(str, self.resolver_list[0].param_dict))
@@ -625,7 +612,7 @@ class ListSweep(Sweep):
     def __repr__(self) -> str:
         return f'cirq.ListSweep({self.resolver_list!r})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ["resolver_list"])
 
 

cirq/testing/circuit_compare.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import itertools
 import random
 from collections import defaultdict
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Union
+from typing import Any, Iterable, Sequence
 
 import numpy as np
 import sympy
@@ -80,7 +80,7 @@ def _measurement_subspaces(
         measurement_mask |= 1 << i
 
     # Keyed by computational basis state with lowest index.
-    measurement_subspaces: Dict[int, List[int]] = defaultdict(list)
+    measurement_subspaces: dict[int, list[int]] = defaultdict(list)
     computational_basis = range(1 << n_qubits)
 
     for basis_state in computational_basis:
@@ -215,7 +215,7 @@ def assert_same_circuits(
 
 def _first_differing_moment_index(
     circuit1: circuits.AbstractCircuit, circuit2: circuits.AbstractCircuit
-) -> Optional[int]:
+) -> int | None:
     for i, (m1, m2) in enumerate(itertools.zip_longest(circuit1, circuit2)):
         if m1 != m2:
             return i
@@ -225,7 +225,7 @@ def _first_differing_moment_index(
 def assert_circuits_have_same_unitary_given_final_permutation(
     actual: circuits.AbstractCircuit,
     expected: circuits.AbstractCircuit,
-    qubit_map: Dict[ops.Qid, ops.Qid],
+    qubit_map: dict[ops.Qid, ops.Qid],
 ) -> None:
     """Asserts two circuits have the same unitary up to a final permutation of qubits.
 
@@ -257,7 +257,7 @@ def assert_circuits_have_same_unitary_given_final_permutation(
 
 
 def assert_has_diagram(
-    actual: Union[circuits.AbstractCircuit, circuits.Moment], desired: str, **kwargs
+    actual: circuits.AbstractCircuit | circuits.Moment, desired: str, **kwargs
 ) -> None:
     """Determines if a given circuit has the desired text diagram.
 

cirq/testing/consistent_controlled_gate_op_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Collection, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Collection, Sequence, TYPE_CHECKING
 
 import numpy as np
 import pytest
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 
 
 class GoodGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:  # pragma: no cover
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:  # pragma: no cover
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
 
@@ -34,15 +34,13 @@ class BadGateOperation(cirq.GateOperation):
     def controlled_by(
         self,
         *control_qubits: cirq.Qid,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
     ) -> cirq.Operation:
         return cirq.ControlledOperation(control_qubits, self, control_values)
 
 
 class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
-    def _eigen_components(self) -> List[Tuple[float, np.ndarray]]:
+    def _eigen_components(self) -> list[tuple[float, np.ndarray]]:
         return [(0, np.diag([1, 0])), (1, np.diag([0, 1]))]
 
     def on(self, *qubits: cirq.Qid) -> cirq.Operation:
@@ -50,11 +48,9 @@ class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
 
     def controlled(
         self,
-        num_controls: Optional[int] = None,
-        control_values: Optional[
-            Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
-        ] = None,
-        control_qid_shape: Optional[Tuple[int, ...]] = None,
+        num_controls: int | None = None,
+        control_values: cv.AbstractControlValues | Sequence[int | Collection[int]] | None = None,
+        control_qid_shape: tuple[int, ...] | None = None,
     ) -> cirq.Gate:
         ret = super().controlled(num_controls, control_values, control_qid_shape)
         if num_controls == 1 and control_values is None: