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

cirq/value/linear_dict.py

@@ -14,11 +14,12 @@
 
 """Linear combination represented as mapping of things to coefficients."""
 
+from __future__ import annotations
+
 from typing import (
     AbstractSet,
     Any,
     Callable,
-    Dict,
     Generic,
     ItemsView,
     Iterable,
@@ -26,12 +27,9 @@ from typing import (
     KeysView,
     Mapping,
     MutableMapping,
-    Optional,
     overload,
-    Tuple,
     TYPE_CHECKING,
     TypeVar,
-    Union,
     ValuesView,
 )
 
@@ -44,7 +42,7 @@ from cirq import protocols
 if TYPE_CHECKING:
     import cirq
 
-Scalar = Union[complex, np.number]
+Scalar = complex | np.number
 TVector = TypeVar('TVector')
 
 TDefault = TypeVar('TDefault')
@@ -63,7 +61,7 @@ class _SympyPrinter(sympy.printing.str.StrPrinter):
         return super()._print(expr, **kwargs)
 
 
-def _format_coefficient(format_spec: str, coefficient: 'cirq.TParamValComplex') -> str:
+def _format_coefficient(format_spec: str, coefficient: cirq.TParamValComplex) -> str:
     if isinstance(coefficient, sympy.Basic):
         printer = _SympyPrinter(format_spec)
         return printer.doprint(coefficient)
@@ -83,7 +81,7 @@ def _format_coefficient(format_spec: str, coefficient: 'cirq.TParamValComplex')
     return f'({real_str}+{imag_str}j)'
 
 
-def _format_term(format_spec: str, vector: TVector, coefficient: 'cirq.TParamValComplex') -> str:
+def _format_term(format_spec: str, vector: TVector, coefficient: cirq.TParamValComplex) -> str:
     coefficient_str = _format_coefficient(format_spec, coefficient)
     if not coefficient_str:
         return coefficient_str
@@ -93,7 +91,7 @@ def _format_term(format_spec: str, vector: TVector, coefficient: 'cirq.TParamVal
     return '+' + result
 
 
-def _format_terms(terms: Iterable[Tuple[TVector, 'cirq.TParamValComplex']], format_spec: str):
+def _format_terms(terms: Iterable[tuple[TVector, cirq.TParamValComplex]], format_spec: str):
     formatted_terms = [_format_term(format_spec, vector, coeff) for vector, coeff in terms]
     s = ''.join(formatted_terms)
     if not s:
@@ -120,8 +118,8 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
 
     def __init__(
         self,
-        terms: Optional[Mapping[TVector, 'cirq.TParamValComplex']] = None,
-        validator: Optional[Callable[[TVector], bool]] = None,
+        terms: Mapping[TVector, cirq.TParamValComplex] | None = None,
+        validator: Callable[[TVector], bool] | None = None,
     ) -> None:
         """Initializes linear combination from a collection of terms.
 
@@ -136,7 +134,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         """
         self._has_validator = validator is not None
         self._is_valid = validator or (lambda x: True)
-        self._terms: Dict[TVector, 'cirq.TParamValComplex'] = {}
+        self._terms: dict[TVector, cirq.TParamValComplex] = {}
         if terms is not None:
             self.update(terms)
 
@@ -172,31 +170,30 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.keys()
 
-    def values(self) -> ValuesView['cirq.TParamValComplex']:
+    def values(self) -> ValuesView[cirq.TParamValComplex]:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.values()
 
-    def items(self) -> ItemsView[TVector, 'cirq.TParamValComplex']:
+    def items(self) -> ItemsView[TVector, cirq.TParamValComplex]:
         snapshot = self.copy().clean(atol=0)
         return snapshot._terms.items()
 
-    # pylint: disable=function-redefined
     @overload
     def update(
-        self, other: Mapping[TVector, 'cirq.TParamValComplex'], **kwargs: 'cirq.TParamValComplex'
+        self, other: Mapping[TVector, cirq.TParamValComplex], **kwargs: cirq.TParamValComplex
     ) -> None:
         pass
 
     @overload
     def update(
         self,
-        other: Iterable[Tuple[TVector, 'cirq.TParamValComplex']],
-        **kwargs: 'cirq.TParamValComplex',
+        other: Iterable[tuple[TVector, cirq.TParamValComplex]],
+        **kwargs: cirq.TParamValComplex,
     ) -> None:
         pass
 
     @overload
-    def update(self, *args: Any, **kwargs: 'cirq.TParamValComplex') -> None:
+    def update(self, *args: Any, **kwargs: cirq.TParamValComplex) -> None:
         pass
 
     def update(self, *args, **kwargs):
@@ -211,11 +208,11 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         self.clean(atol=0)
 
     @overload
-    def get(self, vector: TVector) -> 'cirq.TParamValComplex':
+    def get(self, vector: TVector) -> cirq.TParamValComplex:
         pass
 
     @overload
-    def get(self, vector: TVector, default: TDefault) -> Union['cirq.TParamValComplex', TDefault]:
+    def get(self, vector: TVector, default: TDefault) -> cirq.TParamValComplex | TDefault:
         pass
 
     def get(self, vector, default=0):
@@ -223,15 +220,13 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
             return default
         return self._terms.get(vector)
 
-    # pylint: enable=function-redefined
-
     def __contains__(self, vector: Any) -> bool:
         return vector in self._terms and self._terms[vector] != 0
 
-    def __getitem__(self, vector: TVector) -> 'cirq.TParamValComplex':
+    def __getitem__(self, vector: TVector) -> cirq.TParamValComplex:
         return self._terms.get(vector, 0)
 
-    def __setitem__(self, vector: TVector, coefficient: 'cirq.TParamValComplex') -> None:
+    def __setitem__(self, vector: TVector, coefficient: cirq.TParamValComplex) -> None:
         self._check_vector_valid(vector)
         if coefficient != 0:
             self._terms[vector] = coefficient
@@ -279,21 +274,21 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         factory = type(self)
         return factory({v: -c for v, c in self.items()})
 
-    def __imul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __imul__(self, a: cirq.TParamValComplex) -> Self:
         for vector in self:
             self._terms[vector] *= a
         self.clean(atol=0)
         return self
 
-    def __mul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __mul__(self, a: cirq.TParamValComplex) -> Self:
         result = self.copy()
         result *= a
         return result.copy()
 
-    def __rmul__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __rmul__(self, a: cirq.TParamValComplex) -> Self:
         return self.__mul__(a)
 
-    def __truediv__(self, a: 'cirq.TParamValComplex') -> Self:
+    def __truediv__(self, a: cirq.TParamValComplex) -> Self:
         return self.__mul__(1 / a)
 
     def __bool__(self) -> bool:
@@ -352,7 +347,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
         else:
             p.text(str(self))
 
-    def _json_dict_(self) -> Dict[Any, Any]:
+    def _json_dict_(self) -> dict[Any, Any]:
         if self._has_validator:
             raise ValueError('LinearDict with a validator is not json serializable.')
         return {
@@ -370,7 +365,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, 'cirq.TParamValComple
     def _parameter_names_(self) -> AbstractSet[str]:
         return set(name for v in self._terms.values() for name in protocols.parameter_names(v))
 
-    def _resolve_parameters_(self, resolver: 'cirq.ParamResolver', recursive: bool) -> 'LinearDict':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> LinearDict:
         result = self.copy()
         result.update(
             {

cirq/value/linear_dict_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 numpy as np
 import pytest
 import sympy
@@ -27,7 +29,7 @@ def test_empty_init():
 
 sym = sympy.Symbol('sym')
 expr = sym * -(2 + 3j)
-symval = expr.subs({'sym': 5})
+symval = expr.subs({'sym': 5})  # pylint: disable=assignment-from-no-return
 symvalresolved = -10 - 15j
 
 
@@ -391,8 +393,8 @@ def test_scalar_division(scalar, terms, terms_expected):
     linear_dict = cirq.LinearDict(terms)
     actual = linear_dict / scalar
     expected = cirq.LinearDict(terms_expected)
-    assert actual == expected
-    assert expected == actual
+    assert cirq.approx_eq(actual, expected)
+    assert cirq.approx_eq(expected, actual)
 
 
 @pytest.mark.parametrize(
@@ -408,7 +410,7 @@ def test_scalar_division(scalar, terms, terms_expected):
 )
 def test_expressions(expression, expected):
     assert expression == expected
-    assert not expression != expected
+    assert not expression != expected  # noqa: SIM202
     assert cirq.approx_eq(expression, expected)
 
 
@@ -435,8 +437,8 @@ def test_equal(terms_1, terms_2):
     linear_dict_2 = cirq.LinearDict(terms_2)
     assert linear_dict_1 == linear_dict_2
     assert linear_dict_2 == linear_dict_1
-    assert not linear_dict_1 != linear_dict_2
-    assert not linear_dict_2 != linear_dict_1
+    assert not linear_dict_1 != linear_dict_2  # noqa: SIM202
+    assert not linear_dict_2 != linear_dict_1  # noqa: SIM202
 
 
 @pytest.mark.parametrize(
@@ -454,8 +456,8 @@ def test_unequal(terms_1, terms_2):
     linear_dict_2 = cirq.LinearDict(terms_2)
     assert linear_dict_1 != linear_dict_2
     assert linear_dict_2 != linear_dict_1
-    assert not linear_dict_1 == linear_dict_2
-    assert not linear_dict_2 == linear_dict_1
+    assert not linear_dict_1 == linear_dict_2  # noqa: SIM201
+    assert not linear_dict_2 == linear_dict_1  # noqa: SIM201
 
 
 @pytest.mark.parametrize(

cirq/value/measurement_key.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import dataclasses
-from typing import Any, Dict, FrozenSet, Mapping, Optional, Tuple
+from typing import Any, Mapping
 
 MEASUREMENT_KEY_SEPARATOR = ':'
 
@@ -33,11 +35,11 @@ class MeasurementKey:
             appears first in the tuple.
     """
 
-    _hash: Optional[int] = dataclasses.field(default=None, init=False)
-    _str: Optional[str] = dataclasses.field(default=None, init=False)
+    _hash: int | None = dataclasses.field(default=None, init=False)
+    _str: str | None = dataclasses.field(default=None, init=False)
 
     name: str
-    path: Tuple[str, ...] = dataclasses.field(default_factory=tuple)
+    path: tuple[str, ...] = dataclasses.field(default_factory=tuple)
 
     def __post_init__(self):
         if not isinstance(self.name, str):
@@ -49,7 +51,7 @@ class MeasurementKey:
                 '`MeasurementKey.parse_serialized` for correct behavior.'
             )
 
-    def replace(self, **changes) -> 'MeasurementKey':
+    def replace(self, **changes) -> MeasurementKey:
         """Returns a copy of this MeasurementKey with the specified changes."""
         return dataclasses.replace(self, **changes)
 
@@ -76,7 +78,7 @@ class MeasurementKey:
             object.__setattr__(self, '_hash', hash(str(self)))
         return self._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 "_hash" in state:
@@ -102,7 +104,7 @@ class MeasurementKey:
         return cls(name=name, path=tuple(path))
 
     @classmethod
-    def parse_serialized(cls, key_str: str) -> 'MeasurementKey':
+    def parse_serialized(cls, key_str: str) -> MeasurementKey:
         """Parses the serialized string representation of `Measurementkey` into a `MeasurementKey`.
 
         This is the only way to construct a `MeasurementKey` from a nested string representation
@@ -110,10 +112,10 @@ class MeasurementKey:
         components = key_str.split(MEASUREMENT_KEY_SEPARATOR)
         return MeasurementKey(name=components[-1], path=tuple(components[:-1]))
 
-    def _with_key_path_(self, path: Tuple[str, ...]):
+    def _with_key_path_(self, path: tuple[str, ...]):
         return self.replace(path=path)
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]):
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]):
         return self._with_key_path_(path=prefix + self.path)
 
     def with_key_path_prefix(self, *path_component: str):
@@ -124,9 +126,7 @@ class MeasurementKey:
         """
         return self.replace(path=path_component + self.path)
 
-    def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['MeasurementKey']
-    ):
+    def _with_rescoped_keys_(self, path: tuple[str, ...], bindable_keys: frozenset[MeasurementKey]):
         return self.replace(path=path + self.path)
 
     def _with_measurement_key_mapping_(self, key_map: Mapping[str, str]):

cirq/value/measurement_key_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/periodic_value.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import AbstractSet, Any, TYPE_CHECKING
 
 import sympy
@@ -35,7 +37,7 @@ class PeriodicValue:
     interval.
     """
 
-    def __init__(self, value: 'cirq.TParamVal', period: 'cirq.TParamVal'):
+    def __init__(self, value: cirq.TParamVal, period: cirq.TParamVal):
         """Initializes the equivalence class.
 
         Args:
@@ -99,9 +101,7 @@ class PeriodicValue:
 
         return parameter_names(self.value) | parameter_names(self.period)
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'PeriodicValue':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> PeriodicValue:
         # HACK: Avoids circular dependencies.
         from cirq.protocols import resolve_parameters
 

cirq/value/periodic_value_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 import sympy
 
 import cirq
 
 
-def test_periodic_value_equality():
+def test_periodic_value_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(
         cirq.PeriodicValue(1, 2),
@@ -34,7 +36,7 @@ def test_periodic_value_equality():
     eq.add_equality_group(cirq.PeriodicValue(2, 4))
 
 
-def test_periodic_value_approx_eq_basic():
+def test_periodic_value_approx_eq_basic() -> None:
     assert cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.0, 2.0), atol=0.1)
     assert cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.0), atol=0.3)
     assert not cirq.approx_eq(cirq.PeriodicValue(1.0, 2.0), cirq.PeriodicValue(1.2, 2.0), atol=0.1)
@@ -49,12 +51,12 @@ def test_periodic_value_approx_eq_basic():
     )
 
 
-def test_periodic_value_approx_eq_normalized():
+def test_periodic_value_approx_eq_normalized() -> None:
     assert cirq.approx_eq(cirq.PeriodicValue(1.0, 3.0), cirq.PeriodicValue(4.1, 3.0), atol=0.2)
     assert cirq.approx_eq(cirq.PeriodicValue(1.0, 3.0), cirq.PeriodicValue(-2.1, 3.0), atol=0.2)
 
 
-def test_periodic_value_approx_eq_boundary():
+def test_periodic_value_approx_eq_boundary() -> None:
     assert cirq.approx_eq(cirq.PeriodicValue(0.0, 2.0), cirq.PeriodicValue(1.9, 2.0), atol=0.2)
     assert cirq.approx_eq(cirq.PeriodicValue(0.1, 2.0), cirq.PeriodicValue(1.9, 2.0), atol=0.3)
     assert cirq.approx_eq(cirq.PeriodicValue(1.9, 2.0), cirq.PeriodicValue(0.1, 2.0), atol=0.3)
@@ -64,7 +66,7 @@ def test_periodic_value_approx_eq_boundary():
     assert cirq.approx_eq(cirq.PeriodicValue(0.4, 1.0), cirq.PeriodicValue(0.6, 1.0), atol=0.3)
 
 
-def test_periodic_value_types_mismatch():
+def test_periodic_value_types_mismatch() -> None:
     assert not cirq.approx_eq(cirq.PeriodicValue(0.0, 2.0), 0.0, atol=0.2)
     assert not cirq.approx_eq(0.0, cirq.PeriodicValue(0.0, 2.0), atol=0.2)
 
@@ -79,7 +81,9 @@ def test_periodic_value_types_mismatch():
     ],
 )
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_periodic_value_is_parameterized(value, is_parameterized, parameter_names, resolve_fn):
+def test_periodic_value_is_parameterized(
+    value, is_parameterized, parameter_names, resolve_fn
+) -> None:
     assert cirq.is_parameterized(value) == is_parameterized
     assert cirq.parameter_names(value) == parameter_names
     resolved = resolve_fn(value, {p: 1 for p in parameter_names})
@@ -98,5 +102,5 @@ def test_periodic_value_is_parameterized(value, is_parameterized, parameter_name
         cirq.PeriodicValue(sympy.Symbol('v'), 3),
     ],
 )
-def test_periodic_value_repr(val):
+def test_periodic_value_repr(val) -> None:
     cirq.testing.assert_equivalent_repr(val)

cirq/value/probability.py

@@ -14,6 +14,8 @@
 
 """Utilities for handling probabilities."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 import numpy as np
@@ -44,7 +46,7 @@ def validate_probability(p: float, p_str: str) -> float:
     return p
 
 
-def state_vector_to_probabilities(state_vector: 'cirq.STATE_VECTOR_LIKE') -> np.ndarray:
+def state_vector_to_probabilities(state_vector: cirq.STATE_VECTOR_LIKE) -> np.ndarray:
     """Function to transform a state vector like object into a numpy array of probabilities."""
     valid_state_vector = to_valid_state_vector(state_vector)
     return np.abs(valid_state_vector) ** 2

cirq/value/probability_test.py

@@ -12,17 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 
 
 @pytest.mark.parametrize('p', [0.0, 0.1, 0.6, 1.0])
-def test_validate_probability_valid(p):
+def test_validate_probability_valid(p) -> None:
     assert p == cirq.validate_probability(p, 'p')
 
 
 @pytest.mark.parametrize('p', [-0.1, 1.1])
-def test_validate_probability_invalid(p):
+def test_validate_probability_invalid(p) -> None:
     with pytest.raises(ValueError, match='p'):
         cirq.validate_probability(p, 'p')

cirq/value/product_state.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
 from dataclasses import dataclass
-from typing import Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Iterator, Sequence, TYPE_CHECKING
 
 import numpy as np
 
@@ -28,7 +30,7 @@ if TYPE_CHECKING:
 class _NamedOneQubitState(metaclass=abc.ABCMeta):
     """Abstract class representing a one-qubit state of note."""
 
-    def on(self, qubit: 'cirq.Qid') -> 'ProductState':
+    def on(self, qubit: cirq.Qid) -> ProductState:
         """Associates one qubit with this named state.
 
         The returned object is a ProductState of length 1.
@@ -57,7 +59,7 @@ class ProductState:
     with `cirq.KET_PLUS(q0)`.
     """
 
-    states: Dict['cirq.Qid', _NamedOneQubitState]
+    states: dict[cirq.Qid, _NamedOneQubitState]
 
     def __init__(self, states=None):
         if states is None:
@@ -66,10 +68,10 @@ class ProductState:
         object.__setattr__(self, 'states', states)
 
     @property
-    def qubits(self) -> Sequence['cirq.Qid']:
+    def qubits(self) -> Sequence[cirq.Qid]:
         return sorted(self.states.keys())
 
-    def __mul__(self, other: 'cirq.ProductState') -> 'cirq.ProductState':
+    def __mul__(self, other: cirq.ProductState) -> cirq.ProductState:
         if not isinstance(other, ProductState):
             raise ValueError("Multiplication is only supported with other TensorProductStates.")
 
@@ -93,11 +95,11 @@ class ProductState:
         )
         return f'cirq.ProductState({{{states_dict_repr}}})'
 
-    def __getitem__(self, qubit: 'cirq.Qid') -> _NamedOneQubitState:
+    def __getitem__(self, qubit: cirq.Qid) -> _NamedOneQubitState:
         """Return the _NamedOneQubitState at the given qubit."""
         return self.states[qubit]
 
-    def __iter__(self) -> Iterator[Tuple['cirq.Qid', _NamedOneQubitState]]:
+    def __iter__(self) -> Iterator[tuple[cirq.Qid, _NamedOneQubitState]]:
         yield from self.states.items()
 
     def __len__(self) -> int:
@@ -119,7 +121,7 @@ class ProductState:
     def _from_json_dict_(cls, states, **kwargs):
         return cls(states=dict(states))
 
-    def state_vector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray:
+    def state_vector(self, qubit_order: cirq.QubitOrder | None = None) -> np.ndarray:
         """The state-vector representation of this state."""
         from cirq import ops
 
@@ -136,7 +138,7 @@ class ProductState:
 
         return mat
 
-    def projector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray:
+    def projector(self, qubit_order: cirq.QubitOrder | None = None) -> np.ndarray:
         """The projector associated with this state expressed as a matrix.
 
         This is |s⟩⟨s| where |s⟩ is this state.
@@ -174,7 +176,7 @@ class _PauliEigenState(_NamedOneQubitState):
         return f'cirq.{self._symbol}.basis[{self.eigenvalue:+d}]'
 
     @abc.abstractmethod
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> tuple[int, cirq.Pauli]:
         pass
 
     def __eq__(self, other) -> bool:
@@ -201,7 +203,7 @@ class _XEigenState(_PauliEigenState):
             return np.array([1, -1]) / np.sqrt(2)
         raise ValueError(f"Bad eigenvalue: {self.eigenvalue}")  # pragma: no cover
 
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> tuple[int, cirq.Pauli]:
         # Prevent circular import from `value.value_equality`
         from cirq import ops
 
@@ -218,7 +220,7 @@ class _YEigenState(_PauliEigenState):
             return np.array([1, -1j]) / np.sqrt(2)
         raise ValueError(f"Bad eigenvalue: {self.eigenvalue}")  # pragma: no cover
 
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> tuple[int, cirq.Pauli]:
         from cirq import ops
 
         return self.eigenvalue, ops.Y
@@ -234,7 +236,7 @@ class _ZEigenState(_PauliEigenState):
             return np.array([0, 1])
         raise ValueError(f"Bad eigenvalue: {self.eigenvalue}")  # pragma: no cover
 
-    def stabilized_by(self) -> Tuple[int, 'cirq.Pauli']:
+    def stabilized_by(self) -> tuple[int, cirq.Pauli]:
         from cirq import ops
 
         return self.eigenvalue, ops.Z

cirq/value/product_state_test.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
@@ -85,7 +88,7 @@ def test_product_state():
     with pytest.raises(ValueError) as e:
         # Re-use q2
         ps *= cirq.KET_PLUS(q2)
-    assert e.match(r'.*both contain factors for these qubits: ' r'\[cirq.LineQubit\(2\)\]')
+    assert e.match(r'.*both contain factors for these qubits: \[cirq.LineQubit\(2\)\]')
 
     ps2 = eval(repr(ps))
     assert ps == ps2

cirq/value/random_state.py

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

cirq/value/random_state_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 
 import cirq
 
 
-def test_parse_random_state():
+def test_parse_random_state() -> None:
     global_state = np.random.get_state()
 
     def rand(prng):
@@ -34,11 +36,11 @@ def test_parse_random_state():
     eq.add_equality_group(*vals)
 
     seed = np.random.randint(2**31)
-    prngs = [
+    prngs1 = [
         np.random.RandomState(seed),
         cirq.value.parse_random_state(np.random.RandomState(seed)),
         cirq.value.parse_random_state(seed),
     ]
-    vals = [prng.rand() for prng in prngs]
+    vals = [prng.rand() for prng in prngs1]
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(*vals)