cirq-core 1.6.0.dev20250501173104__py3-none-any.whl → 1.6.0.dev20250501231232__py3-none-any.whl

cirq/transformers/routing/mapping_manager.py

@@ -14,6 +14,8 @@
 
 """Manages the mapping from logical to physical qubits during a routing procedure."""
 
+from __future__ import annotations
+
 from typing import Dict, List, Sequence, TYPE_CHECKING
 
 import networkx as nx
@@ -35,9 +37,7 @@ class MappingManager:
     logical qubits are mapped to, via `self.logical_qid_to_int` map).
     """
 
-    def __init__(
-        self, device_graph: nx.Graph, initial_mapping: Dict['cirq.Qid', 'cirq.Qid']
-    ) -> None:
+    def __init__(self, device_graph: nx.Graph, initial_mapping: Dict[cirq.Qid, cirq.Qid]) -> None:
         """Initializes MappingManager.
 
         Args:
@@ -84,12 +84,12 @@ class MappingManager:
         )
 
     @property
-    def physical_qid_to_int(self) -> Dict['cirq.Qid', int]:
+    def physical_qid_to_int(self) -> Dict[cirq.Qid, int]:
         """Mapping of physical qubits, that were part of the initial mapping, to unique integers."""
         return self._physical_qid_to_int
 
     @property
-    def int_to_physical_qid(self) -> List['cirq.Qid']:
+    def int_to_physical_qid(self) -> List[cirq.Qid]:
         """Inverse mapping of unique integers to corresponding physical qubits.
 
         `self.physical_qid_to_int[self.int_to_physical_qid[i]] == i` for each i.
@@ -97,12 +97,12 @@ class MappingManager:
         return self._int_to_physical_qid
 
     @property
-    def logical_qid_to_int(self) -> Dict['cirq.Qid', int]:
+    def logical_qid_to_int(self) -> Dict[cirq.Qid, int]:
         """Mapping of logical qubits, that were part of the initial mapping, to unique integers."""
         return self._logical_qid_to_int
 
     @property
-    def int_to_logical_qid(self) -> List['cirq.Qid']:
+    def int_to_logical_qid(self) -> List[cirq.Qid]:
         """Inverse mapping of unique integers to corresponding physical qubits.
 
         `self.logical_qid_to_int[self.int_to_logical_qid[i]] == i` for each i.
@@ -178,7 +178,7 @@ class MappingManager:
         self._logical_to_physical[[lq1, lq2]] = self._logical_to_physical[[lq2, lq1]]
         self._physical_to_logical[[pq1, pq2]] = self._physical_to_logical[[pq2, pq1]]
 
-    def mapped_op(self, op: 'cirq.Operation') -> 'cirq.Operation':
+    def mapped_op(self, op: cirq.Operation) -> cirq.Operation:
         """Transforms the given logical operation to act on corresponding physical qubits.
 
         Args:
@@ -189,7 +189,7 @@ class MappingManager:
         """
         logical_ints = [self._logical_qid_to_int[q] for q in op.qubits]
         physical_ints = self.logical_to_physical[logical_ints]
-        qubit_map: Dict['cirq.Qid', 'cirq.Qid'] = {
+        qubit_map: Dict[cirq.Qid, cirq.Qid] = {
             q: self._int_to_physical_qid[physical_ints[i]] for i, q in enumerate(op.qubits)
         }
         return op.transform_qubits(qubit_map)

cirq/transformers/routing/route_circuit_cqc.py

@@ -14,6 +14,8 @@
 
 """Heuristic qubit routing algorithm based on arxiv:1902.08091."""
 
+from __future__ import annotations
+
 import itertools
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING
 
@@ -108,13 +110,13 @@ class RouteCQC:
 
     def __call__(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
         *,
         lookahead_radius: int = 8,
         tag_inserted_swaps: bool = False,
-        initial_mapper: Optional['cirq.AbstractInitialMapper'] = None,
-        context: Optional['cirq.TransformerContext'] = None,
-    ) -> 'cirq.AbstractCircuit':
+        initial_mapper: Optional[cirq.AbstractInitialMapper] = None,
+        context: Optional[cirq.TransformerContext] = None,
+    ) -> cirq.AbstractCircuit:
         """Transforms the given circuit to make it executable on the device.
 
         This method calls self.route_circuit and returns the routed circuit. See docstring of
@@ -150,13 +152,13 @@ class RouteCQC:
 
     def route_circuit(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: cirq.AbstractCircuit,
         *,
         lookahead_radius: int = 8,
         tag_inserted_swaps: bool = False,
-        initial_mapper: Optional['cirq.AbstractInitialMapper'] = None,
-        context: Optional['cirq.TransformerContext'] = None,
-    ) -> Tuple['cirq.AbstractCircuit', Dict['cirq.Qid', 'cirq.Qid'], Dict['cirq.Qid', 'cirq.Qid']]:
+        initial_mapper: Optional[cirq.AbstractInitialMapper] = None,
+        context: Optional[cirq.TransformerContext] = None,
+    ) -> Tuple[cirq.AbstractCircuit, Dict[cirq.Qid, cirq.Qid], Dict[cirq.Qid, cirq.Qid]]:
         """Transforms the given circuit to make it executable on the device.
 
         This transformer assumes that all multi-qubit operations have been decomposed into 2-qubit
