cirq-core 1.5.0.dev20250409225226__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/transformers/routing/initial_mapper.py

@@ -12,8 +12,10 @@
 # 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
+from typing import TYPE_CHECKING
 
 from cirq import value
 
@@ -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/initial_mapper_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq

cirq/transformers/routing/line_initial_mapper.py

@@ -30,8 +30,10 @@ 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
+from typing import TYPE_CHECKING
 
 import networkx as nx
 
@@ -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:

cirq/transformers/routing/line_initial_mapper_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import networkx as nx
 import pytest
 
@@ -66,7 +68,7 @@ def construct_valid_circuit():
     )
 
 
-def test_valid_circuit():
+def test_valid_circuit() -> None:
     # Any circuit with a (full connectivity) graph of disjoint lines should be directly
     # executable after mapping a a supporting device topology without the need for inserting
     # any swaps.
@@ -79,7 +81,7 @@ def test_valid_circuit():
     device.validate_circuit(mapped_circuit)
 
 
-def test_long_line_on_grid_device():
+def test_long_line_on_grid_device() -> None:
     # tests
     #   -if strategy is able to map a single long line onto the device whenever the device topology
     #   supports it (i.e. is Hamiltonian)
@@ -106,7 +108,7 @@ def test_long_line_on_grid_device():
         mapper.initial_mapping(step_circuit)
 
 
-def test_small_circuit_on_grid_device():
+def test_small_circuit_on_grid_device() -> None:
     circuit = construct_small_circuit()
     device_graph = cirq.testing.construct_grid_device(7, 7).metadata.nx_graph
     mapper = cirq.LineInitialMapper(device_graph)
@@ -126,7 +128,7 @@ def test_small_circuit_on_grid_device():
     cirq.testing.assert_same_circuits(circuit.transform_qubits(mapping), expected_circuit)
 
 
-def test_small_circuit_on_ring_device():
+def test_small_circuit_on_ring_device() -> None:
     circuit = construct_small_circuit()
     device_graph = cirq.testing.construct_ring_device(10, directed=True).metadata.nx_graph
 
@@ -159,7 +161,7 @@ glob_mapper = cirq.LineInitialMapper(glob_device_graph)
 )
 def test_random_circuits_grid_device(
     qubits: int, n_moments: int, op_density: float, random_state: int
-):
+) -> None:
     c_orig = cirq.testing.random_circuit(
         qubits=qubits, n_moments=n_moments, op_density=op_density, random_state=random_state
     )
@@ -176,7 +178,7 @@ def test_random_circuits_grid_device(
 )
 def test_large_random_circuits_grid_device(
     qubits: int, n_moments: int, op_density: float, random_state: int
-):
+) -> None:
     c_orig = cirq.testing.random_circuit(
         qubits=qubits, n_moments=n_moments, op_density=op_density, random_state=random_state
     )
