cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/value/classical_data.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import enum
-from typing import Dict, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Mapping, Sequence, TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -45,21 +47,21 @@ class MeasurementType(enum.IntEnum):
 
 class ClassicalDataStoreReader(abc.ABC):
     @abc.abstractmethod
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> tuple[cirq.MeasurementKey, ...]:
         """Gets the measurement keys in the order they were stored."""
 
     @property
     @abc.abstractmethod
-    def records(self) -> Mapping['cirq.MeasurementKey', List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, list[tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
 
     @property
     @abc.abstractmethod
-    def channel_records(self) -> Mapping['cirq.MeasurementKey', List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, list[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
 
     @abc.abstractmethod
-    def get_int(self, key: 'cirq.MeasurementKey', index=-1) -> int:
+    def get_int(self, key: cirq.MeasurementKey, index=-1) -> int:
         """Gets the integer corresponding to the measurement.
 
         The integer is determined by summing the qubit-dimensional basis value
@@ -81,7 +83,7 @@ class ClassicalDataStoreReader(abc.ABC):
         """
 
     @abc.abstractmethod
-    def get_digits(self, key: 'cirq.MeasurementKey', index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> tuple[int, ...]:
         """Gets the values of the qubits that were measured into this key.
 
         For example, if the measurement of qubits [q0, q1] produces [0, 1],
@@ -107,7 +109,7 @@ class ClassicalDataStoreReader(abc.ABC):
 class ClassicalDataStore(ClassicalDataStoreReader, abc.ABC):
     @abc.abstractmethod
     def record_measurement(
-        self, key: 'cirq.MeasurementKey', measurement: Sequence[int], qubits: Sequence['cirq.Qid']
+        self, key: cirq.MeasurementKey, measurement: Sequence[int], qubits: Sequence[cirq.Qid]
     ):
         """Records a measurement.
 
@@ -122,7 +124,7 @@ class ClassicalDataStore(ClassicalDataStoreReader, abc.ABC):
         """
 
     @abc.abstractmethod
-    def record_channel_measurement(self, key: 'cirq.MeasurementKey', measurement: int):
+    def record_channel_measurement(self, key: cirq.MeasurementKey, measurement: int):
         """Records a channel measurement.
 
         Args:
@@ -141,12 +143,10 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
     def __init__(
         self,
         *,
-        _records: Optional[Dict['cirq.MeasurementKey', List[Tuple[int, ...]]]] = None,
-        _measured_qubits: Optional[
-            Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]]
-        ] = None,
-        _channel_records: Optional[Dict['cirq.MeasurementKey', List[int]]] = None,
-        _measurement_types: Optional[Dict['cirq.MeasurementKey', 'cirq.MeasurementType']] = None,
+        _records: dict[cirq.MeasurementKey, list[tuple[int, ...]]] | None = None,
+        _measured_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]] | None = None,
+        _channel_records: dict[cirq.MeasurementKey, list[int]] | None = None,
+        _measurement_types: dict[cirq.MeasurementKey, cirq.MeasurementType] | None = None,
     ):
         """Initializes a `ClassicalDataDictionaryStore` object."""
         if not _measurement_types:
@@ -165,40 +165,40 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             _measured_qubits = {}
         if _channel_records is None:
             _channel_records = {}
-        self._records: Dict['cirq.MeasurementKey', List[Tuple[int, ...]]] = _records
-        self._measured_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = (
+        self._records: dict[cirq.MeasurementKey, list[tuple[int, ...]]] = _records
+        self._measured_qubits: dict[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]] = (
             _measured_qubits
         )
-        self._channel_records: Dict['cirq.MeasurementKey', List[int]] = _channel_records
-        self._measurement_types: Dict['cirq.MeasurementKey', 'cirq.MeasurementType'] = (
+        self._channel_records: dict[cirq.MeasurementKey, list[int]] = _channel_records
+        self._measurement_types: dict[cirq.MeasurementKey, cirq.MeasurementType] = (
             _measurement_types
         )
 
     @property
-    def records(self) -> Mapping['cirq.MeasurementKey', List[Tuple[int, ...]]]:
+    def records(self) -> Mapping[cirq.MeasurementKey, list[tuple[int, ...]]]:
         """Gets the a mapping from measurement key to measurement records."""
         return self._records
 
     @property
-    def channel_records(self) -> Mapping['cirq.MeasurementKey', List[int]]:
+    def channel_records(self) -> Mapping[cirq.MeasurementKey, list[int]]:
         """Gets the a mapping from measurement key to channel measurement records."""
         return self._channel_records
 
     @property
-    def measured_qubits(self) -> Mapping['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]]:
+    def measured_qubits(self) -> Mapping[cirq.MeasurementKey, list[tuple[cirq.Qid, ...]]]:
         """Gets the a mapping from measurement key to the qubits measured."""
         return self._measured_qubits
 
     @property
-    def measurement_types(self) -> Mapping['cirq.MeasurementKey', 'cirq.MeasurementType']:
+    def measurement_types(self) -> Mapping[cirq.MeasurementKey, cirq.MeasurementType]:
         """Gets the a mapping from measurement key to the measurement type."""
         return self._measurement_types
 
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> tuple[cirq.MeasurementKey, ...]:
         return tuple(self._measurement_types.keys())
 
     def record_measurement(
-        self, key: 'cirq.MeasurementKey', measurement: Sequence[int], qubits: Sequence['cirq.Qid']
+        self, key: cirq.MeasurementKey, measurement: Sequence[int], qubits: Sequence[cirq.Qid]
     ):
         if len(measurement) != len(qubits):
             raise ValueError(f'{len(measurement)} measurements but {len(qubits)} qubits.')
@@ -217,7 +217,7 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
         measured_qubits.append(tuple(qubits))
         self._records[key].append(tuple(measurement))
 
-    def record_channel_measurement(self, key: 'cirq.MeasurementKey', measurement: int):
+    def record_channel_measurement(self, key: cirq.MeasurementKey, measurement: int):
         if key not in self._measurement_types:
             self._measurement_types[key] = MeasurementType.CHANNEL
             self._channel_records[key] = []
@@ -225,14 +225,14 @@ class ClassicalDataDictionaryStore(ClassicalDataStore):
             raise ValueError(f"Measurement already logged to key {key}")
         self._channel_records[key].append(measurement)
 
-    def get_digits(self, key: 'cirq.MeasurementKey', index=-1) -> Tuple[int, ...]:
+    def get_digits(self, key: cirq.MeasurementKey, index=-1) -> tuple[int, ...]:
         return (
             self._records[key][index]
             if self._measurement_types[key] == MeasurementType.MEASUREMENT
             else (self._channel_records[key][index],)
         )
 
-    def get_int(self, key: 'cirq.MeasurementKey', index=-1) -> int:
+    def get_int(self, key: cirq.MeasurementKey, index=-1) -> int:
         if key not in self._measurement_types:
             raise KeyError(f'The measurement key {key} is not in {self._measurement_types}')
         measurement_type = self._measurement_types[key]

cirq/value/classical_data_test.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import re
 
 import pytest
@@ -22,7 +25,7 @@ mkey_c = cirq.MeasurementKey('c')
 two_qubits = tuple(cirq.LineQubit.range(2))
 
 
-def test_init():
+def test_init() -> None:
     cd = cirq.ClassicalDataDictionaryStore()
     assert cd.records == {}
     assert cd.keys() == ()
@@ -44,7 +47,7 @@ def test_init():
     }
 
 
-def test_record_measurement():
+def test_record_measurement() -> None:
     cd = cirq.ClassicalDataDictionaryStore()
     cd.record_measurement(mkey_m, (0, 1), two_qubits)
     assert cd.records == {mkey_m: [(0, 1)]}
@@ -52,7 +55,7 @@ def test_record_measurement():
     assert cd.measured_qubits == {mkey_m: [two_qubits]}
 
 
-def test_record_measurement_errors():
+def test_record_measurement_errors() -> None:
     cd = cirq.ClassicalDataDictionaryStore()
     with pytest.raises(ValueError, match='3 measurements but 2 qubits'):
         cd.record_measurement(mkey_m, (0, 1, 2), two_qubits)
@@ -68,14 +71,14 @@ def test_record_measurement_errors():
         cd.record_measurement(mkey_m, (1, 0), tuple(cirq.LineQid.range(2, dimension=3)))
 
 
-def test_record_channel_measurement():
+def test_record_channel_measurement() -> None:
     cd = cirq.ClassicalDataDictionaryStore()
     cd.record_channel_measurement(mkey_m, 1)
     assert cd.channel_records == {mkey_m: [1]}
     assert cd.keys() == (mkey_m,)
 
 
-def test_record_channel_measurement_errors():
+def test_record_channel_measurement_errors() -> None:
     cd = cirq.ClassicalDataDictionaryStore()
     cd.record_channel_measurement(mkey_m, 1)
     cd.record_channel_measurement(mkey_m, 1)
@@ -88,7 +91,7 @@ def test_record_channel_measurement_errors():
         cd.record_channel_measurement(mkey_m, 1)
 
 
-def test_get_int():
+def test_get_int() -> None:
     cd = cirq.ClassicalDataDictionaryStore()
     cd.record_measurement(mkey_m, (0, 1), two_qubits)
     assert cd.get_int(mkey_m) == 1
@@ -106,7 +109,7 @@ def test_get_int():
         cd.get_int(mkey_m)
 
 
-def test_copy():
+def test_copy() -> None:
     cd = cirq.ClassicalDataDictionaryStore(
         _records={mkey_m: [(0, 1)]},
         _measured_qubits={mkey_m: [two_qubits]},
@@ -129,7 +132,7 @@ def test_copy():
     assert cd1.measurement_types == cd.measurement_types
 
 
-def test_repr():
+def test_repr() -> None:
     cd = cirq.ClassicalDataDictionaryStore(
         _records={mkey_m: [(0, 1)]},
         _measured_qubits={mkey_m: [two_qubits]},

cirq/value/condition.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import dataclasses
-from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple, TYPE_CHECKING
+from typing import Any, Mapping, TYPE_CHECKING
 
 import attrs
 import sympy
@@ -32,15 +34,15 @@ class Condition(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def keys(self) -> Tuple['cirq.MeasurementKey', ...]:
+    def keys(self) -> tuple[cirq.MeasurementKey, ...]:
         """Gets the control keys."""
 
     @abc.abstractmethod
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         """Replaces the control keys."""
 
     @abc.abstractmethod
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         """Resolves the condition based on the measurements."""
 
     @property
@@ -48,24 +50,24 @@ class Condition(abc.ABC):
     def qasm(self):
         """Returns the qasm of this condition."""
 
-    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> str | None:
         return self.qasm
 
-    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> 'cirq.Condition':
+    def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]) -> cirq.Condition:
         condition = self
         for k in self.keys:
             condition = condition.replace_key(k, mkp.with_measurement_key_mapping(k, key_map))
         return condition
 
-    def _with_key_path_prefix_(self, path: Tuple[str, ...]) -> 'cirq.Condition':
+    def _with_key_path_prefix_(self, path: tuple[str, ...]) -> cirq.Condition:
         condition = self
         for k in self.keys:
             condition = condition.replace_key(k, mkp.with_key_path_prefix(k, path))
         return condition
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
-    ) -> 'cirq.Condition':
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
+    ) -> cirq.Condition:
         condition = self
         for key in self.keys:
             for i in range(len(path) + 1):
@@ -85,14 +87,14 @@ class KeyCondition(Condition):
     time of resolution.
     """
 
-    key: 'cirq.MeasurementKey'
+    key: cirq.MeasurementKey
     index: int = -1
 
     @property
     def keys(self):
         return (self.key,)
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return KeyCondition(replacement) if self.key == current else self
 
     def __str__(self):
@@ -103,7 +105,7 @@ class KeyCondition(Condition):
             return f'cirq.KeyCondition({self.key!r}, {self.index})'
         return f'cirq.KeyCondition({self.key!r})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         if self.key not in classical_data.keys():
             raise ValueError(f'Measurement key {self.key} missing when testing classical control')
         return classical_data.get_int(self.key, self.index) != 0
@@ -119,7 +121,7 @@ class KeyCondition(Condition):
     def qasm(self):
         raise ValueError('QASM is defined only for SympyConditions of type key == constant.')
 
-    def _qasm_(self, args: 'cirq.QasmArgs', **kwargs) -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs, **kwargs) -> str | None:
         args.validate_version('2.0', '3.0')
         key_str = str(self.key)
         if key_str not in args.meas_key_id_map:
@@ -162,7 +164,7 @@ class BitMaskKeyCondition(Condition):
         - bitmask: Optional bitmask to apply before doing the comparison.
     """
 
-    key: 'cirq.MeasurementKey' = attrs.field(
+    key: cirq.MeasurementKey = attrs.field(
         converter=lambda x: (
             x
             if isinstance(x, measurement_key.MeasurementKey)
@@ -172,7 +174,7 @@ class BitMaskKeyCondition(Condition):
     index: int = -1
     target_value: int = 0
     equal_target: bool = False
-    bitmask: Optional[int] = None
+    bitmask: int | None = None
 
     @property
     def keys(self):
@@ -180,8 +182,8 @@ class BitMaskKeyCondition(Condition):
 
     @staticmethod
     def create_equal_mask(
-        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
-    ) -> 'BitMaskKeyCondition':
+        key: cirq.MeasurementKey, bitmask: int, *, index: int = -1
+    ) -> BitMaskKeyCondition:
         """Creates a condition that evaluates (meas & bitmask) == bitmask."""
         return BitMaskKeyCondition(
             key, index, target_value=bitmask, equal_target=True, bitmask=bitmask
@@ -189,14 +191,14 @@ class BitMaskKeyCondition(Condition):
 
     @staticmethod
     def create_not_equal_mask(
-        key: 'cirq.MeasurementKey', bitmask: int, *, index: int = -1
-    ) -> 'BitMaskKeyCondition':
+        key: cirq.MeasurementKey, bitmask: int, *, index: int = -1
+    ) -> BitMaskKeyCondition:
         """Creates a condition that evaluates (meas & bitmask) != bitmask."""
         return BitMaskKeyCondition(
             key, index, target_value=bitmask, equal_target=False, bitmask=bitmask
         )
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return BitMaskKeyCondition(replacement) if self.key == current else self
 
     def __str__(self):
@@ -218,7 +220,7 @@ class BitMaskKeyCondition(Condition):
         parameters = ', '.join(f'{f.name}={repr(values[f.name])}' for f in attrs.fields(type(self)))
         return f'cirq.BitMaskKeyCondition({parameters})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         if self.key not in classical_data.keys():
             raise ValueError(f'Measurement key {self.key} missing when testing classical control')
         value = classical_data.get_int(self.key, self.index)
@@ -269,7 +271,7 @@ class SympyCondition(Condition):
             # keep the former here.
         )
 
-    def replace_key(self, current: 'cirq.MeasurementKey', replacement: 'cirq.MeasurementKey'):
+    def replace_key(self, current: cirq.MeasurementKey, replacement: cirq.MeasurementKey):
         return SympyCondition(self.expr.subs({str(current): sympy.Symbol(str(replacement))}))
 
     def __str__(self):
@@ -278,12 +280,12 @@ class SympyCondition(Condition):
     def __repr__(self):
         return f'cirq.SympyCondition({proper_repr(self.expr)})'
 
-    def resolve(self, classical_data: 'cirq.ClassicalDataStoreReader') -> bool:
+    def resolve(self, classical_data: cirq.ClassicalDataStoreReader) -> bool:
         missing = [str(k) for k in self.keys if k not in classical_data.keys()]
         if missing:
             raise ValueError(f'Measurement keys {missing} missing when testing classical control')
 
-        replacements: Dict[str, Any] = {}
+        replacements: dict[str, Any] = {}
         for symbol in self.expr.free_symbols:
             if isinstance(symbol, sympy.Symbol):
                 name = symbol.name

cirq/value/condition_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import re
 
 import pytest

cirq/value/digits.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Iterable, List, Optional, overload, Union
+from __future__ import annotations
+
+from typing import Any, Iterable, overload
 
 
 def big_endian_bits_to_int(bits: Iterable[Any]) -> int:
@@ -46,7 +48,7 @@ def big_endian_bits_to_int(bits: Iterable[Any]) -> int:
     return result
 
 
-def big_endian_int_to_bits(val: int, *, bit_count: int) -> List[int]:
+def big_endian_int_to_bits(val: int, *, bit_count: int) -> list[int]:
     """Returns the big-endian bits of an integer.
 
     Args:
@@ -72,7 +74,7 @@ def big_endian_int_to_bits(val: int, *, bit_count: int) -> List[int]:
     return [(val >> i) & 1 for i in range(bit_count)[::-1]]
 
 
-def big_endian_digits_to_int(digits: Iterable[int], *, base: Union[int, Iterable[int]]) -> int:
+def big_endian_digits_to_int(digits: Iterable[int], *, base: int | Iterable[int]) -> int:
     """Returns the big-endian integer specified by the given digits and base.
 
     Args:
@@ -118,20 +120,24 @@ def big_endian_digits_to_int(digits: Iterable[int], *, base: Union[int, Iterable
     return result
 
 
-# pylint: disable=function-redefined
 @overload
-def big_endian_int_to_digits(val: int, *, digit_count: int, base: int) -> List[int]:
+def big_endian_int_to_digits(val: int, *, digit_count: int, base: int) -> list[int]:
     pass
 
 
 @overload
-def big_endian_int_to_digits(val: int, *, base: Iterable[int]) -> List[int]:
+def big_endian_int_to_digits(val: int, *, digit_count: int, base: Iterable[int]) -> list[int]:
+    pass
+
+
+@overload
+def big_endian_int_to_digits(val: int, *, base: Iterable[int]) -> list[int]:
     pass
 
 
 def big_endian_int_to_digits(
-    val: int, *, digit_count: Optional[int] = None, base: Union[int, Iterable[int]]
-) -> List[int]:
+    val: int, *, digit_count: int | None = None, base: int | Iterable[int]
+) -> list[int]:
     """Separates an integer into big-endian digits.
 
     Args:
@@ -187,6 +193,3 @@ def big_endian_int_to_digits(
         )
 
     return result[::-1]
-
-
-# pylint: enable=function-redefined

cirq/value/digits_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq

cirq/value/duration.py

@@ -11,10 +11,13 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 """A typed time delta that supports picosecond accuracy."""
 
+from __future__ import annotations
+
 import datetime
-from typing import AbstractSet, Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
+from typing import AbstractSet, Any, TYPE_CHECKING, TypeAlias, Union
 
 import numpy as np
 import sympy
@@ -42,8 +45,8 @@ document(
 )
 
 
-_NUMERIC_INPUT_TYPE = Union[int, float, sympy.Expr, np.number]
-_NUMERIC_OUTPUT_TYPE = Union[int, float, sympy.Expr]
+_NUMERIC_INPUT_TYPE: TypeAlias = int | float | sympy.Expr | np.number
+_NUMERIC_OUTPUT_TYPE: TypeAlias = int | float | sympy.Expr
 
 
 class Duration:
@@ -51,7 +54,7 @@ class Duration:
 
     def __init__(
         self,
-        value: DURATION_LIKE = None,
+        value: DURATION_LIKE | int = None,
         *,  # Force keyword args.
         picos: _NUMERIC_INPUT_TYPE = 0,
         nanos: _NUMERIC_INPUT_TYPE = 0,
@@ -79,7 +82,7 @@ class Duration:
             >>> print(cirq.Duration(micros=1.5 * sympy.Symbol('t')))
             (1500.0*t) ns
         """
-        self._time_vals: List[_NUMERIC_INPUT_TYPE] = [0, 0, 0, 0]
+        self._time_vals: list[_NUMERIC_INPUT_TYPE] = [0, 0, 0, 0]
         self._multipliers = [1, 1000, 1000_000, 1000_000_000]
         if value is not None and value != 0:
             if isinstance(value, datetime.timedelta):
@@ -98,7 +101,7 @@ class Duration:
     def _parameter_names_(self) -> AbstractSet[str]:
         return protocols.parameter_names(self._time_vals)
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'Duration':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> Duration:
         return _duration_from_time_vals(
             protocols.resolve_parameters(self._time_vals, resolver, recursive)
         )
@@ -121,16 +124,16 @@ class Duration:
         """Returns the number of milliseconds that the duration spans."""
         return self.total_picos() / 1000_000_000
 
-    def __add__(self, other) -> 'Duration':
+    def __add__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
         return _duration_from_time_vals(_add_time_vals(self._time_vals, other._time_vals))
 
-    def __radd__(self, other) -> 'Duration':
+    def __radd__(self, other) -> Duration:
         return self.__add__(other)
 
-    def __sub__(self, other) -> 'Duration':
+    def __sub__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
@@ -138,7 +141,7 @@ class Duration:
             _add_time_vals(self._time_vals, [-x for x in other._time_vals])
         )
 
-    def __rsub__(self, other) -> 'Duration':
+    def __rsub__(self, other) -> Duration:
         other = _attempt_duration_like_to_duration(other)
         if other is None:
             return NotImplemented
@@ -146,17 +149,17 @@ class Duration:
             _add_time_vals(other._time_vals, [-x for x in self._time_vals])
         )
 
-    def __mul__(self, other) -> 'Duration':
+    def __mul__(self, other) -> Duration:
         if not isinstance(other, (int, float, sympy.Expr)):
             return NotImplemented
         if other == 0:
             return _duration_from_time_vals([0] * 4)
         return _duration_from_time_vals([x * other for x in self._time_vals])
 
-    def __rmul__(self, other) -> 'Duration':
+    def __rmul__(self, other) -> Duration:
         return self.__mul__(other)
 
-    def __truediv__(self, other) -> Union['Duration', float]:
+    def __truediv__(self, other) -> Duration | float:
         if isinstance(other, (int, float, sympy.Expr)):
             new_time_vals = [x / other for x in self._time_vals]
             return _duration_from_time_vals(new_time_vals)
@@ -211,7 +214,7 @@ class Duration:
             return hash(datetime.timedelta(microseconds=self.total_picos() / 1000000))
         return hash((Duration, self.total_picos()))
 
-    def _decompose_into_amount_unit_suffix(self) -> Tuple[int, str, str]:
+    def _decompose_into_amount_unit_suffix(self) -> tuple[int, str, str]:
         picos = self.total_picos()
         if (
             isinstance(picos, sympy.Mul)
@@ -258,11 +261,11 @@ class Duration:
         amount, unit, _ = self._decompose_into_amount_unit_suffix()
         return f'cirq.Duration({unit}={proper_repr(amount)})'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'picos': self.total_picos()}
 
 
-def _attempt_duration_like_to_duration(value: Any) -> Optional[Duration]:
+def _attempt_duration_like_to_duration(value: Any) -> Duration | None:
     if isinstance(value, Duration):
         return value
     if isinstance(value, datetime.timedelta):
@@ -273,9 +276,9 @@ def _attempt_duration_like_to_duration(value: Any) -> Optional[Duration]:
 
 
 def _add_time_vals(
-    val1: List[_NUMERIC_INPUT_TYPE], val2: List[_NUMERIC_INPUT_TYPE]
-) -> List[_NUMERIC_INPUT_TYPE]:
-    ret: List[_NUMERIC_INPUT_TYPE] = []
+    val1: list[_NUMERIC_INPUT_TYPE], val2: list[_NUMERIC_INPUT_TYPE]
+) -> list[_NUMERIC_INPUT_TYPE]:
+    ret: list[_NUMERIC_INPUT_TYPE] = []
     for i in range(4):
         if val1[i] and val2[i]:
             ret.append(val1[i] + val2[i])
@@ -284,7 +287,7 @@ def _add_time_vals(
     return ret
 
 
-def _duration_from_time_vals(time_vals: List[_NUMERIC_INPUT_TYPE]):
+def _duration_from_time_vals(time_vals: list[_NUMERIC_INPUT_TYPE]):
     ret = Duration()
     ret._time_vals = time_vals
     return ret

cirq/value/duration_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from datetime import timedelta
 
 import numpy as np