cirq-core 1.6.0.dev20250416035400__py3-none-any.whl → 1.6.0.dev20250417204649__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.6.0.dev20250416035400"
+__version__ = "1.6.0.dev20250417204649"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.6.0.dev20250416035400"
+    assert cirq.__version__ == "1.6.0.dev20250417204649"

cirq/devices/noise_model_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 typing import Sequence
 
 import numpy as np
@@ -77,7 +79,7 @@ def test_infers_other_methods():
     )
 
     class NoiseModelWithNoisyOperationMethod(cirq.NoiseModel):
-        def noisy_operation(self, operation: 'cirq.Operation'):
+        def noisy_operation(self, operation: cirq.Operation):
             return cirq.Z(operation.qubits[0]).with_tags(ops.VirtualTag())
 
     c = NoiseModelWithNoisyOperationMethod()

cirq/devices/noise_properties.py

@@ -19,6 +19,8 @@ be translated into noise models. NoiseModelFromNoiseProperties consumes those
 noise models to produce a single noise model which replicates device noise.
 """
 
+from __future__ import annotations
+
 import abc
 from typing import Iterable, List, Sequence, TYPE_CHECKING
 
@@ -35,7 +37,7 @@ class NoiseProperties(abc.ABC):
     """Noise-defining properties for a quantum device."""
 
     @abc.abstractmethod
-    def build_noise_models(self) -> List['cirq.NoiseModel']:
+    def build_noise_models(self) -> List[cirq.NoiseModel]:
         """Construct all NoiseModels associated with this NoiseProperties."""
 
 
@@ -52,7 +54,7 @@ class NoiseModelFromNoiseProperties(devices.NoiseModel):
         self._noise_properties = noise_properties
         self.noise_models = self._noise_properties.build_noise_models()
 
-    def is_virtual(self, op: 'cirq.Operation') -> bool:
+    def is_virtual(self, op: cirq.Operation) -> bool:
         """Returns True if an operation is virtual.
 
         Device-specific subclasses should implement this method to mark any
@@ -67,8 +69,8 @@ class NoiseModelFromNoiseProperties(devices.NoiseModel):
         return False
 
     def noisy_moments(
-        self, moments: Iterable['cirq.Moment'], system_qubits: Sequence['cirq.Qid']
-    ) -> Sequence['cirq.OP_TREE']:
+        self, moments: Iterable[cirq.Moment], system_qubits: Sequence[cirq.Qid]
+    ) -> Sequence[cirq.OP_TREE]:
         # Split multi-qubit measurements into single-qubit measurements.
         # These will be recombined after noise is applied.
         split_measure_moments = []

cirq/devices/noise_utils.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, Dict, Tuple, Type, TYPE_CHECKING, Union
 
 from cirq import ops, protocols, qis, value
@@ -29,24 +31,24 @@ PHYSICAL_GATE_TAG = 'physical_gate'
 class OpIdentifier:
     """Identifies an operation by gate and (optionally) target qubits."""
 
-    def __init__(self, gate_type: Type['cirq.Gate'], *qubits: 'cirq.Qid'):
+    def __init__(self, gate_type: Type[cirq.Gate], *qubits: cirq.Qid):
         self._gate_type = gate_type
         self._gate_family = ops.GateFamily(gate_type)
-        self._qubits: Tuple['cirq.Qid', ...] = tuple(qubits)
+        self._qubits: Tuple[cirq.Qid, ...] = tuple(qubits)
 
     @property
-    def gate_type(self) -> Type['cirq.Gate']:
+    def gate_type(self) -> Type[cirq.Gate]:
         # set to a type during initialization, never modified
         return self._gate_type
 
     @property
-    def qubits(self) -> Tuple['cirq.Qid', ...]:
+    def qubits(self) -> Tuple[cirq.Qid, ...]:
         return self._qubits
 
     def _predicate(self, *args, **kwargs):
         return self._gate_family._predicate(*args, **kwargs)
 