@@ -187,7 +189,7 @@ def test_large_random_circuits_grid_device(
     assert nx.is_connected(nx.induced_subgraph(glob_device_graph, mapping.values()))
 
 
-def test_repr():
+def test_repr() -> None:
     device_graph = cirq.testing.construct_grid_device(7, 7).metadata.nx_graph
     mapper = cirq.LineInitialMapper(device_graph)
     cirq.testing.assert_equivalent_repr(mapper, setup_code='import cirq\nimport networkx as nx')

cirq/transformers/routing/mapping_manager.py

@@ -14,7 +14,9 @@
 
 """Manages the mapping from logical to physical qubits during a routing procedure."""
 
-from typing import Dict, List, Sequence, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Sequence, TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
@@ -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/mapping_manager_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import networkx as nx
 import pytest
 from networkx.utils.misc import graphs_equal

cirq/transformers/routing/route_circuit_cqc.py

@@ -14,8 +14,10 @@
 
 """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
+from typing import Any, Sequence, TYPE_CHECKING
 
 import networkx as nx
 
@@ -26,12 +28,12 @@ from cirq.transformers.routing import line_initial_mapper, mapping_manager
 if TYPE_CHECKING:
     import cirq
 
-QidIntPair = Tuple[int, int]
+QidIntPair = tuple[int, int]
 
 
 def _disjoint_nc2_combinations(
     qubit_pairs: Sequence[QidIntPair],
-) -> List[Tuple[QidIntPair, QidIntPair]]:
+) -> list[tuple[QidIntPair, QidIntPair]]:
     """Gets disjoint pair combinations of qubits pairs.
 
     For example:
@@ -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: cirq.AbstractInitialMapper | None = None,
+        context: cirq.TransformerContext | None = 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: cirq.AbstractInitialMapper | None = None,
+        context: cirq.TransformerContext | None = 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
@@ -254,7 +256,7 @@ class RouteCQC:
                         qubits with a custom key.
         """
         two_qubit_circuit = circuits.Circuit()
-        single_qubit_ops: List[List[cirq.Operation]] = []
+        single_qubit_ops: list[list[cirq.Operation]] = []
 
         for i, moment in enumerate(circuit):
             for op in moment:
@@ -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
@@ -309,18 +311,18 @@ class RouteCQC:
         Returns:
             a list of lists corresponding to timesteps of the routed circuit.
         """
-        two_qubit_ops_ints: List[List[QidIntPair]] = [
+        two_qubit_ops_ints: list[list[QidIntPair]] = [
             [
                 (mm.logical_qid_to_int[op.qubits[0]], mm.logical_qid_to_int[op.qubits[1]])
                 for op in timestep_ops
             ]
             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_ints: List[QidIntPair] = []
+            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):
                     routed_ops[timestep].append(mm.mapped_op(op))
@@ -339,10 +341,10 @@ class RouteCQC:
 
             # swaps applied in the current timestep thus far. This ensures the same swaps
             # don't get executed twice in the same timestep.
-            seen: Set[Tuple[QidIntPair, ...]] = set()
+            seen: set[tuple[QidIntPair, ...]] = set()
 
             while process_executable_two_qubit_ops(timestep):
-                chosen_swaps: Optional[Tuple[QidIntPair, ...]] = None
+                chosen_swaps: tuple[QidIntPair, ...] | None = None
                 for strat in strats:
                     chosen_swaps = strat(mm, two_qubit_ops_ints, timestep, lookahead_radius)
                     if chosen_swaps is not None:
@@ -370,7 +372,7 @@ class RouteCQC:
         mm: mapping_manager.MappingManager,
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
-    ) -> Tuple[QidIntPair, ...]:
+    ) -> tuple[QidIntPair, ...]:
         """Inserts SWAPS along the shortest path of the qubits that are the farthest.
 
         Since swaps along the shortest path are being executed one after the other, in order
@@ -388,7 +390,7 @@ class RouteCQC:
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
         lookahead_radius: int,
-    ) -> Optional[Tuple[QidIntPair, ...]]:
+    ) -> tuple[QidIntPair, ...] | None:
         """Computes cost function with pairs of candidate swaps that act on disjoint qubits."""
         pair_sigma = _disjoint_nc2_combinations(
             cls._initial_candidate_swaps(mm, two_qubit_ops_ints[timestep])
@@ -404,9 +406,9 @@ class RouteCQC:
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
         lookahead_radius: int,
-    ) -> Optional[Tuple[QidIntPair, ...]]:
+    ) -> tuple[QidIntPair, ...] | None:
         """Computes cost function with list of single candidate swaps."""
-        sigma: List[Tuple[QidIntPair, ...]] = [
+        sigma: list[tuple[QidIntPair, ...]] = [
             (swap,) for swap in cls._initial_candidate_swaps(mm, two_qubit_ops_ints[timestep])
         ]
         return cls._choose_optimal_swap(mm, two_qubit_ops_ints, timestep, lookahead_radius, sigma)
@@ -418,8 +420,8 @@ class RouteCQC:
         two_qubit_ops_ints: Sequence[Sequence[QidIntPair]],
         timestep: int,
         lookahead_radius: int,
-        sigma: Sequence[Tuple[QidIntPair, ...]],
-    ) -> Optional[Tuple[QidIntPair, ...]]:
+        sigma: Sequence[tuple[QidIntPair, ...]],
+    ) -> tuple[QidIntPair, ...] | None:
         """Optionally returns the swap with minimum cost from a list of n-tuple candidate swaps.
 
         Computes a cost (as defined by the overridable function `_cost`) for each candidate swap
