cirq-core 1.6.0.dev20250428201230__py3-none-any.whl → 1.6.0.dev20250429004516__py3-none-any.whl

cirq/sim/sparse_simulator.py

@@ -14,6 +14,8 @@
 
 """A simulator that uses numpy's einsum for sparse matrix operations."""
 
+from __future__ import annotations
+
 from typing import Any, Iterator, List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
 import numpy as np
@@ -126,8 +128,8 @@ class Simulator(
         self,
         *,
         dtype: Type[np.complexfloating] = np.complex64,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        noise: cirq.NOISE_MODEL_LIKE = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = True,
     ):
         """A sparse matrix simulator.
@@ -152,9 +154,9 @@ class Simulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union['cirq.STATE_VECTOR_LIKE', 'cirq.StateVectorSimulationState'],
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
+        initial_state: Union[cirq.STATE_VECTOR_LIKE, cirq.StateVectorSimulationState],
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
     ):
         """Creates the StateVectorSimulationState for a circuit.
 
@@ -183,16 +185,16 @@ class Simulator(
         )
 
     def _create_step_result(
-        self, sim_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]'
+        self, sim_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState]
     ):
         return SparseSimulatorStep(sim_state=sim_state, dtype=self._dtype)
 
     def simulate_expectation_values_sweep_iter(
         self,
-        program: 'cirq.AbstractCircuit',
-        observables: Union['cirq.PauliSumLike', List['cirq.PauliSumLike']],
-        params: 'cirq.Sweepable',
-        qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+        program: cirq.AbstractCircuit,
+        observables: Union[cirq.PauliSumLike, List[cirq.PauliSumLike]],
+        params: cirq.Sweepable,
+        qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
         initial_state: Any = None,
         permit_terminal_measurements: bool = False,
     ) -> Iterator[List[float]]:
@@ -222,7 +224,7 @@ class SparseSimulatorStep(
 
     def __init__(
         self,
-        sim_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]',
+        sim_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
         dtype: Type[np.complexfloating] = np.complex64,
     ):
         """Results of a step of the simulator.

cirq/sim/state_vector.py

@@ -11,8 +11,11 @@
 # 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.
+
 """Helpers for handling quantum state vectors."""
 
+from __future__ import annotations
+
 import abc
 from typing import List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING
 
@@ -31,7 +34,7 @@ if TYPE_CHECKING:
 class StateVectorMixin:
     """A mixin that provide methods for objects that have a state vector."""
 
-    def __init__(self, qubit_map: Optional[Mapping['cirq.Qid', int]] = None, *args, **kwargs):
+    def __init__(self, qubit_map: Optional[Mapping[cirq.Qid, int]] = None, *args, **kwargs):
         """Inits StateVectorMixin.
 
         Args:
@@ -47,7 +50,7 @@ class StateVectorMixin:
         self._qid_shape = None if qubit_map is None else qid_shape
 
     @property
-    def qubit_map(self) -> Mapping['cirq.Qid', int]:
+    def qubit_map(self) -> Mapping[cirq.Qid, int]:
         return self._qubit_map
 
     def _qid_shape_(self) -> Tuple[int, ...]:
@@ -102,7 +105,7 @@ class StateVectorMixin:
             and non-zero floats of the specified accuracy."""
         return qis.dirac_notation(self.state_vector(), decimals, qid_shape=self._qid_shape)
 
-    def density_matrix_of(self, qubits: Optional[List['cirq.Qid']] = None) -> np.ndarray:
+    def density_matrix_of(self, qubits: Optional[List[cirq.Qid]] = None) -> np.ndarray:
         r"""Returns the density matrix of the state.
 
         Calculate the density matrix for the system on the qubits provided.
@@ -141,7 +144,7 @@ class StateVectorMixin:
             qid_shape=self._qid_shape,
         )
 
-    def bloch_vector_of(self, qubit: 'cirq.Qid') -> np.ndarray:
+    def bloch_vector_of(self, qubit: cirq.Qid) -> np.ndarray:
         """Returns the bloch vector of a qubit in the state.
 
         Calculates the bloch vector of the given qubit
@@ -171,7 +174,7 @@ def sample_state_vector(
     *,  # Force keyword args
     qid_shape: Optional[Tuple[int, ...]] = None,
     repetitions: int = 1,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> np.ndarray:
     """Samples repeatedly from measurements in the computational basis.
 
