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

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],

cirq/transformers/transformer_api.py

@@ -14,6 +14,8 @@
 
 """Defines the API for circuit transformers in Cirq."""
 
+from __future__ import annotations
+
 import dataclasses
 import enum
 import functools
@@ -83,8 +85,8 @@ class _LoggerNode:
 
     transformer_id: int
     transformer_name: str
-    initial_circuit: 'cirq.AbstractCircuit'
-    final_circuit: 'cirq.AbstractCircuit'
+    initial_circuit: cirq.AbstractCircuit
+    final_circuit: cirq.AbstractCircuit
     logs: List[Tuple[LogLevel, Tuple[str, ...]]] = dataclasses.field(default_factory=list)
     nested_loggers: List[int] = dataclasses.field(default_factory=list)
 
@@ -116,7 +118,7 @@ class TransformerLogger:
         self._logs: List[_LoggerNode] = []
         self._stack: List[int] = []
 
-    def register_initial(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_initial(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         """Register the beginning of a new transformer stage.
 
         Args:
@@ -143,7 +145,7 @@ class TransformerLogger:
             raise ValueError('No active transformer found.')
         self._logs[self._stack[-1]].logs.append((level, args))
 
-    def register_final(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_final(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         """Register the end of the currently active transformer stage.
 
         Args:
@@ -195,13 +197,13 @@ class TransformerLogger:
 class NoOpTransformerLogger(TransformerLogger):
     """All calls to this logger are a no-op"""
 
-    def register_initial(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_initial(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         pass
 
     def log(self, *args: str, level: LogLevel = LogLevel.INFO) -> None:
         pass
 
-    def register_final(self, circuit: 'cirq.AbstractCircuit', transformer_name: str) -> None:
+    def register_final(self, circuit: cirq.AbstractCircuit, transformer_name: str) -> None:
         pass
 
     def show(self, level: LogLevel = LogLevel.INFO) -> None:
@@ -262,8 +264,8 @@ class TRANSFORMER(Protocol):
     """
 
     def __call__(
-        self, circuit: 'cirq.AbstractCircuit', *, context: Optional[TransformerContext] = None
-    ) -> 'cirq.AbstractCircuit': ...
+        self, circuit: cirq.AbstractCircuit, *, context: Optional[TransformerContext] = None
+    ) -> cirq.AbstractCircuit: ...
 
 
 _TRANSFORMER_T = TypeVar('_TRANSFORMER_T', bound=TRANSFORMER)
@@ -357,8 +359,8 @@ def transformer(cls_or_func: Any = None, *, add_deep_support: bool = False) -> A
 
         @functools.wraps(method)
         def method_with_logging(
-            self, circuit: 'cirq.AbstractCircuit', **kwargs
-        ) -> 'cirq.AbstractCircuit':
+            self, circuit: cirq.AbstractCircuit, **kwargs
+        ) -> cirq.AbstractCircuit:
             return _transform_and_log(
                 add_deep_support,
                 lambda circuit, **kwargs: method(self, circuit, **kwargs),
@@ -376,7 +378,7 @@ def transformer(cls_or_func: Any = None, *, add_deep_support: bool = False) -> A
         default_context = _get_default_context(func)
 
         @functools.wraps(func)
-        def func_with_logging(circuit: 'cirq.AbstractCircuit', **kwargs) -> 'cirq.AbstractCircuit':
+        def func_with_logging(circuit: cirq.AbstractCircuit, **kwargs) -> cirq.AbstractCircuit:
             return _transform_and_log(
                 add_deep_support,
                 func,
@@ -401,10 +403,10 @@ def _get_default_context(func: TRANSFORMER) -> TransformerContext:
 def _run_transformer_on_circuit(
     add_deep_support: bool,
     func: TRANSFORMER,
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     extracted_context: Optional[TransformerContext],
     **kwargs,
-) -> 'cirq.AbstractCircuit':
+) -> cirq.AbstractCircuit:
     mutable_circuit = None
     if extracted_context and extracted_context.deep and add_deep_support:
         batch_replace = []
@@ -429,10 +431,10 @@ def _transform_and_log(
     add_deep_support: bool,
     func: TRANSFORMER,
     transformer_name: str,
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     extracted_context: Optional[TransformerContext],
     **kwargs,
-) -> 'cirq.AbstractCircuit':
+) -> cirq.AbstractCircuit:
     """Helper to log initial and final circuits before and after calling the transformer."""
     if extracted_context:
         extracted_context.logger.register_initial(circuit, transformer_name)

cirq/transformers/transformer_primitives.py

@@ -14,6 +14,8 @@
 
 """Defines primitives for common transformer patterns."""
 
+from __future__ import annotations
+
 import bisect
 import dataclasses
 from collections import defaultdict
@@ -157,7 +159,7 @@ def _map_operations_impl(
     """
     tags_to_ignore_set = set(tags_to_ignore)
 
-    def apply_map_func(op: 'cirq.Operation', idx: int) -> List['cirq.Operation']:
+    def apply_map_func(op: cirq.Operation, idx: int) -> List[cirq.Operation]:
         if tags_to_ignore_set.intersection(op.tags):
             return [op]
         if deep and isinstance(op.untagged, circuits.CircuitOperation):
@@ -173,7 +175,7 @@ def _map_operations_impl(
             ).with_tags(*op.tags)
         mapped_ops = [*ops.flatten_to_ops(map_func(op, idx))]
         op_qubits = set(op.qubits)
-        mapped_ops_qubits: Set['cirq.Qid'] = set()
+        mapped_ops_qubits: Set[cirq.Qid] = set()
         has_overlapping_ops = False
         for mapped_op in mapped_ops:
             if raise_if_add_qubits and not op_qubits.issuperset(mapped_op.qubits):
@@ -194,9 +196,9 @@ def _map_operations_impl(
             ]
         return mapped_ops
 
-    new_moments: List[List['cirq.Operation']] = []
+    new_moments: List[List[cirq.Operation]] = []
     for idx, moment in enumerate(circuit):
-        curr_moments: List[List['cirq.Operation']] = [[]] if wrap_in_circuit_op else []
+        curr_moments: List[List[cirq.Operation]] = [[]] if wrap_in_circuit_op else []
         placement_cache = circuits.circuit._PlacementCache()
         for op in moment:
             mapped_ops = apply_map_func(op, idx)
@@ -305,21 +307,21 @@ class _MergedCircuit:
             of a set to store operations to preserve insertion order.
     """
 
-    qubit_indexes: Dict['cirq.Qid', List[int]] = dataclasses.field(
+    qubit_indexes: Dict[cirq.Qid, List[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    mkey_indexes: Dict['cirq.MeasurementKey', List[int]] = dataclasses.field(
+    mkey_indexes: Dict[cirq.MeasurementKey, List[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    ckey_indexes: Dict['cirq.MeasurementKey', List[int]] = dataclasses.field(
+    ckey_indexes: Dict[cirq.MeasurementKey, List[int]] = dataclasses.field(
         default_factory=lambda: defaultdict(lambda: [-1])
     )
-    ops_by_index: List[Dict['cirq.Operation', int]] = dataclasses.field(default_factory=list)
+    ops_by_index: List[Dict[cirq.Operation, int]] = dataclasses.field(default_factory=list)
 
     def append_empty_moment(self) -> None:
         self.ops_by_index.append({})
 
-    def add_op_to_moment(self, moment_index: int, op: 'cirq.Operation') -> None:
+    def add_op_to_moment(self, moment_index: int, op: cirq.Operation) -> None:
         self.ops_by_index[moment_index][op] = 0
         for q in op.qubits:
             if moment_index > self.qubit_indexes[q][-1]:
@@ -331,7 +333,7 @@ class _MergedCircuit:
         for ckey in protocols.control_keys(op):
             bisect.insort(self.ckey_indexes[ckey], moment_index)
 
-    def remove_op_from_moment(self, moment_index: int, op: 'cirq.Operation') -> None:
+    def remove_op_from_moment(self, moment_index: int, op: cirq.Operation) -> None:
         self.ops_by_index[moment_index].pop(op)
         for q in op.qubits:
             if self.qubit_indexes[q][-1] == moment_index:
@@ -344,8 +346,8 @@ class _MergedCircuit:
             self.ckey_indexes[ckey].remove(moment_index)
 
     def get_mergeable_ops(
-        self, op: 'cirq.Operation', op_qs: Set['cirq.Qid']
-    ) -> Tuple[int, List['cirq.Operation']]:
+        self, op: cirq.Operation, op_qs: Set[cirq.Qid]
+    ) -> Tuple[int, List[cirq.Operation]]:
         # Find the index of previous moment which can be merged with `op`.
         idx = max([self.qubit_indexes[q][-1] for q in op_qs], default=-1)
         idx = max([idx] + [self.mkey_indexes[ckey][-1] for ckey in protocols.control_keys(op)])
@@ -360,7 +362,7 @@ class _MergedCircuit:
             left_op for left_op in self.ops_by_index[idx] if not op_qs.isdisjoint(left_op.qubits)
         ]
 
-    def get_cirq_circuit(self) -> 'cirq.Circuit':
+    def get_cirq_circuit(self) -> cirq.Circuit:
         return circuits.Circuit(circuits.Moment(m.keys()) for m in self.ops_by_index)
 
 
@@ -493,7 +495,7 @@ def merge_operations(
 
 def merge_operations_to_circuit_op(
     circuit: CIRCUIT_TYPE,
-    can_merge: Callable[[Sequence['cirq.Operation'], Sequence['cirq.Operation']], bool],
+    can_merge: Callable[[Sequence[cirq.Operation], Sequence[cirq.Operation]], bool],
     *,
     tags_to_ignore: Sequence[Hashable] = (),
     merged_circuit_op_tag: str = "Merged connected component",
@@ -524,8 +526,8 @@ def merge_operations_to_circuit_op(
         Copy of input circuit with valid connected components wrapped in tagged circuit operations.
     """
 
-    def merge_func(op1: 'cirq.Operation', op2: 'cirq.Operation') -> Optional['cirq.Operation']:
-        def get_ops(op: 'cirq.Operation'):
+    def merge_func(op1: cirq.Operation, op2: cirq.Operation) -> Optional[cirq.Operation]:
+        def get_ops(op: cirq.Operation):
             op_untagged = op.untagged
             return (
                 [*op_untagged.circuit.all_operations()]
@@ -573,7 +575,7 @@ def merge_k_qubit_unitaries_to_circuit_op(
         Copy of input circuit with valid connected components wrapped in tagged circuit operations.
     """
 
-    def can_merge(ops1: Sequence['cirq.Operation'], ops2: Sequence['cirq.Operation']) -> bool:
+    def can_merge(ops1: Sequence[cirq.Operation], ops2: Sequence[cirq.Operation]) -> bool:
         return all(
             protocols.num_qubits(op) <= k and protocols.has_unitary(op)
             for op_list in [ops1, ops2]
@@ -659,7 +661,7 @@ def unroll_circuit_op(
     """
 
     def map_func(m: circuits.Moment, _: int):
-        to_zip: List['cirq.AbstractCircuit'] = []
+        to_zip: List[cirq.AbstractCircuit] = []
         for op in m:
             op_untagged = op.untagged
             if isinstance(op_untagged, circuits.CircuitOperation):
@@ -751,7 +753,7 @@ def unroll_circuit_op_greedy_frontier(
         Copy of input circuit with (Tagged) CircuitOperation's expanded inline at qubit frontier.
     """
     unrolled_circuit = circuit.unfreeze(copy=True)
-    frontier: Dict['cirq.Qid', int] = defaultdict(lambda: 0)
+    frontier: Dict[cirq.Qid, int] = defaultdict(lambda: 0)
     idx = 0
     while idx < len(unrolled_circuit):
         for op in unrolled_circuit[idx].operations:
@@ -799,7 +801,7 @@ def toggle_tags(circuit: CIRCUIT_TYPE, tags: Sequence[Hashable], *, deep: bool =
     """
     tags_to_xor = set(tags)
 
-    def map_func(op: 'cirq.Operation', _) -> 'cirq.Operation':
+    def map_func(op: cirq.Operation, _) -> cirq.Operation:
         return (
             op
             if deep and isinstance(op, circuits.CircuitOperation)

cirq/transformers/transformer_primitives_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 Iterator, List, Optional
 
 import pytest
@@ -721,7 +723,7 @@ def test_merge_operations_to_circuit_op_merges_connected_component():
 ''',
     )
 
-    def can_merge(ops1: List['cirq.Operation'], ops2: List['cirq.Operation']) -> bool:
+    def can_merge(ops1: List[cirq.Operation], ops2: List[cirq.Operation]) -> bool:
         """Artificial example where a CZ will absorb any merge-able operation."""
         return any(o.gate == cirq.CZ for op_list in [ops1, ops2] for o in op_list)