@@ -447,7 +449,7 @@ class RouteCQC:
     @classmethod
     def _initial_candidate_swaps(
         cls, mm: mapping_manager.MappingManager, two_qubit_ops: Sequence[QidIntPair]
-    ) -> List[QidIntPair]:
+    ) -> list[QidIntPair]:
         """Finds all feasible SWAPs between qubits involved in 2-qubit operations."""
         physical_qubits = (mm.logical_to_physical[lq[i]] for lq in two_qubit_ops for i in range(2))
         physical_swaps = mm.induced_subgraph_int.edges(nbunch=physical_qubits)
@@ -459,7 +461,7 @@ class RouteCQC:
     def _cost(
         cls,
         mm: mapping_manager.MappingManager,
-        swaps: Tuple[QidIntPair, ...],
+        swaps: tuple[QidIntPair, ...],
         two_qubit_ops: Sequence[QidIntPair],
     ) -> Any:
         """Computes the cost function for the given list of swaps over the current timestep ops.

cirq/transformers/routing/route_circuit_cqc_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 
 
-def test_directed_device():
+def test_directed_device() -> None:
     device = cirq.testing.construct_ring_device(10, directed=True)
     device_graph = device.metadata.nx_graph
     with pytest.raises(ValueError, match="Device graph must be undirected."):
@@ -33,7 +35,7 @@ def test_directed_device():
         for op_density in [0.3, 0.5, 0.7]
     ],
 )
-def test_route_small_circuit_random(n_qubits, n_moments, op_density, seed):
+def test_route_small_circuit_random(n_qubits, n_moments, op_density, seed) -> None:
     c_orig = cirq.testing.random_circuit(
         qubits=n_qubits, n_moments=n_moments, op_density=op_density, random_state=seed
     )
@@ -47,7 +49,7 @@ def test_route_small_circuit_random(n_qubits, n_moments, op_density, seed):
     )
 
 
-def test_high_qubit_count():
+def test_high_qubit_count() -> None:
     c_orig = cirq.testing.random_circuit(qubits=40, n_moments=350, op_density=0.4, random_state=0)
     device = cirq.testing.construct_grid_device(7, 7)
     device_graph = device.metadata.nx_graph
@@ -56,7 +58,7 @@ def test_high_qubit_count():
     device.validate_circuit(c_routed)
 
 
-def test_multi_qubit_gate_inputs():
+def test_multi_qubit_gate_inputs() -> None:
     device = cirq.testing.construct_grid_device(4, 4)
     device_graph = device.metadata.nx_graph
     router = cirq.RouteCQC(device_graph)
@@ -97,7 +99,7 @@ def test_multi_qubit_gate_inputs():
     device.validate_circuit(c_routed)
 
 
-def test_circuit_with_measurement_gates():
+def test_circuit_with_measurement_gates() -> None:
     device = cirq.testing.construct_ring_device(3)
     device_graph = device.metadata.nx_graph
     q = cirq.LineQubit.range(3)
@@ -108,7 +110,7 @@ def test_circuit_with_measurement_gates():
     cirq.testing.assert_same_circuits(routed_circuit, circuit)
 
 
-def test_circuit_with_two_qubit_intermediate_measurement_gate():
+def test_circuit_with_two_qubit_intermediate_measurement_gate() -> None:
     device = cirq.testing.construct_ring_device(2)
     device_graph = device.metadata.nx_graph
     router = cirq.RouteCQC(device_graph)
@@ -121,7 +123,7 @@ def test_circuit_with_two_qubit_intermediate_measurement_gate():
     device.validate_circuit(routed_circuit)
 
 
-def test_circuit_with_multi_qubit_intermediate_measurement_gate_and_with_default_key():
+def test_circuit_with_multi_qubit_intermediate_measurement_gate_and_with_default_key() -> None:
     device = cirq.testing.construct_ring_device(3)
     device_graph = device.metadata.nx_graph
     router = cirq.RouteCQC(device_graph)
@@ -135,7 +137,7 @@ def test_circuit_with_multi_qubit_intermediate_measurement_gate_and_with_default
     cirq.testing.assert_same_circuits(routed_circuit, expected)
 
 
-def test_circuit_with_multi_qubit_intermediate_measurement_gate_with_custom_key():
+def test_circuit_with_multi_qubit_intermediate_measurement_gate_with_custom_key() -> None:
     device = cirq.testing.construct_ring_device(3)
     device_graph = device.metadata.nx_graph
     router = cirq.RouteCQC(device_graph)
@@ -150,7 +152,7 @@ def test_circuit_with_multi_qubit_intermediate_measurement_gate_with_custom_key(
         )
 
 
-def test_circuit_with_non_unitary_and_global_phase():
+def test_circuit_with_non_unitary_and_global_phase() -> None:
     device = cirq.testing.construct_ring_device(4)
     device_graph = device.metadata.nx_graph
     q = cirq.LineQubit.range(3)
@@ -176,7 +178,7 @@ def test_circuit_with_non_unitary_and_global_phase():
     cirq.testing.assert_same_circuits(routed_circuit, expected)
 
 
-def test_circuit_with_tagged_ops():
+def test_circuit_with_tagged_ops() -> None:
     device = cirq.testing.construct_ring_device(4)
     device_graph = device.metadata.nx_graph
     q = cirq.LineQubit.range(3)
@@ -205,7 +207,7 @@ def test_circuit_with_tagged_ops():
     cirq.testing.assert_same_circuits(routed_circuit, expected)
 
 
-def test_already_valid_circuit():
+def test_already_valid_circuit() -> None:
     device = cirq.testing.construct_ring_device(10)
     device_graph = device.metadata.nx_graph
     circuit = cirq.Circuit(
@@ -222,7 +224,7 @@ def test_already_valid_circuit():
     cirq.testing.assert_same_circuits(routed_circuit, circuit)
 
 
-def test_empty_circuit():
+def test_empty_circuit() -> None:
     device = cirq.testing.construct_grid_device(5, 5)
     device_graph = device.metadata.nx_graph
     empty_circuit = cirq.Circuit()
@@ -235,7 +237,7 @@ def test_empty_circuit():
     )
 
 
-def test_repr():
+def test_repr() -> None:
     device = cirq.testing.construct_ring_device(10)
     device_graph = device.metadata.nx_graph
     router = cirq.RouteCQC(device_graph)

cirq/transformers/routing/visualize_routed_circuit.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, Optional, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import 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: dict[cirq.Qid, cirq.Qid] | None = 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/routing/visualize_routed_circuit_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 
 
-def test_routed_circuit_with_mapping_simple():
+def test_routed_circuit_with_mapping_simple() -> None:
     q = cirq.LineQubit.range(2)
     circuit = cirq.Circuit([cirq.Moment(cirq.SWAP(q[0], q[1]).with_tags(cirq.RoutingSwapTag()))])
     expected_diagram = """
@@ -57,7 +59,7 @@ def test_routed_circuit_with_mapping_simple():
         cirq.routed_circuit_with_mapping(circuit)
 
 
-def test_routed_circuit_with_mapping_multi_swaps():
+def test_routed_circuit_with_mapping_multi_swaps() -> None:
     q = cirq.LineQubit.range(6)
     circuit = cirq.Circuit(
         [