cirq-core 1.4.1__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/contrib/qasm_import/qasm_test.py

@@ -15,8 +15,8 @@ import numpy as np
 
 import cirq
 import cirq.testing as ct
-from cirq.testing import consistent_qasm as cq
 from cirq.contrib.qasm_import import circuit_from_qasm
+from cirq.testing import consistent_qasm as cq
 
 
 def test_consistency_with_qasm_output_and_qiskit():

cirq/contrib/qcircuit/__init__.py

@@ -14,10 +14,12 @@
 
 """Converts cirq circuits into latex using qcircuit."""
 
-from cirq.contrib.qcircuit.qcircuit_diagram import circuit_to_latex_using_qcircuit
+from cirq.contrib.qcircuit.qcircuit_diagram import (
+    circuit_to_latex_using_qcircuit as circuit_to_latex_using_qcircuit,
+)
 
 from cirq.contrib.qcircuit.qcircuit_diagram_info import (
-    escape_text_for_latex,
-    get_multigate_parameters,
-    get_qcircuit_diagram_info,
+    escape_text_for_latex as escape_text_for_latex,
+    get_multigate_parameters as get_multigate_parameters,
+    get_qcircuit_diagram_info as get_qcircuit_diagram_info,
 )

cirq/contrib/qcircuit/qcircuit_diagram.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
@@ -23,7 +26,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def qcircuit_qubit_namer(qubit: 'cirq.Qid') -> str:
+def qcircuit_qubit_namer(qubit: cirq.Qid) -> str:
     """Returns the latex code for a QCircuit label of given qubit.
 
     Args:
@@ -64,7 +67,7 @@ def _render(diagram: circuits.TextDiagramDrawer) -> str:
 
 
 def circuit_to_latex_using_qcircuit(
-    circuit: 'cirq.Circuit', qubit_order: 'cirq.QubitOrderOrList' = ops.QubitOrder.DEFAULT
+    circuit: cirq.Circuit, qubit_order: cirq.QubitOrderOrList = ops.QubitOrder.DEFAULT
 ) -> str:
     """Returns a QCircuit-based latex diagram of the given circuit.
 

cirq/contrib/qcircuit/qcircuit_pdf.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# pragma: no cover
 
 import errno
 import os