@@ -241,8 +243,8 @@ class RouteCQC:
 
     @classmethod
     def _get_one_and_two_qubit_ops_as_timesteps(
-        cls, circuit: 'cirq.AbstractCircuit'
-    ) -> Tuple[List[List['cirq.Operation']], List[List['cirq.Operation']]]:
+        cls, circuit: cirq.AbstractCircuit
+    ) -> Tuple[List[List[cirq.Operation]], List[List[cirq.Operation]]]:
         """Gets the single and two qubit operations of the circuit factored into timesteps.
 
         The i'th entry in the nested two-qubit and single-qubit ops correspond to the two-qubit
@@ -286,11 +288,11 @@ class RouteCQC:
     def _route(
         cls,
         mm: mapping_manager.MappingManager,
-        two_qubit_ops: List[List['cirq.Operation']],
-        single_qubit_ops: List[List['cirq.Operation']],
+        two_qubit_ops: List[List[cirq.Operation]],
+        single_qubit_ops: List[List[cirq.Operation]],
         lookahead_radius: int,
         tag_inserted_swaps: bool = False,
-    ) -> List[List['cirq.Operation']]:
+    ) -> List[List[cirq.Operation]]:
         """Main routing procedure that inserts necessary swaps on the given timesteps.
 
         The i'th element of the returned list corresponds to the routed operatiosn in the i'th
@@ -316,10 +318,10 @@ class RouteCQC:
             ]
             for timestep_ops in two_qubit_ops
         ]
-        routed_ops: List[List['cirq.Operation']] = []
+        routed_ops: List[List[cirq.Operation]] = []
 
         def process_executable_two_qubit_ops(timestep: int) -> int:
-            unexecutable_ops: List['cirq.Operation'] = []
+            unexecutable_ops: List[cirq.Operation] = []
             unexecutable_ops_ints: List[QidIntPair] = []
             for op, op_ints in zip(two_qubit_ops[timestep], two_qubit_ops_ints[timestep]):
                 if mm.is_adjacent(*op_ints):

cirq/transformers/routing/visualize_routed_circuit.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 Dict, Optional, Tuple, TYPE_CHECKING
 
 from cirq import circuits, ops
@@ -23,20 +25,19 @@ if TYPE_CHECKING:
 class _SwapPrintGate(ops.Gate):
     """A gate that displays the string representation of each qubits on the circuit."""
 
-    def __init__(self, qubits: Tuple[Tuple['cirq.Qid', 'cirq.Qid'], ...]) -> None:
+    def __init__(self, qubits: Tuple[Tuple[cirq.Qid, cirq.Qid], ...]) -> None:
         self.qubits = qubits
 
     def num_qubits(self):
         return len(self.qubits)
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         return tuple(f'{str(q[1])}' for q in self.qubits)
 
 
 def routed_circuit_with_mapping(
-    routed_circuit: 'cirq.AbstractCircuit',
-    initial_map: Optional[Dict['cirq.Qid', 'cirq.Qid']] = None,
-) -> 'cirq.AbstractCircuit':
+    routed_circuit: cirq.AbstractCircuit, initial_map: Optional[Dict[cirq.Qid, cirq.Qid]] = None
+) -> cirq.AbstractCircuit:
     """Returns the same circuits with information about the permutation of qubits after each swap.
 
     Args:
@@ -54,7 +55,7 @@ def routed_circuit_with_mapping(
         initial_map = qdict.copy()
     inverse_map = {v: k for k, v in initial_map.items()}
 
-    def swap_print_moment() -> 'cirq.Operation':
+    def swap_print_moment() -> cirq.Operation:
         return _SwapPrintGate(
             tuple(zip(qdict.values(), [inverse_map[x] for x in qdict.values()]))
         ).on(*all_qubits)

cirq/transformers/stratify.py

@@ -14,6 +14,8 @@
 
 """Transformer pass to repack circuits avoiding simultaneous operations with different classes."""
 
+from __future__ import annotations
+
 import itertools
 from typing import Callable, Dict, Iterable, List, Optional, Sequence, Type, TYPE_CHECKING, Union
 
@@ -37,11 +39,11 @@ Category = Union[
 
 @transformer_api.transformer(add_deep_support=True)
 def stratified_circuit(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     categories: Iterable[Category] = (),
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Repacks avoiding simultaneous operations with different classes.
 
     This transforms the given circuit to ensure that no operations of different categories are
@@ -96,9 +98,9 @@ def stratified_circuit(
 def _stratify_circuit(
     circuit: circuits.AbstractCircuit,
     *,
-    context: 'cirq.TransformerContext',
+    context: cirq.TransformerContext,
     classifiers: Sequence[Classifier],
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Performs the stratification by iterating through the operations in the
     circuit and using the given classifiers to align them.
 
@@ -115,12 +117,12 @@ def _stratify_circuit(
         The stratified circuit.
     """
     num_classes = len(classifiers) + 1  # include one "extra" category for ignored operations