@@ -236,7 +239,7 @@ def measure_state_vector(
     *,  # Force keyword args
     qid_shape: Optional[Tuple[int, ...]] = None,
     out: Optional[np.ndarray] = None,
-    seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> Tuple[List[int], np.ndarray]:
     """Performs a measurement of the state in the computational basis.
 

cirq/sim/state_vector_simulation_state.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Objects and methods for acting efficiently on a state vector."""
+
+from __future__ import annotations
+
 from typing import Any, Callable, List, Optional, Sequence, Tuple, Type, TYPE_CHECKING, Union
 
 import numpy as np
@@ -50,7 +53,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
     def create(
         cls,
         *,
-        initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'] = 0,
+        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE] = 0,
         qid_shape: Optional[Tuple[int, ...]] = None,
         dtype: Optional[Type[np.complexfloating]] = None,
         buffer: Optional[np.ndarray] = None,
@@ -85,7 +88,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         state_vector = state_vector.astype(dtype, copy=False)
         return cls(state_vector, buffer)
 
-    def copy(self, deep_copy_buffers: bool = True) -> '_BufferedStateVector':
+    def copy(self, deep_copy_buffers: bool = True) -> _BufferedStateVector:
         """Copies the object.
 
         Args:
@@ -98,7 +101,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
             buffer=self._buffer.copy() if deep_copy_buffers else self._buffer,
         )
 
-    def kron(self, other: '_BufferedStateVector') -> '_BufferedStateVector':
+    def kron(self, other: _BufferedStateVector) -> _BufferedStateVector:
         """Creates the Kronecker product with the other state vector.
 
         Args:
@@ -113,7 +116,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
 
     def factor(
         self, axes: Sequence[int], *, validate=True, atol=1e-07
-    ) -> Tuple['_BufferedStateVector', '_BufferedStateVector']:
+    ) -> Tuple[_BufferedStateVector, _BufferedStateVector]:
         """Factors a state vector into two independent state vectors.
 
         This function should only be called on state vectors that are known to be separable, such
@@ -143,7 +146,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         )
         return extracted, remainder
 
-    def reindex(self, axes: Sequence[int]) -> '_BufferedStateVector':
+    def reindex(self, axes: Sequence[int]) -> _BufferedStateVector:
         """Transposes the axes of a state vector to a specified order.
 
         Args:
@@ -253,7 +256,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         return index
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> List[int]:
         """Measures the state vector.
 
@@ -269,10 +272,7 @@ class _BufferedStateVector(qis.QuantumStateRepresentation):
         return bits
 
     def sample(
-        self,
-        axes: Sequence[int],
-        repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        self, axes: Sequence[int], repetitions: int = 1, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> np.ndarray:
         """Samples the state vector.
 
@@ -322,10 +322,10 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
         *,
         available_buffer: Optional[np.ndarray] = None,
         prng: Optional[np.random.RandomState] = None,
-        qubits: Optional[Sequence['cirq.Qid']] = None,
-        initial_state: Union[np.ndarray, 'cirq.STATE_VECTOR_LIKE'] = 0,
+        qubits: Optional[Sequence[cirq.Qid]] = None,
+        initial_state: Union[np.ndarray, cirq.STATE_VECTOR_LIKE] = 0,
         dtype: Type[np.complexfloating] = np.complex64,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Inits StateVectorSimulationState.
 
@@ -356,7 +356,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
         )
         super().__init__(state=state, prng=prng, qubits=qubits, classical_data=classical_data)
 
-    def add_qubits(self, qubits: Sequence['cirq.Qid']):
+    def add_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().add_qubits(qubits)
         return (
             self.kronecker_product(type(self)(qubits=qubits), inplace=True)
@@ -364,7 +364,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
             else ret
         )
 
-    def remove_qubits(self, qubits: Sequence['cirq.Qid']):
+    def remove_qubits(self, qubits: Sequence[cirq.Qid]):
         ret = super().remove_qubits(qubits)
         if ret is not NotImplemented:
             return ret
@@ -373,9 +373,9 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
         return remainder
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> bool:
-        strats: List[Callable[[Any, Any, Sequence['cirq.Qid']], bool]] = [
+        strats: List[Callable[[Any, Any, Sequence[cirq.Qid]], bool]] = [
             _strat_act_on_state_vector_from_apply_unitary,
             _strat_act_on_state_vector_from_mixture,
             _strat_act_on_state_vector_from_channel,
@@ -415,7 +415,7 @@ class StateVectorSimulationState(SimulationState[_BufferedStateVector]):
 
 
 def _strat_act_on_state_vector_from_apply_unitary(
-    action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.StateVectorSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     if not args._state.apply_unitary(action, args.get_axes(qubits)):
         return NotImplemented
@@ -423,7 +423,7 @@ def _strat_act_on_state_vector_from_apply_unitary(
 
 
 def _strat_act_on_state_vector_from_mixture(
-    action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.StateVectorSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     index = args._state.apply_mixture(action, args.get_axes(qubits), args.prng)
     if index is None:
@@ -435,7 +435,7 @@ def _strat_act_on_state_vector_from_mixture(
 
 
 def _strat_act_on_state_vector_from_channel(
-    action: Any, args: 'cirq.StateVectorSimulationState', qubits: Sequence['cirq.Qid']
+    action: Any, args: cirq.StateVectorSimulationState, qubits: Sequence[cirq.Qid]
 ) -> bool:
     index = args._state.apply_channel(action, args.get_axes(qubits), args.prng)
     if index is None:

cirq/sim/state_vector_simulator.py

@@ -11,8 +11,11 @@
 # 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.
+
 """Abstract classes for simulations which keep track of state vector."""
 
+from __future__ import annotations
+
 import abc
 import warnings
 from functools import cached_property
@@ -48,8 +51,8 @@ class SimulatesIntermediateStateVector(
         self,
         *,
         dtype: Type[np.complexfloating] = np.complex64,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        noise: cirq.NOISE_MODEL_LIKE = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         split_untangled_states: bool = False,
     ):
         super().__init__(
@@ -58,20 +61,20 @@ class SimulatesIntermediateStateVector(
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]',
-    ) -> 'cirq.StateVectorTrialResult':
+        final_simulator_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
+    ) -> cirq.StateVectorTrialResult:
         return StateVectorTrialResult(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
 
     def compute_amplitudes_sweep_iter(
         self,
-        program: 'cirq.AbstractCircuit',
+        program: cirq.AbstractCircuit,
         bitstrings: Sequence[int],
-        params: 'cirq.Sweepable',
-        qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT,
+        params: cirq.Sweepable,
+        qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT,
     ) -> Iterator[Sequence[complex]]:
         if isinstance(bitstrings, np.ndarray) and len(bitstrings.shape) > 1:
             raise ValueError(
@@ -112,9 +115,9 @@ class StateVectorTrialResult(
 
     def __init__(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[cirq.StateVectorSimulationState]',
+        final_simulator_state: cirq.SimulationStateBase[cirq.StateVectorSimulationState],
     ) -> None:
         super().__init__(
             params=params,

cirq/study/flatten_expressions.py

@@ -11,8 +11,11 @@
 # 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.
+
 """Resolves symbolic expressions to unique symbols."""
 
+from __future__ import annotations
+
 import numbers
 from typing import Any, Callable, List, Optional, Tuple, TYPE_CHECKING, Union
 
@@ -25,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.
@@ -250,8 +253,8 @@ class _ParamFlattener(resolver.ParamResolver):
         return symbol
 
     def value_of(
-        self, value: Union['cirq.TParamKey', 'cirq.TParamValComplex'], recursive: bool = False
-    ) -> 'cirq.TParamValComplex':
+        self, value: Union[cirq.TParamKey, cirq.TParamValComplex], recursive: bool = False
+    ) -> cirq.TParamValComplex:
         """Resolves a symbol or expression to a new symbol unique to that value.
 
         - If value is a float, returns it.
@@ -380,8 +383,8 @@ class ExpressionMap(dict):
 
 
 def _ensure_not_str(
-    param: Union[sympy.Expr, 'cirq.TParamValComplex', str],
-) -> Union[sympy.Expr, 'cirq.TParamValComplex']:
+    param: Union[sympy.Expr, cirq.TParamValComplex, str],
+) -> Union[sympy.Expr, cirq.TParamValComplex]:
     if isinstance(param, str):
         return sympy.Symbol(param)
     return param

cirq/study/resolver.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Resolves ParameterValues to assigned values."""
+
+from __future__ import annotations
+
 import numbers
 from typing import Any, cast, Dict, Iterator, Mapping, Optional, TYPE_CHECKING, Union
 
@@ -61,12 +64,12 @@ class ParamResolver:
         TypeError if formulas are passed as keys.
     """
 
-    def __new__(cls, param_dict: 'cirq.ParamResolverOrSimilarType' = None):
+    def __new__(cls, param_dict: cirq.ParamResolverOrSimilarType = None):
         if isinstance(param_dict, ParamResolver):
             return param_dict
         return super().__new__(cls)
 
-    def __init__(self, param_dict: 'cirq.ParamResolverOrSimilarType' = None) -> None:
+    def __init__(self, param_dict: cirq.ParamResolverOrSimilarType = None) -> None:
         if hasattr(self, 'param_dict'):
             return  # Already initialized. Got wrapped as part of the __new__.
 
@@ -82,8 +85,8 @@ class ParamResolver:
         return self._param_dict
 
     def value_of(
-        self, value: Union['cirq.TParamKey', 'cirq.TParamValComplex'], recursive: bool = True
-    ) -> 'cirq.TParamValComplex':
+        self, value: Union[cirq.TParamKey, cirq.TParamValComplex], recursive: bool = True
+    ) -> cirq.TParamValComplex:
         """Attempt to resolve a parameter to its assigned value.
 
         Scalars are returned without modification.  Strings are resolved via
@@ -193,7 +196,7 @@ class ParamResolver:
 
         return self._value_of_recursive(value)
 
-    def _value_of_recursive(self, value: 'cirq.TParamKey') -> 'cirq.TParamValComplex':
+    def _value_of_recursive(self, value: cirq.TParamKey) -> cirq.TParamValComplex:
         # Recursive parameter resolution. We can safely assume that value is a
         # single symbol, since combinations are handled earlier in the method.
         if value in self._deep_eval_map:
@@ -213,8 +216,8 @@ class ParamResolver:
             self._deep_eval_map[value] = self.value_of(v, recursive=True)
         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]] = {
+    def _resolve_parameters_(self, resolver: ParamResolver, recursive: bool) -> ParamResolver:
+        new_dict: Dict[cirq.TParamKey, Union[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})
@@ -232,8 +235,8 @@ class ParamResolver:
         return bool(self._param_dict)
 
     def __getitem__(
-        self, key: Union['cirq.TParamKey', 'cirq.TParamValComplex']
-    ) -> 'cirq.TParamValComplex':
+        self, key: Union[cirq.TParamKey, cirq.TParamValComplex]
+    ) -> cirq.TParamValComplex:
         return self.value_of(key)
 
     def __hash__(self) -> int:

cirq/study/result.py

@@ -11,8 +11,11 @@
 # 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.
+
 """Defines trial results."""
 
+from __future__ import annotations
+
 import abc
 import collections
 import io
@@ -99,7 +102,7 @@ class Result(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def params(self) -> 'cirq.ParamResolver':
+    def params(self) -> cirq.ParamResolver:
         """A ParamResolver of settings used for this result."""
 
     @property
@@ -275,7 +278,7 @@ class Result(abc.ABC):
             and self.params == other.params
         )
 
-    def __add__(self, other: 'cirq.Result') -> 'cirq.Result':
+    def __add__(self, other: cirq.Result) -> cirq.Result:
         if not isinstance(other, Result):
             return NotImplemented
         if self.params != other.params:
@@ -341,7 +344,7 @@ class ResultDict(Result):
         self._data: Optional[pd.DataFrame] = None
 
     @property
-    def params(self) -> 'cirq.ParamResolver':
+    def params(self) -> cirq.ParamResolver:
         return self._params
 
     @property

cirq/study/sweeps.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 abc
 import collections
 import itertools
@@ -71,7 +74,7 @@ class Sweep(metaclass=abc.ABCMeta):
     see the Product and Zip documentation.
     """
 
-    def __mul__(self, other: 'Sweep') -> 'Sweep':
+    def __mul__(self, other: Sweep) -> Sweep:
         factors: List[Sweep] = []
         if isinstance(self, Product):
             factors.extend(self.factors)
@@ -85,7 +88,7 @@ class Sweep(metaclass=abc.ABCMeta):
             raise TypeError(f'cannot multiply sweep and {type(other)}')
         return Product(*factors)
 
-    def __add__(self, other: 'Sweep') -> 'Sweep':
+    def __add__(self, other: Sweep) -> Sweep:
         sweeps: List[Sweep] = []
         if isinstance(self, Zip):
             sweeps.extend(self.sweeps)
@@ -108,7 +111,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
@@ -125,10 +128,10 @@ class Sweep(metaclass=abc.ABCMeta):
         pass
 
     @overload
-    def __getitem__(self, val: slice) -> 'Sweep':
+    def __getitem__(self, val: slice) -> Sweep:
         pass
 
-    def __getitem__(self, val: Union[int, slice]) -> Union[resolver.ParamResolver, 'Sweep']:
+    def __getitem__(self, val: Union[int, slice]) -> Union[resolver.ParamResolver, Sweep]:
         n = len(self)
         if isinstance(val, int):
             if val < -n or val >= n:
@@ -186,7 +189,7 @@ class _Unit(Sweep):
         return True
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> List[cirq.TParamKey]:
         return []
 
     def __len__(self) -> int:
@@ -233,7 +236,7 @@ class Product(Sweep):
         return hash(tuple(self.factors))
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> List[cirq.TParamKey]:
         return sum((factor.keys for factor in self.factors), [])
 
     def __len__(self) -> int:
@@ -308,7 +311,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:
@@ -361,7 +364,7 @@ class Zip(Sweep):
         return hash(tuple(self.sweeps))
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> List[cirq.TParamKey]:
         return sum((sweep.keys for sweep in self.sweeps), [])
 
     def __len__(self) -> int:
@@ -449,7 +452,7 @@ class ZipLongest(Zip):
 class SingleSweep(Sweep):
     """A simple sweep over one parameter with values from an iterator."""
 
-    def __init__(self, key: 'cirq.TParamKey') -> None:
+    def __init__(self, key: cirq.TParamKey) -> None:
         if isinstance(key, sympy.Symbol):
             key = str(key)
         self.key = key
@@ -467,7 +470,7 @@ class SingleSweep(Sweep):
         pass
 
     @property
-    def keys(self) -> List['cirq.TParamKey']:
+    def keys(self) -> List[cirq.TParamKey]:
         return [self.key]
 
     def param_tuples(self) -> Iterator[Params]:
@@ -483,7 +486,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: Optional[Any] = None
     ) -> None:
         """Creates a sweep on a variable with supplied values.
 
@@ -524,7 +527,7 @@ class Linspace(SingleSweep):
 
     def __init__(
         self,
-        key: 'cirq.TParamKey',
+        key: cirq.TParamKey,
         start: float,
         stop: float,
         length: int,
@@ -607,7 +610,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))

cirq/testing/consistent_act_on_test.py

@@ -24,7 +24,7 @@ class GoodGate(cirq.testing.SingleQubitGate):
     def _unitary_(self):
         return np.array([[0, 1], [1, 0]])
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]):
         if isinstance(sim_state, cirq.CliffordTableauSimulationState):
             tableau = sim_state.tableau
             q = sim_state.qubit_map[qubits[0]]
@@ -37,7 +37,7 @@ class BadGate(cirq.testing.SingleQubitGate):
     def _unitary_(self):
         return np.array([[0, 1j], [1, 0]])
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase', qubits: Sequence['cirq.Qid']):
+    def _act_on_(self, sim_state: cirq.SimulationStateBase, qubits: Sequence[cirq.Qid]):
         if isinstance(sim_state, cirq.CliffordTableauSimulationState):
             tableau = sim_state.tableau
             q = sim_state.qubit_map[qubits[0]]

cirq/testing/consistent_controlled_gate_op_test.py

@@ -12,13 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Collection, List, Optional, Sequence, Tuple, Union
+from __future__ import annotations
+
+from typing import Collection, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 import pytest
 
 import cirq
-from cirq.ops import control_values as cv
+
+if TYPE_CHECKING:
+    from cirq.ops import control_values as cv
 
 
 class GoodGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
@@ -29,11 +33,11 @@ class GoodGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
 class BadGateOperation(cirq.GateOperation):
     def controlled_by(
         self,
-        *control_qubits: 'cirq.Qid',
+        *control_qubits: cirq.Qid,
         control_values: Optional[
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
-    ) -> 'cirq.Operation':
+    ) -> cirq.Operation:
         return cirq.ControlledOperation(control_qubits, self, control_values)
 
 
@@ -41,7 +45,7 @@ class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
     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':
+    def on(self, *qubits: cirq.Qid) -> cirq.Operation:
         return BadGateOperation(self, list(qubits))
 
     def controlled(
@@ -51,7 +55,7 @@ class BadGate(cirq.EigenGate, cirq.testing.SingleQubitGate):
             Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]]
         ] = None,
         control_qid_shape: Optional[Tuple[int, ...]] = None,
-    ) -> 'cirq.Gate':
+    ) -> cirq.Gate:
         ret = super().controlled(num_controls, control_values, control_qid_shape)
         if num_controls == 1 and control_values is None:
             return cirq.CZPowGate(exponent=self._exponent, global_shift=self._global_shift)