@@ -65,4 +64,4 @@ def circuit_to_pdf_using_qcircuit_via_tex(
             os.remove(filepath + '.' + ext)
         except (OSError, IOError) as e:
             if e.errno != errno.ENOENT:
-                raise
+                raise  # pragma: nocover

cirq/{experiments/grid_parallel_two_qubit_xeb_test.py → contrib/qcircuit/qcircuit_pdf_test.py}

@@ -1,4 +1,4 @@
-# Copyright 2022 The Cirq Developers
+# Copyright 2025 The Cirq Developers
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,18 +11,19 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata, LAYER_A, LAYER_B
+
+from unittest import mock
+
+import pylatex
+
 import cirq
+import cirq.contrib.qcircuit.qcircuit_pdf as qcircuit_pdf
 
 
-def test_grid_parallel_xeb_metadata_repr():
-    metadata = GridParallelXEBMetadata(
-        qubits=cirq.GridQubit.square(2),
-        two_qubit_gate=cirq.ISWAP,
-        num_circuits=10,
-        repetitions=10_000,
-        cycles=[2, 4, 6, 8, 10],
-        layers=[LAYER_A, LAYER_B],
-        seed=1234,
+@mock.patch.object(pylatex.Document, "generate_pdf")
+def test_qcircuit_pdf(mock_generate_pdf):
+    circuit = cirq.Circuit(cirq.X(cirq.q(0)), cirq.CZ(cirq.q(0), cirq.q(1)))
+    qcircuit_pdf.circuit_to_pdf_using_qcircuit_via_tex(circuit, "/tmp/test_file")
+    mock_generate_pdf.assert_called_once_with(
+        "/tmp/test_file", compiler="latexmk", compiler_args=["-pdfps"]
     )
-    cirq.testing.assert_equivalent_repr(metadata)

cirq/contrib/qcircuit/qcircuit_test.py

@@ -53,7 +53,7 @@ def test_fallback_diagram():
             self._qubits = qubits
 
         def with_qubits(self, *new_qubits):
-            return MagicOp(*new_qubits)
+            return MagicOp(*new_qubits)  # pragma: no cover
 
         @property
         def qubits(self):

cirq/contrib/quantum_volume/__init__.py

@@ -14,11 +14,11 @@
 """Utilities running the Quantum Volume benchmark on devices"""
 
 from cirq.contrib.quantum_volume.quantum_volume import (
-    generate_model_circuit,
-    compute_heavy_set,
-    sample_heavy_set,
-    compile_circuit,
-    calculate_quantum_volume,
-    QuantumVolumeResult,
-    CompilationResult,
+    generate_model_circuit as generate_model_circuit,
+    compute_heavy_set as compute_heavy_set,
+    sample_heavy_set as sample_heavy_set,
+    compile_circuit as compile_circuit,
+    calculate_quantum_volume as calculate_quantum_volume,
+    QuantumVolumeResult as QuantumVolumeResult,
+    CompilationResult as CompilationResult,
 )

cirq/contrib/quantum_volume/quantum_volume.py

@@ -4,7 +4,7 @@ https://arxiv.org/abs/1811.12926.
 """
 
 from dataclasses import dataclass
-from typing import Optional, List, Callable, Dict, Tuple, Set, Any
+from typing import Callable, Dict, List, Optional, Set, Tuple
 
 import networkx as nx
 import numpy as np
@@ -15,7 +15,7 @@ import cirq.contrib.routing as ccr
 
 
 def generate_model_circuit(
-    num_qubits: int, depth: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    num_qubits: int, depth: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> cirq.Circuit:
     """Generates a model circuit with the given number of qubits and depth.
 
@@ -147,7 +147,7 @@ def sample_heavy_set(
 
     results = results.agg(lambda meas: cirq.value.big_endian_bits_to_int(meas), axis=1)
     # Compute the number of outputs that are in the heavy set.
-    num_in_heavy_set = np.sum(np.in1d(results, heavy_set)).item()
+    num_in_heavy_set = np.sum(np.isin(results, heavy_set)).item()
 
     # Return the number of Heavy outputs over the number of valid runs.
     return num_in_heavy_set / len(results)
@@ -277,7 +277,7 @@ def compile_circuit(
     # Replace the PermutationGates with regular gates, so we don't proliferate
     # the routing implementation details to the compiler and the device itself.
 
-    def replace_swap_permutation_gate(op: 'cirq.Operation', _):
+    def replace_swap_permutation_gate(op: cirq.Operation, _):
         if isinstance(op.gate, cirq.contrib.acquaintance.SwapPermutationGate):
             return [op.gate.swap_gate.on(*op.qubits)]
         return op
@@ -327,7 +327,7 @@ def prepare_circuits(
     num_qubits: int,
     depth: int,
     num_circuits: int,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> List[Tuple[cirq.Circuit, List[int]]]:
     """Generates circuits and computes their heavy set.
 
@@ -416,11 +416,6 @@ def execute_circuits(
     return results
 
 
-def _get_device_graph(device_or_qubits: Any):
-    qubits = device_or_qubits if isinstance(device_or_qubits, list) else device_or_qubits.qubits
-    return ccr.gridqubits_to_graph_device(qubits)
-
-
 def calculate_quantum_volume(
     *,
     num_qubits: int,
@@ -428,7 +423,7 @@ def calculate_quantum_volume(
     num_circuits: int,
     device_graph: nx.Graph,
     samplers: List[cirq.Sampler],
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None,
     repetitions=10_000,
     routing_attempts=30,

cirq/contrib/quantum_volume/quantum_volume_test.py

@@ -1,10 +1,12 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 """Tests for the Quantum Volume utilities."""
 
-from unittest.mock import Mock, MagicMock
 import io
+from unittest.mock import MagicMock, Mock
+
 import numpy as np
 import pytest
+
 import cirq
 import cirq.contrib.routing as ccr
 from cirq.contrib.quantum_volume import CompilationResult

cirq/contrib/quimb/__init__.py

@@ -1,23 +1,26 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 from cirq.contrib.quimb.state_vector import (
-    circuit_for_expectation_value,
-    tensor_expectation_value,
-    circuit_to_tensors,
-    tensor_state_vector,
-    tensor_unitary,
+    circuit_for_expectation_value as circuit_for_expectation_value,
+    tensor_expectation_value as tensor_expectation_value,
+    circuit_to_tensors as circuit_to_tensors,
+    tensor_state_vector as tensor_state_vector,
+    tensor_unitary as tensor_unitary,
 )
 
 from cirq.contrib.quimb.density_matrix import (
-    tensor_density_matrix,
-    circuit_to_density_matrix_tensors,
+    tensor_density_matrix as tensor_density_matrix,
+    circuit_to_density_matrix_tensors as circuit_to_density_matrix_tensors,
 )
 
-from cirq.contrib.quimb.grid_circuits import simplify_expectation_value_circuit, get_grid_moments
+from cirq.contrib.quimb.grid_circuits import (
+    simplify_expectation_value_circuit as simplify_expectation_value_circuit,
+    get_grid_moments as get_grid_moments,
+)
 
 from cirq.contrib.quimb.mps_simulator import (
-    MPSOptions,
-    MPSSimulator,
-    MPSSimulatorStepResult,
-    MPSState,
-    MPSTrialResult,
+    MPSOptions as MPSOptions,
+    MPSSimulator as MPSSimulator,
+    MPSSimulatorStepResult as MPSSimulatorStepResult,
+    MPSState as MPSState,
+    MPSTrialResult as MPSTrialResult,
 )

cirq/contrib/quimb/density_matrix.py

@@ -1,6 +1,6 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 from functools import lru_cache
-from typing import Sequence, Dict, Union, Tuple, List, Optional
+from typing import Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import quimb

cirq/contrib/quimb/mps_simulator.py

@@ -17,6 +17,8 @@ This is based on this paper:
 https://arxiv.org/abs/2002.07730
 """
 
+from __future__ import annotations
+
 import dataclasses
 import math
 from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
@@ -58,10 +60,10 @@ class MPSSimulator(
 
     def __init__(
         self,
-        noise: 'cirq.NOISE_MODEL_LIKE' = None,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        noise: cirq.NOISE_MODEL_LIKE = None,
+        seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
         simulation_options: MPSOptions = MPSOptions(),
-        grouping: Optional[Dict['cirq.Qid', int]] = None,
+        grouping: Optional[Dict[cirq.Qid, int]] = None,
     ):
         """Creates instance of `MPSSimulator`.
 
@@ -84,10 +86,10 @@ class MPSSimulator(
 
     def _create_partial_simulation_state(
         self,
-        initial_state: Union[int, 'MPSState'],
-        qubits: Sequence['cirq.Qid'],
-        classical_data: 'cirq.ClassicalDataStore',
-    ) -> 'MPSState':
+        initial_state: Union[int, MPSState],
+        qubits: Sequence[cirq.Qid],
+        classical_data: cirq.ClassicalDataStore,
+    ) -> MPSState:
         """Creates MPSState args for simulating the Circuit.
 
         Args:
@@ -103,7 +105,7 @@ class MPSSimulator(
             MPSState args for simulating the Circuit.
         """
         if isinstance(initial_state, MPSState):
-            return initial_state
+            return initial_state  # pragma: no cover
 
         return MPSState(
             qubits=qubits,
@@ -114,15 +116,15 @@ class MPSSimulator(
             classical_data=classical_data,
         )
 
-    def _create_step_result(self, sim_state: 'cirq.SimulationStateBase[MPSState]'):
+    def _create_step_result(self, sim_state: cirq.SimulationStateBase[MPSState]):
         return MPSSimulatorStepResult(sim_state)
 
     def _create_simulator_trial_result(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[MPSState]',
-    ) -> 'MPSTrialResult':
+        final_simulator_state: cirq.SimulationStateBase[MPSState],
+    ) -> MPSTrialResult:
         """Creates a single trial results with the measurements.
 
         Args:
@@ -144,16 +146,16 @@ class MPSTrialResult(simulator_base.SimulationTrialResultBase['MPSState']):
 
     def __init__(
         self,
-        params: 'cirq.ParamResolver',
+        params: cirq.ParamResolver,
         measurements: Dict[str, np.ndarray],
-        final_simulator_state: 'cirq.SimulationStateBase[MPSState]',
+        final_simulator_state: cirq.SimulationStateBase[MPSState],
     ) -> None:
         super().__init__(
             params=params, measurements=measurements, final_simulator_state=final_simulator_state
         )
 
     @property
-    def final_state(self) -> 'MPSState':
+    def final_state(self) -> MPSState:
         return self._get_merged_sim_state()
 
     def __str__(self) -> str:
@@ -173,7 +175,7 @@ class MPSTrialResult(simulator_base.SimulationTrialResultBase['MPSState']):
 class MPSSimulatorStepResult(simulator_base.StepResultBase['MPSState']):
     """A `StepResult` that can perform measurements."""
 
-    def __init__(self, sim_state: 'cirq.SimulationStateBase[MPSState]'):
+    def __init__(self, sim_state: cirq.SimulationStateBase[MPSState]):
         """Results of a step of the simulator.
         Attributes:
             sim_state: The qubit:SimulationState lookup for this step.
@@ -309,7 +311,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
     def _value_equality_values_(self) -> Any:
         return self._qid_shape, self._M, self._simulation_options, self._grouping
 
-    def copy(self, deep_copy_buffers: bool = True) -> '_MPSHandler':
+    def copy(self, deep_copy_buffers: bool = True) -> _MPSHandler:
         """Copies the object.
 
         Args:
@@ -460,7 +462,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
             raise ValueError('Can only handle 1 and 2 qubit operations')
         return True
 
-    def estimation_stats(self):
+    def estimation_stats(self):  # pragma: no cover
         """Returns some statistics about the memory usage and quality of the approximation."""
 
         num_coefs_used = sum([Mi.data.size for Mi in self._M])
@@ -520,7 +522,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
         return results
 
     def measure(
-        self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+        self, axes: Sequence[int], seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> List[int]:
         """Measures the MPS.
 
@@ -533,10 +535,7 @@ class _MPSHandler(qis.QuantumStateRepresentation):
         return self._measure(axes, value.parse_random_state(seed))
 
     def sample(
-        self,
-        axes: Sequence[int],
-        repetitions: int = 1,
-        seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        self, axes: Sequence[int], repetitions: int = 1, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None
     ) -> np.ndarray:
         """Samples the MPS.
 
@@ -564,12 +563,12 @@ class MPSState(SimulationState[_MPSHandler]):
     def __init__(
         self,
         *,
-        qubits: Sequence['cirq.Qid'],
+        qubits: Sequence[cirq.Qid],
         prng: np.random.RandomState,
         simulation_options: MPSOptions = MPSOptions(),
-        grouping: Optional[Dict['cirq.Qid', int]] = None,
+        grouping: Optional[Dict[cirq.Qid, int]] = None,
         initial_state: int = 0,
-        classical_data: Optional['cirq.ClassicalDataStore'] = None,
+        classical_data: Optional[cirq.ClassicalDataStore] = None,
     ):
         """Creates and MPSState
 
@@ -623,7 +622,7 @@ class MPSState(SimulationState[_MPSHandler]):
         """
         return self._state.state_vector()
 
-    def partial_trace(self, keep_qubits: Set['cirq.Qid']) -> np.ndarray:
+    def partial_trace(self, keep_qubits: Set[cirq.Qid]) -> np.ndarray:
         """Traces out all qubits except keep_qubits.
 
         Args:
@@ -642,7 +641,7 @@ class MPSState(SimulationState[_MPSHandler]):
         return self._state.to_numpy()
 
     def _act_on_fallback_(
-        self, action: Any, qubits: Sequence['cirq.Qid'], allow_decompose: bool = True
+        self, action: Any, qubits: Sequence[cirq.Qid], allow_decompose: bool = True
     ) -> bool:
         """Delegates the action to self.apply_op"""
         return self._state.apply_op(action, self.get_axes(qubits), self.prng)

cirq/contrib/quimb/mps_simulator_test.py

@@ -479,6 +479,11 @@ def test_simulation_state_initializer():
     )
     assert s.qubits == (cirq.LineQubit(0),)
     assert s.classical_data == expected_classical_data
+    assert s.estimation_stats() == {
+        'estimated_fidelity': 1.0,
+        'memory_bytes': 16,
+        'num_coefs_used': 2,
+    }
 
 
 def test_act_on_gate():

cirq/contrib/quimb/state_vector.py

@@ -1,6 +1,6 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 import warnings
-from typing import cast, Sequence, Union, List, Tuple, Dict, Optional
+from typing import cast, Dict, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
 import quimb
@@ -170,15 +170,8 @@ def tensor_expectation_value(
         )
     else:
         tn.rank_simplify(inplace=True)
-    # TODO(#6586): revert when our minimum quimb version has bugfix for quimb#231
-    # Skip path-info evaluation when TensorNetwork consists of scalar Tensors.
-    # Avoid bug in quimb-1.8.0.
-    # Ref: https://github.com/jcmgray/quimb/issues/231
-    if tn.ind_map:
-        path_info = tn.contract(get='path-info')
-        ram_gb = path_info.largest_intermediate * 128 / 8 / 1024 / 1024 / 1024
-    else:
-        ram_gb = 0
+    path_info = tn.contract(get='path-info')
+    ram_gb = path_info.largest_intermediate * 128 / 8 / 1024 / 1024 / 1024
     if ram_gb > max_ram_gb:
         raise MemoryError(f"We estimate that this contraction will take too much RAM! {ram_gb} GB")
     e_val = tn.contract(inplace=True)

cirq/contrib/quirk/__init__.py

@@ -14,4 +14,4 @@
 
 """Converts cirq circuits into quirk circuits."""
 
-from cirq.contrib.quirk.export_to_quirk import circuit_to_quirk_url
+from cirq.contrib.quirk.export_to_quirk import circuit_to_quirk_url as circuit_to_quirk_url

cirq/contrib/quirk/export_to_quirk.py

@@ -14,15 +14,15 @@
 
 import json
 import urllib.parse
-from typing import List, cast, Tuple, Any, Iterable
+from typing import Any, cast, Iterable, List, Tuple
 
-from cirq import ops, circuits, devices, protocols
+from cirq import circuits, devices, ops, protocols
 from cirq.contrib.quirk.linearize_circuit import linearize_circuit_qubits
 from cirq.contrib.quirk.quirk_gate import (
     known_quirk_op_for_operation,
     QuirkOp,
-    UNKNOWN_GATE,
     single_qubit_matrix_gate,
+    UNKNOWN_GATE,
 )
 
 

cirq/contrib/routing/__init__.py

@@ -14,15 +14,18 @@
 """Utilities for routing circuits on devices"""
 
 from cirq.contrib.routing.device import (
-    get_linear_device_graph,
-    get_grid_device_graph,
-    gridqubits_to_graph_device,
-    nx_qubit_layout,
+    get_linear_device_graph as get_linear_device_graph,
+    get_grid_device_graph as get_grid_device_graph,
+    gridqubits_to_graph_device as gridqubits_to_graph_device,
+    nx_qubit_layout as nx_qubit_layout,
 )
-from cirq.contrib.routing.router import route_circuit, ROUTERS
-from cirq.contrib.routing.swap_network import SwapNetwork
+
+from cirq.contrib.routing.router import route_circuit as route_circuit, ROUTERS as ROUTERS
+
+from cirq.contrib.routing.swap_network import SwapNetwork as SwapNetwork
+
 from cirq.contrib.routing.utils import (
-    get_circuit_connectivity,
-    is_valid_routing,
-    ops_are_consistent_with_device_graph,
+    get_circuit_connectivity as get_circuit_connectivity,
+    is_valid_routing as is_valid_routing,
+    ops_are_consistent_with_device_graph as ops_are_consistent_with_device_graph,
 )

cirq/contrib/routing/device.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import itertools
-from typing import Iterable, Tuple, Dict
+from typing import Dict, Iterable, Tuple
 
 import networkx as nx
 

cirq/contrib/routing/device_test.py

@@ -12,9 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
-
 import networkx as nx
+import pytest
 
 import cirq
 import cirq.contrib.routing as ccr

cirq/contrib/routing/greedy.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 typing import (
     Callable,
@@ -26,11 +28,11 @@ from typing import (
     TYPE_CHECKING,
 )
 
-import numpy as np
 import networkx as nx
+import numpy as np
 
-from cirq import circuits, ops, value
 import cirq.contrib.acquaintance as cca
+from cirq import circuits, ops, value
 from cirq.contrib import circuitdag
 from cirq.contrib.routing.initialization import get_initial_mapping
 from cirq.contrib.routing.swap_network import SwapNetwork
@@ -109,7 +111,7 @@ class _GreedyRouter:
             op1.qubits
         )
         & set(op2.qubits),
-        random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+        random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
     ):
 
         self.prng = value.parse_random_state(random_state)
@@ -148,12 +150,12 @@ class _GreedyRouter:
             ]
         return self.edge_sets[edge_set_size]
 
-    def log_to_phys(self, *qubits: 'cirq.Qid') -> Iterable[ops.Qid]:
+    def log_to_phys(self, *qubits: cirq.Qid) -> Iterable[ops.Qid]:
         """Returns an iterator over the physical qubits mapped to by the given
         logical qubits."""
         return (self._log_to_phys[q] for q in qubits)
 
-    def phys_to_log(self, *qubits: 'cirq.Qid') -> Iterable[Optional[ops.Qid]]:
+    def phys_to_log(self, *qubits: cirq.Qid) -> Iterable[Optional[ops.Qid]]:
         """Returns an iterator over the logical qubits that map to the given
         physical qubits."""
         return (self._phys_to_log[q] for q in qubits)

cirq/contrib/routing/greedy_test.py

@@ -45,15 +45,17 @@ def create_circuit_and_device():
 
 def create_hanging_routing_instance(circuit, device_graph):
     """Create a test problem instance."""
-    route_circuit_greedily(circuit, device_graph, max_search_radius=2, random_state=1)
+    route_circuit_greedily(  # pragma: no cover
+        circuit, device_graph, max_search_radius=2, random_state=1
+    )
 
 
 def test_router_hanging():
-    """Run a separate process and check if greedy router hits timeout (5s)."""
+    """Run a separate process and check if greedy router hits timeout (20s)."""
     circuit, device_graph = create_circuit_and_device()
     process = Process(target=create_hanging_routing_instance, args=[circuit, device_graph])
     process.start()
-    process.join(timeout=5)
+    process.join(timeout=20)
     try:
         assert not process.is_alive(), "Greedy router timeout"
     finally:

cirq/contrib/routing/initialization.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 typing import cast, Dict, Hashable, TYPE_CHECKING
 
@@ -32,7 +34,7 @@ def get_center(graph: nx.Graph) -> Hashable:
 def get_initial_mapping(
     logical_graph: nx.Graph,
     device_graph: nx.Graph,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> Dict[ops.Qid, ops.Qid]:
     """Gets an initial mapping of logical to physical qubits for routing.
 

cirq/contrib/routing/initialization_test.py

@@ -14,9 +14,9 @@
 
 import random
 
+import networkx as nx
 import numpy as np
 import pytest
-import networkx as nx
 
 import cirq
 import cirq.contrib.routing as ccr