-    new_moments: List[List['cirq.Operation']] = []
+    new_moments: List[List[cirq.Operation]] = []
 
     # Keep track of the latest time index for each qubit, measurement key, and control key.
-    qubit_time_index: Dict['cirq.Qid', int] = {}
-    measurement_time_index: Dict['cirq.MeasurementKey', int] = {}
-    control_time_index: Dict['cirq.MeasurementKey', int] = {}
+    qubit_time_index: Dict[cirq.Qid, int] = {}
+    measurement_time_index: Dict[cirq.MeasurementKey, int] = {}
+    control_time_index: Dict[cirq.MeasurementKey, int] = {}
 
     # The minimum time index for operations with a tag in context.tags_to_ignore.
     last_ignored_ops_time_index = 0
@@ -221,12 +223,12 @@ def _category_to_classifier(category) -> Classifier:
         )
 
 
-def _mock_classifier(op: 'cirq.Operation') -> bool:
+def _mock_classifier(op: cirq.Operation) -> bool:
     """Mock classifier, used to "complete" a collection of classifiers and make it exhaustive."""
     return False  # pragma: no cover
 
 
-def _get_op_class(op: 'cirq.Operation', classifiers: Sequence[Classifier]) -> int:
+def _get_op_class(op: cirq.Operation, classifiers: Sequence[Classifier]) -> int:
     """Get the "class" of an operator, by index."""
     for class_index, classifier in enumerate(classifiers):
         if classifier is _mock_classifier:

cirq/transformers/synchronize_terminal_measurements.py

@@ -14,6 +14,8 @@
 
 """Transformer pass to move terminal measurements to the end of circuit."""
 
+from __future__ import annotations
+
 from typing import List, Optional, Set, Tuple, TYPE_CHECKING
 
 from cirq import circuits, protocols
@@ -23,9 +25,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def find_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
-) -> List[Tuple[int, 'cirq.Operation']]:
+def find_terminal_measurements(circuit: cirq.AbstractCircuit) -> List[Tuple[int, cirq.Operation]]:
     """Finds all terminal measurements in the given circuit.
 
     A measurement is terminal if there are no other operations acting on the measured qubits
@@ -39,9 +39,9 @@ def find_terminal_measurements(
         (moment_index, measurement_operation).
     """
 
-    open_qubits: Set['cirq.Qid'] = set(circuit.all_qubits())
-    seen_control_keys: Set['cirq.MeasurementKey'] = set()
-    terminal_measurements: Set[Tuple[int, 'cirq.Operation']] = set()
+    open_qubits: Set[cirq.Qid] = set(circuit.all_qubits())
+    seen_control_keys: Set[cirq.MeasurementKey] = set()
+    terminal_measurements: Set[Tuple[int, cirq.Operation]] = set()
     for i in range(len(circuit) - 1, -1, -1):
         moment = circuit[i]
         for q in open_qubits:
@@ -62,11 +62,11 @@ def find_terminal_measurements(
 
 @transformer_api.transformer(add_deep_support=True)
 def synchronize_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     after_other_operations: bool = True,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Move measurements to the end of the circuit.
 
     Move all measurements in a circuit to the final moment, if it can accommodate them (without

cirq/transformers/target_gatesets/compilation_target_gateset.py

@@ -14,18 +14,20 @@
 
 """Base class for creating custom target gatesets which can be used for compilation."""
 
+from __future__ import annotations
+
 import abc
 from typing import Hashable, List, Optional, Type, TYPE_CHECKING, Union
 
 from cirq import circuits, ops, protocols, transformers
-from cirq.protocols.decompose_protocol import DecomposeResult
 from cirq.transformers import merge_k_qubit_gates, merge_single_qubit_gates
 
 if TYPE_CHECKING:
     import cirq
+    from cirq.protocols.decompose_protocol import DecomposeResult
 
 
-def create_transformer_with_kwargs(transformer: 'cirq.TRANSFORMER', **kwargs) -> 'cirq.TRANSFORMER':
+def create_transformer_with_kwargs(transformer: cirq.TRANSFORMER, **kwargs) -> cirq.TRANSFORMER:
     """Method to capture additional keyword arguments to transformers while preserving mypy type.
 
     Returns a `cirq.TRANSFORMER` which, when called with a circuit and transformer context, is
@@ -33,13 +35,13 @@ def create_transformer_with_kwargs(transformer: 'cirq.TRANSFORMER', **kwargs) ->
     capture keyword arguments of a transformer before passing them as an argument to an API that
     expects `cirq.TRANSFORMER`. For example:
 
-    >>> def run_transformers(transformers: 'List[cirq.TRANSFORMER]'):
+    >>> def run_transformers(transformers: list[cirq.TRANSFORMER]):
     ...     circuit = cirq.Circuit(cirq.X(cirq.q(0)))
     ...     context = cirq.TransformerContext()
     ...     for transformer in transformers:
     ...         transformer(circuit, context=context)
     ...
-    >>> transformers: 'List[cirq.TRANSFORMER]' = []
+    >>> transformers: list[cirq.TRANSFORMER] = []
     >>> transformers.append(
     ...     cirq.create_transformer_with_kwargs(
     ...         cirq.expand_composite, no_decomp=lambda op: cirq.num_qubits(op) <= 2
@@ -65,8 +67,8 @@ def create_transformer_with_kwargs(transformer: 'cirq.TRANSFORMER', **kwargs) ->
         raise SyntaxError('**kwargs to be captured must not contain `context`.')
 
     def transformer_with_kwargs(
-        circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-    ) -> 'cirq.AbstractCircuit':
+        circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+    ) -> cirq.AbstractCircuit:
         return transformer(circuit, context=context, **kwargs)
 
     return transformer_with_kwargs
@@ -81,7 +83,7 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
 
     def __init__(
         self,
-        *gates: Union[Type['cirq.Gate'], 'cirq.Gate', 'cirq.GateFamily'],
+        *gates: Union[Type[cirq.Gate], cirq.Gate, cirq.GateFamily],
         name: Optional[str] = None,
         unroll_circuit_op: bool = True,
         preserve_moment_structure: bool = True,
@@ -116,7 +118,7 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
         """Maximum number of qubits on which a gate from this gateset can act upon."""
 
     @abc.abstractmethod
-    def decompose_to_target_gateset(self, op: 'cirq.Operation', moment_idx: int) -> DecomposeResult:
+    def decompose_to_target_gateset(self, op: cirq.Operation, moment_idx: int) -> DecomposeResult:
         """Method to rewrite the given operation using gates from this gateset.
 
         Args:
@@ -128,7 +130,7 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
             - `None` or `NotImplemented` if does not know how to decompose `op`.
         """
 
-    def _validate_operation(self, op: 'cirq.Operation') -> bool:
+    def _validate_operation(self, op: cirq.Operation) -> bool:
         """Validates whether the given `cirq.Operation` is contained in this Gateset.
 
         Overrides the method on the base gateset class to ensure that operations which created
@@ -153,7 +155,7 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
         return "_default_merged_k_qubit_unitaries"
 
     @property
-    def preprocess_transformers(self) -> List['cirq.TRANSFORMER']:
+    def preprocess_transformers(self) -> List[cirq.TRANSFORMER]:
         """List of transformers which should be run before decomposing individual operations."""
         reorder_transfomers = (
             [transformers.insertion_sort_transformer] if self._reorder_operations else []
@@ -172,9 +174,9 @@ class CompilationTargetGateset(ops.Gateset, metaclass=abc.ABCMeta):
         ]
 
     @property
-    def postprocess_transformers(self) -> List['cirq.TRANSFORMER']:
+    def postprocess_transformers(self) -> List[cirq.TRANSFORMER]:
         """List of transformers which should be run after decomposing individual operations."""
-        processors: List['cirq.TRANSFORMER'] = [
+        processors: List[cirq.TRANSFORMER] = [
             merge_single_qubit_gates.merge_single_qubit_moments_to_phxz,
             transformers.drop_negligible_operations,
             transformers.drop_empty_moments,
@@ -221,7 +223,7 @@ class TwoQubitCompilationTargetGateset(CompilationTargetGateset):
     def num_qubits(self) -> int:
         return 2
 
-    def decompose_to_target_gateset(self, op: 'cirq.Operation', moment_idx: int) -> DecomposeResult:
+    def decompose_to_target_gateset(self, op: cirq.Operation, moment_idx: int) -> DecomposeResult:
         if not 1 <= protocols.num_qubits(op) <= 2:
             return self._decompose_multi_qubit_operation(op, moment_idx)
         if protocols.num_qubits(op) == 1:
@@ -248,7 +250,7 @@ class TwoQubitCompilationTargetGateset(CompilationTargetGateset):
         )
         if switch_to_new:
             return new_optree
-        mapped_old_optree: List['cirq.OP_TREE'] = []
+        mapped_old_optree: List[cirq.OP_TREE] = []
         for old_op in ops.flatten_to_ops(old_optree):
             if old_op in self:
                 mapped_old_optree.append(old_op)
@@ -260,7 +262,7 @@ class TwoQubitCompilationTargetGateset(CompilationTargetGateset):
         return mapped_old_optree
 
     def _decompose_single_qubit_operation(
-        self, op: 'cirq.Operation', moment_idx: int
+        self, op: cirq.Operation, moment_idx: int
     ) -> DecomposeResult:
         """Decomposes (connected component of) 1-qubit operations using gates from this gateset.
 
@@ -282,7 +284,7 @@ class TwoQubitCompilationTargetGateset(CompilationTargetGateset):
         )
 
     def _decompose_multi_qubit_operation(
-        self, op: 'cirq.Operation', moment_idx: int
+        self, op: cirq.Operation, moment_idx: int
     ) -> DecomposeResult:
         """Decomposes operations acting on more than 2 qubits using gates from this gateset.
 
@@ -298,7 +300,7 @@ class TwoQubitCompilationTargetGateset(CompilationTargetGateset):
 
     @abc.abstractmethod
     def _decompose_two_qubit_operation(
-        self, op: 'cirq.Operation', moment_idx: int
+        self, op: cirq.Operation, moment_idx: int
     ) -> DecomposeResult:
         """Decomposes (connected component of) 2-qubit operations using gates from this gateset.
 

cirq/transformers/target_gatesets/compilation_target_gateset_test.py

@@ -12,12 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
+from __future__ import annotations
+
+from typing import List, TYPE_CHECKING
 
 import pytest
 
 import cirq
-from cirq.protocols.decompose_protocol import DecomposeResult
+
+if TYPE_CHECKING:
+    from cirq.protocols.decompose_protocol import DecomposeResult
 
 
 def test_compilation_target_gateset():
@@ -29,7 +33,7 @@ def test_compilation_target_gateset():
         def num_qubits(self) -> int:
             return 2
 
-        def decompose_to_target_gateset(self, op: 'cirq.Operation', _) -> DecomposeResult:
+        def decompose_to_target_gateset(self, op: cirq.Operation, _) -> DecomposeResult:
             return op if cirq.num_qubits(op) == 2 and cirq.has_unitary(op) else NotImplemented
 
         @property
@@ -63,7 +67,7 @@ class ExampleCXTargetGateset(cirq.TwoQubitCompilationTargetGateset):
     def __init__(self):
         super().__init__(cirq.AnyUnitaryGateFamily(1), cirq.CNOT)
 
-    def _decompose_two_qubit_operation(self, op: 'cirq.Operation', _) -> DecomposeResult:
+    def _decompose_two_qubit_operation(self, op: cirq.Operation, _) -> DecomposeResult:
         if not cirq.has_unitary(op):
             return NotImplemented
 
@@ -77,7 +81,7 @@ class ExampleCXTargetGateset(cirq.TwoQubitCompilationTargetGateset):
             cirq.Z.on_each(q0, q1),
         ]
 
-    def _decompose_single_qubit_operation(self, op: 'cirq.Operation', _) -> DecomposeResult:
+    def _decompose_single_qubit_operation(self, op: cirq.Operation, _) -> DecomposeResult:
         if not cirq.has_unitary(op):
             return NotImplemented
         assert self._intermediate_result_tag in op.tags
@@ -209,11 +213,11 @@ def test_two_qubit_compilation_replaces_only_if_2q_gate_count_is_less():
         def __init__(self):
             super().__init__(cirq.X, cirq.CNOT)
 
-        def _decompose_two_qubit_operation(self, op: 'cirq.Operation', _) -> DecomposeResult:
+        def _decompose_two_qubit_operation(self, op: cirq.Operation, _) -> DecomposeResult:
             q0, q1 = op.qubits
             return [cirq.X.on_each(q0, q1), cirq.CNOT(q0, q1)] * 10
 
-        def _decompose_single_qubit_operation(self, op: 'cirq.Operation', _) -> DecomposeResult:
+        def _decompose_single_qubit_operation(self, op: cirq.Operation, _) -> DecomposeResult:
             return cirq.X(*op.qubits) if op.gate == cirq.Y else NotImplemented
 
     q = cirq.LineQubit.range(2)

cirq/transformers/target_gatesets/cz_gateset.py

@@ -14,6 +14,8 @@
 
 """Target gateset used for compiling circuits to CZ + 1-q rotations + measurement gates."""
 
+from __future__ import annotations
+
 from typing import Any, Dict, Sequence, Type, TYPE_CHECKING, Union
 
 from cirq import ops, protocols
@@ -47,7 +49,7 @@ class CZTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGatese
         *,
         atol: float = 1e-8,
         allow_partial_czs: bool = False,
-        additional_gates: Sequence[Union[Type['cirq.Gate'], 'cirq.Gate', 'cirq.GateFamily']] = (),
+        additional_gates: Sequence[Union[Type[cirq.Gate], cirq.Gate, cirq.GateFamily]] = (),
         preserve_moment_structure: bool = True,
         reorder_operations: bool = False,
     ) -> None:
@@ -83,7 +85,7 @@ class CZTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGatese
         self.atol = atol
         self.allow_partial_czs = allow_partial_czs
 
-    def _decompose_two_qubit_operation(self, op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def _decompose_two_qubit_operation(self, op: cirq.Operation, _) -> cirq.OP_TREE:
         if not protocols.has_unitary(op):
             return NotImplemented
         return two_qubit_to_cz.two_qubit_matrix_to_cz_operations(

cirq/transformers/target_gatesets/sqrt_iswap_gateset.py

@@ -14,15 +14,17 @@
 
 """Target gateset used for compiling circuits to √iSWAP + 1-q rotations + measurement gates."""
 
+from __future__ import annotations
+
 from typing import Any, Dict, Optional, Sequence, Type, TYPE_CHECKING, Union
 
 from cirq import ops, protocols
-from cirq.protocols.decompose_protocol import DecomposeResult
 from cirq.transformers.analytical_decompositions import two_qubit_to_sqrt_iswap
 from cirq.transformers.target_gatesets import compilation_target_gateset
 
 if TYPE_CHECKING:
     import cirq
+    from cirq.protocols.decompose_protocol import DecomposeResult
 
 
 class SqrtIswapTargetGateset(compilation_target_gateset.TwoQubitCompilationTargetGateset):
@@ -49,7 +51,7 @@ class SqrtIswapTargetGateset(compilation_target_gateset.TwoQubitCompilationTarge
         atol: float = 1e-8,
         required_sqrt_iswap_count: Optional[int] = None,
         use_sqrt_iswap_inv: bool = False,
-        additional_gates: Sequence[Union[Type['cirq.Gate'], 'cirq.Gate', 'cirq.GateFamily']] = (),
+        additional_gates: Sequence[Union[Type[cirq.Gate], cirq.Gate, cirq.GateFamily]] = (),
     ):
         """Initializes `cirq.SqrtIswapTargetGateset`
 
@@ -87,7 +89,7 @@ class SqrtIswapTargetGateset(compilation_target_gateset.TwoQubitCompilationTarge
         self.required_sqrt_iswap_count = required_sqrt_iswap_count
         self.use_sqrt_iswap_inv = use_sqrt_iswap_inv
 
-    def _decompose_two_qubit_operation(self, op: 'cirq.Operation', _) -> DecomposeResult:
+    def _decompose_two_qubit_operation(self, op: cirq.Operation, _) -> DecomposeResult:
         if protocols.has_unitary(op):
             return two_qubit_to_sqrt_iswap.two_qubit_matrix_to_sqrt_iswap_operations(
                 op.qubits[0],