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

cirq/transformers/measurement_transformers.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 from collections import defaultdict
 from typing import Any, cast, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
@@ -33,7 +35,7 @@ class _MeasurementQid(ops.Qid):
     Exactly one qubit will be created per qubit in the measurement gate.
     """
 
-    def __init__(self, key: Union[str, 'cirq.MeasurementKey'], qid: 'cirq.Qid', index: int = 0):
+    def __init__(self, key: Union[str, cirq.MeasurementKey], qid: cirq.Qid, index: int = 0):
         """Initializes the qubit.
 
         Args:
@@ -63,8 +65,8 @@ class _MeasurementQid(ops.Qid):
 
 @transformer_api.transformer
 def defer_measurements(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+) -> cirq.Circuit:
     """Implements the Deferred Measurement Principle.
 
     Uses the Deferred Measurement Principle to move all measurements to the
@@ -94,11 +96,9 @@ def defer_measurements(
 
     circuit = transformer_primitives.unroll_circuit_op(circuit, deep=True, tags_to_check=None)
     terminal_measurements = {op for _, op in find_terminal_measurements(circuit)}
-    measurement_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = defaultdict(
-        list
-    )
+    measurement_qubits: Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]] = defaultdict(list)
 
-    def defer(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def defer(op: cirq.Operation, _) -> cirq.OP_TREE:
         if op in terminal_measurements:
             return op
         gate = op.gate
@@ -169,9 +169,9 @@ def defer_measurements(
 
 
 def _all_possible_datastore_states(
-    keys: Iterable[Tuple['cirq.MeasurementKey', int]],
-    measurement_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]],
-) -> Iterable['cirq.ClassicalDataStoreReader']:
+    keys: Iterable[Tuple[cirq.MeasurementKey, int]],
+    measurement_qubits: Dict[cirq.MeasurementKey, List[Tuple[cirq.Qid, ...]]],
+) -> Iterable[cirq.ClassicalDataStoreReader]:
     """The cartesian product of all possible DataStore states for the given keys."""
     # First we get the list of all possible values. So if we have a key mapped to qubits of shape
     # (2, 2) and a key mapped to a qutrit, the possible measurement values are:
@@ -214,10 +214,10 @@ def _all_possible_datastore_states(
 
 @transformer_api.transformer
 def dephase_measurements(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = transformer_api.TransformerContext(deep=True),
-) -> 'cirq.Circuit':
+    context: Optional[cirq.TransformerContext] = transformer_api.TransformerContext(deep=True),
+) -> cirq.Circuit:
     """Changes all measurements to a dephase operation.
 
     This transformer is useful when using a density matrix simulator, when