-    def is_proper_subtype_of(self, op_id: 'OpIdentifier'):
+    def is_proper_subtype_of(self, op_id: OpIdentifier):
         """Returns true if this is contained within op_id, but not equal to it.
 
         If this returns true, (x in self) implies (x in op_id), but the reverse
@@ -90,7 +92,7 @@ class OpIdentifier:
         return {'gate_type': self._gate_type, 'qubits': self._qubits}
 
     @classmethod
-    def _from_json_dict_(cls, gate_type, qubits, **kwargs) -> 'OpIdentifier':
+    def _from_json_dict_(cls, gate_type, qubits, **kwargs) -> OpIdentifier:
         if isinstance(gate_type, str):
             gate_type = protocols.cirq_type_from_json(gate_type)
         return cls(gate_type, *qubits)

cirq/devices/superconducting_qubits_noise_properties.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 """Class for representing noise on a superconducting qubit device."""
 
+from __future__ import annotations
+
 import abc
 from dataclasses import dataclass, field
 from functools import cached_property
@@ -49,13 +50,13 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
     """
 
     gate_times_ns: Dict[type, float]
-    t1_ns: Dict['cirq.Qid', float]
-    tphi_ns: Dict['cirq.Qid', float]
-    readout_errors: Dict['cirq.Qid', List[float]]
+    t1_ns: Dict[cirq.Qid, float]
+    tphi_ns: Dict[cirq.Qid, float]
+    readout_errors: Dict[cirq.Qid, List[float]]
     gate_pauli_errors: Dict[noise_utils.OpIdentifier, float]
 
     validate: bool = True
-    _qubits: List['cirq.Qid'] = field(init=False, default_factory=list)
+    _qubits: List[cirq.Qid] = field(init=False, default_factory=list)
 
     def __post_init__(self):
         if not self.validate:
@@ -95,7 +96,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
                 )
 
     @property
-    def qubits(self) -> List['cirq.Qid']:
+    def qubits(self) -> List[cirq.Qid]:
         """Qubits for which we have data"""
         if not self._qubits:
             self._qubits = sorted(self.t1_ns)
@@ -150,8 +151,8 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
             depol_errors[op_id] = self._get_pauli_error(p_error, op_id)
         return depol_errors
 
-    def build_noise_models(self) -> List['cirq.NoiseModel']:
-        noise_models: List['cirq.NoiseModel'] = []
+    def build_noise_models(self) -> List[cirq.NoiseModel]:
+        noise_models: List[cirq.NoiseModel] = []
 
         if self.t1_ns:
             noise_models.append(
@@ -175,7 +176,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
 
         # This adds per-qubit measurement error BEFORE measurement on those qubits.
         if self.readout_errors:
-            added_measure_errors: Dict[noise_utils.OpIdentifier, 'cirq.Operation'] = {}
+            added_measure_errors: Dict[noise_utils.OpIdentifier, cirq.Operation] = {}
             for qubit in self.readout_errors:
                 p_00, p_11 = self.readout_errors[qubit]
                 p = p_11 / (p_00 + p_11)

cirq/devices/thermal_noise_model.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import dataclasses
 import functools
 from typing import Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
@@ -129,8 +131,8 @@ def _decoherence_matrix(
 
 
 def _as_rate_dict(
-    rate_or_dict: Optional[Union[float, Dict['cirq.Qid', float]]], qubits: Set['cirq.Qid']
-) -> Dict['cirq.Qid', float]:
+    rate_or_dict: Optional[Union[float, Dict[cirq.Qid, float]]], qubits: Set[cirq.Qid]
+) -> Dict[cirq.Qid, float]:
     """Convert float or None input into dictionary form.
 
     This method also ensures that no qubits are missing from dictionary keys.
@@ -143,7 +145,7 @@ def _as_rate_dict(
         return {q: rate_or_dict for q in qubits}
 
 
-def _validate_rates(qubits: Set['cirq.Qid'], rates: Dict['cirq.Qid', np.ndarray]) -> None:
+def _validate_rates(qubits: Set[cirq.Qid], rates: Dict[cirq.Qid, np.ndarray]) -> None:
     """Check all rate matrices are square and of appropriate dimension.
 
     We check rates are positive in the class validator.
@@ -169,11 +171,11 @@ class ThermalNoiseModel(devices.NoiseModel):
 
     def __init__(
         self,
-        qubits: Set['cirq.Qid'],
+        qubits: Set[cirq.Qid],
         gate_durations_ns: Dict[type, float],
-        heat_rate_GHz: Union[float, Dict['cirq.Qid', float], None] = None,
-        cool_rate_GHz: Union[float, Dict['cirq.Qid', float], None] = None,
-        dephase_rate_GHz: Union[float, Dict['cirq.Qid', float], None] = None,
+        heat_rate_GHz: Union[float, Dict[cirq.Qid, float], None] = None,
+        cool_rate_GHz: Union[float, Dict[cirq.Qid, float], None] = None,
+        dephase_rate_GHz: Union[float, Dict[cirq.Qid, float], None] = None,
         require_physical_tag: bool = True,
         skip_measurements: bool = True,
         prepend: bool = False,
@@ -225,14 +227,12 @@ class ThermalNoiseModel(devices.NoiseModel):
 
         _validate_rates(qubits, rate_dict)
         self.gate_durations_ns: Dict[type, float] = gate_durations_ns
-        self.rate_matrix_GHz: Dict['cirq.Qid', np.ndarray] = rate_dict
+        self.rate_matrix_GHz: Dict[cirq.Qid, np.ndarray] = rate_dict
         self.require_physical_tag: bool = require_physical_tag
         self.skip_measurements: bool = skip_measurements
         self._prepend = prepend
 
-    def noisy_moment(
-        self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid']
-    ) -> 'cirq.OP_TREE':
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if not moment.operations:
             return [moment]
         if self.require_physical_tag:
@@ -247,7 +247,7 @@ class ThermalNoiseModel(devices.NoiseModel):
                 # Only moments with physical operations should have noise.
                 return [moment]
 
-        noise_ops: List['cirq.Operation'] = []
+        noise_ops: List[cirq.Operation] = []
         # Some devices (including Google hardware) require that all gates have
         # the same duration, but this does not. Instead, each moment is assumed
         # to be as long as the longest gate it contains.

cirq/devices/unconstrained_device.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, Dict, TYPE_CHECKING
 
 from cirq import protocols, value
@@ -26,7 +28,7 @@ if TYPE_CHECKING:
 class _UnconstrainedDevice(device.Device):
     """A device that allows everything, infinitely fast."""
 
-    def duration_of(self, operation: 'cirq.Operation') -> 'cirq.Duration':
+    def duration_of(self, operation: cirq.Operation) -> cirq.Duration:
         return value.Duration(picos=0)
 
     def validate_moment(self, moment) -> None:

cirq/experiments/n_qubit_tomography.py

@@ -17,6 +17,9 @@ different pre-measurement rotations.
 The code is designed to be modular with regards to data collection
 so that occurs outside of the StateTomographyExperiment class.
 """
+
+from __future__ import annotations
+
 from typing import List, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -49,7 +52,7 @@ class StateTomographyExperiment:
 
     def __init__(
         self,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         prerotations: Optional[Sequence[Tuple[float, float]]] = None,
     ):
         """Initializes the rotation protocol and matrix for system.
@@ -69,8 +72,8 @@ class StateTomographyExperiment:
 
         phase_exp_vals, exp_vals = zip(*prerotations)
 
-        operations: List['cirq.Operation'] = []
-        sweeps: List['cirq.Sweep'] = []
+        operations: List[cirq.Operation] = []
+        sweeps: List[cirq.Sweep] = []
         for i, qubit in enumerate(qubits):
             phase_exp = sympy.Symbol(f'phase_exp_{i}')
             exp = sympy.Symbol(f'exp_{i}')
@@ -82,7 +85,7 @@ class StateTomographyExperiment:
         self.rot_sweep = study.Product(*sweeps)
         self.mat = self._make_state_tomography_matrix(qubits)
 
-    def _make_state_tomography_matrix(self, qubits: Sequence['cirq.Qid']) -> np.ndarray:
+    def _make_state_tomography_matrix(self, qubits: Sequence[cirq.Qid]) -> np.ndarray:
         """Gets the matrix used for solving the linear system of the tomography.
 
         Args:
@@ -130,9 +133,9 @@ class StateTomographyExperiment:
 
 
 def state_tomography(
-    sampler: 'cirq.Sampler',
-    qubits: Sequence['cirq.Qid'],
-    circuit: 'cirq.Circuit',
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.Qid],
+    circuit: cirq.Circuit,
     repetitions: int = 1000,
     prerotations: Optional[Sequence[Tuple[float, float]]] = None,
 ) -> TomographyResult:
@@ -166,11 +169,11 @@ def state_tomography(
 
 
 def get_state_tomography_data(
-    sampler: 'cirq.Sampler',
-    qubits: Sequence['cirq.Qid'],
-    circuit: 'cirq.Circuit',
-    rot_circuit: 'cirq.Circuit',
-    rot_sweep: 'cirq.Sweep',
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.Qid],
+    circuit: cirq.Circuit,
+    rot_circuit: cirq.Circuit,
+    rot_sweep: cirq.Sweep,
     repetitions: int = 1000,
 ) -> np.ndarray:
     """Gets the data for each rotation string added to the circuit.

cirq/experiments/qubit_characterizations.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import dataclasses
 import functools
 import itertools
@@ -150,10 +152,10 @@ class RandomizedBenchMarkResult:
 class ParallelRandomizedBenchmarkingResult:
     """Results from a parallel randomized benchmarking experiment."""
 
-    results_dictionary: Mapping['cirq.Qid', 'RandomizedBenchMarkResult']
+    results_dictionary: Mapping[cirq.Qid, RandomizedBenchMarkResult]
 
     def plot_single_qubit(
-        self, qubit: 'cirq.Qid', ax: Optional[plt.Axes] = None, **plot_kwargs: Any
+        self, qubit: cirq.Qid, ax: Optional[plt.Axes] = None, **plot_kwargs: Any
     ) -> plt.Axes:
         """Plot the raw data for the specified qubit.
 
@@ -168,7 +170,7 @@ class ParallelRandomizedBenchmarkingResult:
 
         return self.results_dictionary[qubit].plot(ax, **plot_kwargs)
 
-    def pauli_error(self) -> Mapping['cirq.Qid', float]:
+    def pauli_error(self) -> Mapping[cirq.Qid, float]:
         """Return a dictionary of Pauli errors.
         Returns:
             A dictionary containing the Pauli errors for all qubits.
@@ -342,8 +344,8 @@ class TomographyResult:
 
 
 def single_qubit_randomized_benchmarking(
-    sampler: 'cirq.Sampler',
-    qubit: 'cirq.Qid',
+    sampler: cirq.Sampler,
+    qubit: cirq.Qid,
     use_xy_basis: bool = True,
     *,
     num_clifford_range: Sequence[int] = tuple(np.logspace(np.log10(5), 3, 5, dtype=int)),
@@ -396,8 +398,8 @@ def single_qubit_randomized_benchmarking(
 
 
 def parallel_single_qubit_randomized_benchmarking(
-    sampler: 'cirq.Sampler',
-    qubits: Sequence['cirq.Qid'],
+    sampler: cirq.Sampler,
+    qubits: Sequence[cirq.Qid],
     use_xy_basis: bool = True,
     *,
     num_clifford_range: Sequence[int] = tuple(
@@ -405,7 +407,7 @@ def parallel_single_qubit_randomized_benchmarking(
     ),
     num_circuits: int = 10,
     repetitions: int = 1000,
-) -> 'ParallelRandomizedBenchmarkingResult':
+) -> ParallelRandomizedBenchmarkingResult:
     """Clifford-based randomized benchmarking (RB) single qubits in parallel.
 
     This is the same as `single_qubit_randomized_benchmarking` except on all
@@ -430,7 +432,7 @@ def parallel_single_qubit_randomized_benchmarking(
     c1 = clifford_group.c1_in_xy if use_xy_basis else clifford_group.c1_in_xz
 
     # create circuits
-    circuits_all: List['cirq.AbstractCircuit'] = []
+    circuits_all: List[cirq.AbstractCircuit] = []
     for num_cliffords in num_clifford_range:
         for _ in range(num_circuits):
             circuits_all.append(_create_parallel_rb_circuit(qubits, num_cliffords, c1))
@@ -440,7 +442,7 @@ def parallel_single_qubit_randomized_benchmarking(
     gnd_probs: dict = {q: [] for q in qubits}
     idx = 0
     for num_cliffords in num_clifford_range:
-        excited_probs: Dict['cirq.Qid', List[float]] = {q: [] for q in qubits}
+        excited_probs: Dict[cirq.Qid, List[float]] = {q: [] for q in qubits}
         for _ in range(num_circuits):
             result = results[idx][0]
             for qubit in qubits:
@@ -454,9 +456,9 @@ def parallel_single_qubit_randomized_benchmarking(
 
 
 def two_qubit_randomized_benchmarking(
-    sampler: 'cirq.Sampler',
-    first_qubit: 'cirq.Qid',
-    second_qubit: 'cirq.Qid',
+    sampler: cirq.Sampler,
+    first_qubit: cirq.Qid,
+    second_qubit: cirq.Qid,
     *,
     num_clifford_range: Sequence[int] = range(5, 50, 5),
     num_circuits: int = 20,
@@ -514,10 +516,7 @@ def two_qubit_randomized_benchmarking(
 
 
 def single_qubit_state_tomography(
-    sampler: 'cirq.Sampler',
-    qubit: 'cirq.Qid',
-    circuit: 'cirq.AbstractCircuit',
-    repetitions: int = 1000,
+    sampler: cirq.Sampler, qubit: cirq.Qid, circuit: cirq.AbstractCircuit, repetitions: int = 1000
 ) -> TomographyResult:
     """Single-qubit state tomography.
 
@@ -560,10 +559,10 @@ def single_qubit_state_tomography(
 
 
 def two_qubit_state_tomography(
-    sampler: 'cirq.Sampler',
-    first_qubit: 'cirq.Qid',
-    second_qubit: 'cirq.Qid',
-    circuit: 'cirq.AbstractCircuit',
+    sampler: cirq.Sampler,
+    first_qubit: cirq.Qid,
+    second_qubit: cirq.Qid,
+    circuit: cirq.AbstractCircuit,
     repetitions: int = 1000,
 ) -> TomographyResult:
     r"""Two-qubit state tomography.
@@ -688,8 +687,8 @@ def two_qubit_state_tomography(
 
 
 def _create_parallel_rb_circuit(
-    qubits: Sequence['cirq.Qid'], num_cliffords: int, c1: list
-) -> 'cirq.Circuit':
+    qubits: Sequence[cirq.Qid], num_cliffords: int, c1: list
+) -> cirq.Circuit:
     sequences_to_zip = [_random_single_q_clifford(qubit, num_cliffords, c1) for qubit in qubits]
     # Ensure each sequence has the same number of moments.
     num_moments = max(len(sequence) for sequence in sequences_to_zip)
@@ -711,9 +710,7 @@ def _indices_after_basis_rot(i: int, j: int) -> Tuple[int, Sequence[int], Sequen
     return mat_idx, indices, signs
 
 
-def _two_qubit_clifford_matrices(
-    q_0: 'cirq.Qid', q_1: 'cirq.Qid', cliffords: Cliffords
-) -> np.ndarray:
+def _two_qubit_clifford_matrices(q_0: cirq.Qid, q_1: cirq.Qid, cliffords: Cliffords) -> np.ndarray:
     mats = []
 
     # Total number of different gates in the two-qubit Clifford group.
@@ -743,8 +740,8 @@ def _two_qubit_clifford_matrices(
 
 
 def _random_single_q_clifford(
-    qubit: 'cirq.Qid', num_cfds: int, cfds: Sequence[Sequence['cirq.ops.SingleQubitCliffordGate']]
-) -> List['cirq.Operation']:
+    qubit: cirq.Qid, num_cfds: int, cfds: Sequence[Sequence[cirq.ops.SingleQubitCliffordGate]]
+) -> List[cirq.Operation]:
     clifford_group_size = 24
     operations = [[gate.to_phased_xz_gate()(qubit) for gate in gates] for gates in cfds]
     gate_ids = list(np.random.choice(clifford_group_size, num_cfds))
@@ -755,8 +752,8 @@ def _random_single_q_clifford(
 
 
 def _random_two_q_clifford(
-    q_0: 'cirq.Qid', q_1: 'cirq.Qid', num_cfds: int, cfd_matrices: np.ndarray, cliffords: Cliffords
-) -> 'cirq.Circuit':
+    q_0: cirq.Qid, q_1: cirq.Qid, num_cfds: int, cfd_matrices: np.ndarray, cliffords: Cliffords
+) -> cirq.Circuit:
     clifford_group_size = 11520
     idx_list = list(np.random.choice(clifford_group_size, num_cfds))
     circuit = circuits.Circuit()
@@ -819,8 +816,8 @@ def _reduce_gate_seq(
 
 
 def _two_qubit_clifford(
-    q_0: 'cirq.Qid', q_1: 'cirq.Qid', idx: int, cliffords: Cliffords
-) -> Iterator['cirq.OP_TREE']:
+    q_0: cirq.Qid, q_1: cirq.Qid, idx: int, cliffords: Cliffords
+) -> Iterator[cirq.OP_TREE]:
     """Generates a two-qubit Clifford gate.
 
     An integer (idx) from 0 to 11519 is used to generate a two-qubit Clifford
@@ -875,8 +872,8 @@ def _split_two_q_clifford_idx(idx: int):
 
 
 def _two_qubit_clifford_starters(
-    q_0: 'cirq.Qid', q_1: 'cirq.Qid', idx_0: int, idx_1: int, cliffords: Cliffords
-) -> Iterator['cirq.OP_TREE']:
+    q_0: cirq.Qid, q_1: cirq.Qid, idx_0: int, idx_1: int, cliffords: Cliffords
+) -> Iterator[cirq.OP_TREE]:
     """Fulfills part (a) for two-qubit Cliffords."""
     c1 = cliffords.c1_in_xy
     yield _single_qubit_gates(c1[idx_0], q_0)
@@ -884,8 +881,8 @@ def _two_qubit_clifford_starters(
 
 
 def _two_qubit_clifford_mixers(
-    q_0: 'cirq.Qid', q_1: 'cirq.Qid', idx_2: int, cliffords: Cliffords
-) -> Iterator['cirq.OP_TREE']:
+    q_0: cirq.Qid, q_1: cirq.Qid, idx_2: int, cliffords: Cliffords
+) -> Iterator[cirq.OP_TREE]:
     """Fulfills parts (b-d) for two-qubit Cliffords."""
     s1 = cliffords.s1
     s1_x = cliffords.s1_x
@@ -916,9 +913,7 @@ def _two_qubit_clifford_mixers(
         yield _single_qubit_gates(s1_x[idx_4], q_1)
 
 
-def _single_qubit_gates(
-    gate_seq: Sequence['cirq.Gate'], qubit: 'cirq.Qid'
-) -> Iterator['cirq.OP_TREE']:
+def _single_qubit_gates(gate_seq: Sequence[cirq.Gate], qubit: cirq.Qid) -> Iterator[cirq.OP_TREE]:
     for gate in gate_seq:
         yield gate(qubit)