@@ -240,7 +240,7 @@ def dephase_measurements(
             surprises.
     """
 
-    def dephase(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def dephase(op: cirq.Operation, _) -> cirq.OP_TREE:
         gate = op.gate
         if isinstance(gate, ops.MeasurementGate):
             key = value.MeasurementKey.parse_serialized(gate.key)
@@ -257,10 +257,10 @@ def dephase_measurements(
 
 @transformer_api.transformer
 def drop_terminal_measurements(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = transformer_api.TransformerContext(deep=True),
-) -> 'cirq.Circuit':
+    context: Optional[cirq.TransformerContext] = transformer_api.TransformerContext(deep=True),
+) -> cirq.Circuit:
     """Removes terminal measurements from a circuit.
 
     This transformer is helpful when trying to capture the final state vector
@@ -289,7 +289,7 @@ def drop_terminal_measurements(
     if not circuit.are_all_measurements_terminal():
         raise ValueError('Circuit contains a non-terminal measurement.')
 
-    def flip_inversion(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def flip_inversion(op: cirq.Operation, _) -> cirq.OP_TREE:
         if isinstance(op.gate, ops.MeasurementGate):
             return [
                 (
@@ -432,7 +432,7 @@ class _ConfusionChannel(ops.Gate):
     def _kraus_(self) -> Tuple[np.ndarray, ...]:
         return self._kraus
 
-    def _apply_channel_(self, args: 'cirq.ApplyChannelArgs'):
+    def _apply_channel_(self, args: cirq.ApplyChannelArgs):
         configs: List[transformations._BuildFromSlicesArgs] = []
         for i in range(np.prod(self._shape) ** 2):
             scale = cast(complex, self._confusion_map.flat[i])
@@ -472,7 +472,7 @@ class _ModAdd(ops.ArithmeticGate):
     def registers(self) -> Tuple[Tuple[int], Tuple[int]]:
         return (self._dimension,), (self._dimension,)
 
-    def with_registers(self, *new_registers) -> '_ModAdd':
+    def with_registers(self, *new_registers) -> _ModAdd:
         raise NotImplementedError()
 
     def apply(self, *register_values: int) -> Tuple[int, int]:
@@ -482,7 +482,7 @@ class _ModAdd(ops.ArithmeticGate):
         return self._dimension
 
 
-def _mod_add(source: 'cirq.Qid', target: 'cirq.Qid') -> 'cirq.Operation':
+def _mod_add(source: cirq.Qid, target: cirq.Qid) -> cirq.Operation:
     assert source.dimension == target.dimension
     if source.dimension == 2:
         # Use a CX gate in 2D case for simplicity.

cirq/transformers/merge_k_qubit_gates.py

@@ -14,6 +14,8 @@
 
 """Transformer pass to merge connected components of k-qubit unitary operations."""
 
+from __future__ import annotations
+
 from typing import Callable, cast, Optional, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
@@ -24,16 +26,16 @@ if TYPE_CHECKING:
 
 
 def _rewrite_merged_k_qubit_unitaries(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     k: int = 0,
-    rewriter: Optional[Callable[['cirq.CircuitOperation'], 'cirq.OP_TREE']] = None,
+    rewriter: Optional[Callable[[cirq.CircuitOperation], cirq.OP_TREE]] = None,
     merged_circuit_op_tag: str = "_merged_k_qubit_unitaries_component",
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     deep = context.deep if context else False
 
-    def map_func(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
         op_untagged = op.untagged
         if (
             deep
@@ -66,12 +68,12 @@ def _rewrite_merged_k_qubit_unitaries(
 
 @transformer_api.transformer
 def merge_k_qubit_unitaries(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     k: int = 0,
-    rewriter: Optional[Callable[['cirq.CircuitOperation'], 'cirq.OP_TREE']] = None,
-) -> 'cirq.Circuit':
+    rewriter: Optional[Callable[[cirq.CircuitOperation], cirq.OP_TREE]] = None,
+) -> cirq.Circuit:
     """Merges connected components of unitary operations, acting on <= k qubits.
 
     Uses rewriter to convert a connected component of unitary operations acting on <= k-qubits

cirq/transformers/merge_k_qubit_gates_test.py

@@ -14,6 +14,8 @@
 
 # pylint: skip-file
 
+from __future__ import annotations
+
 from typing import List
 
 import numpy as np
@@ -133,7 +135,7 @@ a: ═════════════════════════
     )
     component_id = 0
 
-    def rewriter_merge_to_circuit_op(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter_merge_to_circuit_op(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         nonlocal component_id
         component_id = component_id + 1
         return op.with_tags(f'{component_id}')
@@ -160,7 +162,7 @@ a: ═════════════════════════
 
     component_id = 0
 
-    def rewriter_replace_with_decomp(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter_replace_with_decomp(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         nonlocal component_id
         component_id = component_id + 1
         tag = f'{component_id}'
@@ -220,7 +222,7 @@ def test_merge_k_qubit_unitaries_deep():
 
     component_id = 0
 
-    def rewriter_merge_to_circuit_op(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter_merge_to_circuit_op(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         nonlocal component_id
         component_id = component_id + 1
         return op.with_tags(f'{component_id}')

cirq/transformers/merge_single_qubit_gates.py

@@ -14,6 +14,8 @@
 
 """Transformer passes to combine adjacent single-qubit rotations."""
 
+from __future__ import annotations
+
 from typing import Optional, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
@@ -26,11 +28,11 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def merge_single_qubit_gates_to_phased_x_and_z(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Replaces runs of single qubit rotations with `cirq.PhasedXPowGate` and `cirq.ZPowGate`.
 
     Specifically, any run of non-parameterized single-qubit unitaries will be replaced by an
@@ -46,7 +48,7 @@ def merge_single_qubit_gates_to_phased_x_and_z(
         Copy of the transformed input circuit.
     """
 
-    def rewriter(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         u = protocols.unitary(op)
         if protocols.num_qubits(op) == 0:
             return ops.GlobalPhaseGate(u[0, 0]).on()
@@ -62,11 +64,11 @@ def merge_single_qubit_gates_to_phased_x_and_z(
 
 @transformer_api.transformer
 def merge_single_qubit_gates_to_phxz(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Replaces runs of single qubit rotations with a single optional `cirq.PhasedXZGate`.
 
     Specifically, any run of non-parameterized single-qubit unitaries will be replaced by an
@@ -82,7 +84,7 @@ def merge_single_qubit_gates_to_phxz(
         Copy of the transformed input circuit.
     """
 
-    def rewriter(op: 'cirq.CircuitOperation') -> 'cirq.OP_TREE':
+    def rewriter(op: cirq.CircuitOperation) -> cirq.OP_TREE:
         u = protocols.unitary(op)
         if protocols.num_qubits(op) == 0:
             return ops.GlobalPhaseGate(u[0, 0]).on()
@@ -96,11 +98,11 @@ def merge_single_qubit_gates_to_phxz(
 
 @transformer_api.transformer
 def merge_single_qubit_moments_to_phxz(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: Optional[cirq.TransformerContext] = None,
     atol: float = 1e-8,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Merges adjacent moments with only 1-qubit rotations to a single moment with PhasedXZ gates.
 
     Args:
@@ -114,7 +116,7 @@ def merge_single_qubit_moments_to_phxz(
     """
     tags_to_ignore = set(context.tags_to_ignore) if context else set()
 
-    def can_merge_moment(m: 'cirq.Moment'):
+    def can_merge_moment(m: cirq.Moment):
         return all(
             protocols.num_qubits(op) == 1
             and protocols.has_unitary(op)
@@ -122,7 +124,7 @@ def merge_single_qubit_moments_to_phxz(
             for op in m
         )
 
-    def merge_func(m1: 'cirq.Moment', m2: 'cirq.Moment') -> Optional['cirq.Moment']:
+    def merge_func(m1: cirq.Moment, m2: cirq.Moment) -> Optional[cirq.Moment]:
         if not (can_merge_moment(m1) and can_merge_moment(m2)):
             return None
         ret_ops = []

cirq/transformers/optimize_for_target_gateset.py

@@ -14,6 +14,8 @@
 
 """Transformers to rewrite a circuit using gates from a given target gateset."""
 
+from __future__ import annotations
+
 from typing import Callable, Hashable, Optional, Sequence, TYPE_CHECKING, Union
 
 from cirq import circuits
@@ -24,8 +26,8 @@ if TYPE_CHECKING:
     import cirq
 
 
-def _create_on_stuck_raise_error(gateset: 'cirq.Gateset'):
-    def _value_error_describing_bad_operation(op: 'cirq.Operation') -> ValueError:
+def _create_on_stuck_raise_error(gateset: cirq.Gateset):
+    def _value_error_describing_bad_operation(op: cirq.Operation) -> ValueError:
         return ValueError(f"Unable to convert {op} to target gateset {gateset!r}")
 
     return _value_error_describing_bad_operation
@@ -33,14 +35,14 @@ def _create_on_stuck_raise_error(gateset: 'cirq.Gateset'):
 
 @transformer_api.transformer
 def _decompose_operations_to_target_gateset(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
-    gateset: Optional['cirq.Gateset'] = None,
-    decomposer: Callable[['cirq.Operation', int], dp.DecomposeResult] = lambda *_: NotImplemented,
+    context: Optional[cirq.TransformerContext] = None,
+    gateset: Optional[cirq.Gateset] = None,
+    decomposer: Callable[[cirq.Operation, int], dp.DecomposeResult] = lambda *_: NotImplemented,
     ignore_failures: bool = True,
     tags_to_decompose: Sequence[Hashable] = (),
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Decomposes every operation to `gateset` using `cirq.decompose` and `decomposer`.
 
     This transformer attempts to decompose every operation `op` in the given circuit to `gateset`
@@ -68,7 +70,7 @@ def _decompose_operations_to_target_gateset(
         ValueError: If any input operation fails to convert and `ignore_failures` is False.
     """
 
-    def map_func(op: 'cirq.Operation', moment_index: int):
+    def map_func(op: cirq.Operation, moment_index: int):
         if (
             context
             and context.deep
@@ -97,13 +99,13 @@ def _decompose_operations_to_target_gateset(
 
 @transformer_api.transformer
 def optimize_for_target_gateset(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
-    gateset: Optional['cirq.CompilationTargetGateset'] = None,
+    context: Optional[cirq.TransformerContext] = None,
+    gateset: Optional[cirq.CompilationTargetGateset] = None,
     ignore_failures: bool = True,
     max_num_passes: Union[int, None] = 1,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Transforms the given circuit into an equivalent circuit using gates accepted by `gateset`.
 
     Repeat max_num_passes times or when `max_num_passes=None` until no further changes can be done

cirq/transformers/optimize_for_target_gateset_test.py

@@ -12,14 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Union
 
 import pytest
 
 import cirq
-from cirq.protocols.decompose_protocol import DecomposeResult
 from cirq.transformers.optimize_for_target_gateset import _decompose_operations_to_target_gateset
 
+if TYPE_CHECKING:
+    from cirq.protocols.decompose_protocol import DecomposeResult
+
 
 def test_decompose_operations_raises_on_stuck():
     c_orig = cirq.Circuit(cirq.X(cirq.NamedQubit("q")).with_tags("ignore"))
@@ -121,7 +125,7 @@ class MatrixGateTargetGateset(cirq.CompilationTargetGateset):
     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:
         if cirq.num_qubits(op) != 2 or not cirq.has_unitary(op):
             return NotImplemented
         return cirq.MatrixGate(cirq.unitary(op), name="M").on(*op.qubits)

cirq/transformers/qubit_management_transformers.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, Set, Tuple, TYPE_CHECKING
 
 from cirq import circuits, ops
@@ -21,8 +23,8 @@ if TYPE_CHECKING:
 
 
 def _get_qubit_mapping_first_and_last_moment(
-    circuit: 'cirq.AbstractCircuit',
-) -> Dict['cirq.Qid', Tuple[int, int]]:
+    circuit: cirq.AbstractCircuit,
+) -> Dict[cirq.Qid, Tuple[int, int]]:
     """Computes `(first_moment_idx, last_moment_idx)` tuple for each qubit in the input circuit.
 
     Args:
@@ -41,13 +43,13 @@ def _get_qubit_mapping_first_and_last_moment(
     return ret
 
 
-def _is_temp(q: 'cirq.Qid') -> bool:
+def _is_temp(q: cirq.Qid) -> bool:
     return isinstance(q, (ops.CleanQubit, ops.BorrowableQubit))
 
 
 def map_clean_and_borrowable_qubits(
-    circuit: 'cirq.AbstractCircuit', *, qm: Optional['cirq.QubitManager'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, qm: Optional[cirq.QubitManager] = None
+) -> cirq.Circuit:
     """Uses `qm: QubitManager` to map all `CleanQubit`/`BorrowableQubit`s to system qubits.
 
     `CleanQubit` and `BorrowableQubit` are internal qubit types that are used as placeholder qubits
@@ -97,11 +99,11 @@ def map_clean_and_borrowable_qubits(
     trivial_map = {q: q for q in all_qubits}
     # `allocated_map` maintains the mapping of all temporary qubits seen so far, mapping each of
     # them to either a newly allocated managed ancilla or an existing borrowed system qubit.
-    allocated_map: Dict['cirq.Qid', 'cirq.Qid'] = {}
-    to_free: Set['cirq.Qid'] = set()
+    allocated_map: Dict[cirq.Qid, cirq.Qid] = {}
+    to_free: Set[cirq.Qid] = set()
     last_op_idx = -1
 
-    def map_func(op: 'cirq.Operation', idx: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, idx: int) -> cirq.OP_TREE:
         nonlocal last_op_idx, to_free
         assert isinstance(qm, ops.QubitManager)
 

cirq/transformers/randomized_measurements.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from collections.abc import Sequence
 from typing import Any
 
@@ -39,12 +41,12 @@ class RandomizedMeasurements:
 
     def __call__(
         self,
-        circuit: "cirq.AbstractCircuit",
+        circuit: cirq.AbstractCircuit,
         unitary_ensemble: str = "pauli",
         rng: np.random.Generator | None = None,
         *,
         context: transformer_api.TransformerContext | None = None,
-    ) -> "cirq.Circuit":
+    ) -> cirq.Circuit:
         """Apply the transformer to the given circuit. Given an input circuit returns
         a new circuit with the pre-measurement unitaries and measurements gates added.
         to the qubits in the subsystem provided.If no subsystem is specified in the
@@ -80,7 +82,7 @@ class RandomizedMeasurements:
 
     def random_single_qubit_unitary_moment(
         self, unitary_ensemble: str, qubits: Sequence[Any], rng: np.random.Generator
-    ) -> "cirq.Moment":
+    ) -> cirq.Moment:
         """Outputs the cirq moment associated with the pre-measurement rotations.
 
         Args:
@@ -115,7 +117,7 @@ class RandomizedMeasurements:
         return cirq.Moment.from_ops(*op_list)
 
 
-def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
+def _pauli_basis_rotation(rng: np.random.Generator) -> cirq.Gate:
     """Randomly generate a Pauli basis rotation.
 
     Args:
@@ -127,7 +129,7 @@ def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
     basis_idx = rng.choice(np.arange(3))
 
     if basis_idx == 0:
-        gate: "cirq.Gate" = cirq.Ry(rads=-np.pi / 2)
+        gate: cirq.Gate = cirq.Ry(rads=-np.pi / 2)
     elif basis_idx == 1:
         gate = cirq.Rx(rads=np.pi / 2)
     else:
@@ -135,7 +137,7 @@ def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
     return gate
 
 
-def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
+def _single_qubit_clifford(rng: np.random.Generator) -> cirq.Gate:
     """Randomly generate a single-qubit Clifford rotation.
 
     Args:
@@ -153,7 +155,7 @@ def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
     )
 
 
-def _single_qubit_cue(rng: np.random.Generator) -> "cirq.Gate":
+def _single_qubit_cue(rng: np.random.Generator) -> cirq.Gate:
     """Randomly generate a CUE gate.
 
     Args:

cirq/transformers/routing/initial_mapper.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 from typing import Dict, TYPE_CHECKING
 
@@ -37,7 +39,7 @@ class AbstractInitialMapper(metaclass=abc.ABCMeta):
     """
 
     @abc.abstractmethod
-    def initial_mapping(self, circuit: 'cirq.AbstractCircuit') -> Dict['cirq.Qid', 'cirq.Qid']:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
         """Maps the logical qubits of a circuit onto physical qubits on a device.
 
         Args:
@@ -52,10 +54,10 @@ class AbstractInitialMapper(metaclass=abc.ABCMeta):
 class HardCodedInitialMapper(AbstractInitialMapper):
     """Initial Mapper class takes a hard-coded mapping and returns it."""
 
-    def __init__(self, _map: Dict['cirq.Qid', 'cirq.Qid']) -> None:
+    def __init__(self, _map: Dict[cirq.Qid, cirq.Qid]) -> None:
         self._map = _map
 
-    def initial_mapping(self, circuit: 'cirq.AbstractCircuit') -> Dict['cirq.Qid', 'cirq.Qid']:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
         """Returns the hard-coded initial mapping.
 
         Args:

cirq/transformers/routing/line_initial_mapper.py

@@ -30,6 +30,8 @@ If some logical qubits are unampped after this first procedure then there are tw
     the nearest available neighbor to the center of the device.
 """
 
+from __future__ import annotations
+
 from collections import deque
 from typing import Deque, Dict, List, Set, Tuple, TYPE_CHECKING
 
@@ -82,8 +84,8 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         self.center = nx.center(self.device_graph)[0]
 
     def _make_circuit_graph(
-        self, circuit: 'cirq.AbstractCircuit'
-    ) -> Tuple[List[Deque['cirq.Qid']], Dict['cirq.Qid', 'cirq.Qid']]:
+        self, circuit: cirq.AbstractCircuit
+    ) -> Tuple[List[Deque[cirq.Qid]], Dict[cirq.Qid, cirq.Qid]]:
         """Creates a (potentially incomplete) qubit connectivity graph of the circuit.
 
         Iterates over moments in the circuit from left to right and adds edges between logical
@@ -99,11 +101,11 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
             The (potentially incomplete) qubit connectivity graph of the circuit, which is
                 guaranteed to be a forest of line graphs.
         """
-        circuit_graph: List[Deque['cirq.Qid']] = [deque([q]) for q in sorted(circuit.all_qubits())]
-        component_id: Dict['cirq.Qid', int] = {q[0]: i for i, q in enumerate(circuit_graph)}
-        partners: Dict['cirq.Qid', 'cirq.Qid'] = {}
+        circuit_graph: List[Deque[cirq.Qid]] = [deque([q]) for q in sorted(circuit.all_qubits())]
+        component_id: Dict[cirq.Qid, int] = {q[0]: i for i, q in enumerate(circuit_graph)}
+        partners: Dict[cirq.Qid, cirq.Qid] = {}
 
-        def degree_lt_two(q: 'cirq.Qid'):
+        def degree_lt_two(q: cirq.Qid):
             return any(circuit_graph[component_id[q]][i] == q for i in [-1, 0])
 
         for op in circuit.all_operations():
@@ -141,7 +143,7 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         )
         return graph, partners
 
-    def initial_mapping(self, circuit: 'cirq.AbstractCircuit') -> Dict['cirq.Qid', 'cirq.Qid']:
+    def initial_mapping(self, circuit: cirq.AbstractCircuit) -> Dict[cirq.Qid, cirq.Qid]:
         """Maps disjoint lines of logical qubits onto lines of physical qubits.
 
         Args:
@@ -151,13 +153,13 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
             a dictionary that maps logical qubits in the circuit (keys) to physical qubits on the
             device (values).
         """
-        mapped_physicals: Set['cirq.Qid'] = set()
-        qubit_map: Dict['cirq.Qid', 'cirq.Qid'] = {}
+        mapped_physicals: Set[cirq.Qid] = set()
+        qubit_map: Dict[cirq.Qid, cirq.Qid] = {}
         circuit_graph, partners = self._make_circuit_graph(circuit)
 
         def next_physical(
-            current_physical: 'cirq.Qid', partner: 'cirq.Qid', isolated: bool = False
-        ) -> 'cirq.Qid':
+            current_physical: cirq.Qid, partner: cirq.Qid, isolated: bool = False
+        ) -> cirq.Qid:
             # Handle the first physical qubit getting mapped.
             if current_physical not in mapped_physicals:
                 return current_physical
@@ -189,8 +191,8 @@ class LineInitialMapper(initial_mapper.AbstractInitialMapper):
         return qubit_map
 
     def _closest_unmapped_qubit(
-        self, source: 'cirq.Qid', mapped_physicals: Set['cirq.Qid']
-    ) -> 'cirq.Qid':
+        self, source: cirq.Qid, mapped_physicals: Set[cirq.Qid]
+    ) -> cirq.Qid:
         """Finds the closest available neighbor to a physical qubit 'source' on the device.
 
         Args: