cirq-core 1.7.0.dev20250807224154__py3-none-any.whl → 1.7.0.dev20250812021254__py3-none-any.whl

cirq/contrib/routing/device_test.py

@@ -22,33 +22,35 @@ import cirq.contrib.routing as ccr
 
 
 @pytest.mark.parametrize('n_qubits', (2, 5, 11))
-def test_get_linear_device_graph(n_qubits):
+def test_get_linear_device_graph(n_qubits) -> None:
     graph = ccr.get_linear_device_graph(n_qubits)
     assert sorted(graph) == cirq.LineQubit.range(n_qubits)
     assert len(graph.edges()) == n_qubits - 1
     assert all(abs(a.x - b.x) == 1 for a, b in graph.edges())
 
 
-def test_nx_qubit_layout():
+def test_nx_qubit_layout() -> None:
     grid_qubit_graph = ccr.gridqubits_to_graph_device(cirq.GridQubit.rect(5, 5))
     pos = ccr.nx_qubit_layout(grid_qubit_graph)
     assert len(pos) == len(grid_qubit_graph)
     for k, (x, y) in pos.items():
+        assert isinstance(k, cirq.GridQubit)
         assert x == k.col
         assert y == -k.row
 
 
-def test_nx_qubit_layout_2():
+def test_nx_qubit_layout_2() -> None:
     g = nx.from_edgelist(
         [(cirq.LineQubit(0), cirq.LineQubit(1)), (cirq.LineQubit(1), cirq.LineQubit(2))]
     )
     pos = ccr.nx_qubit_layout(g)
     for k, (x, y) in pos.items():
+        assert isinstance(k, cirq.LineQubit)
         assert x == k.x
         assert y == 0.5
 
 
-def test_nx_qubit_layout_3():
+def test_nx_qubit_layout_3() -> None:
     g = nx.from_edgelist(
         [(cirq.NamedQubit('a'), cirq.NamedQubit('b')), (cirq.NamedQubit('b'), cirq.NamedQubit('c'))]
     )
@@ -57,4 +59,4 @@ def test_nx_qubit_layout_3():
     pos = ccr.nx_qubit_layout(g)
     for k, (x, y) in pos.items():
         assert x == 0.5
-        assert y == node_to_i[k] + 1
+        assert y == node_to_i[k] + 1  # type: ignore[index]

cirq/contrib/routing/greedy_test.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 from multiprocessing import Process
+from typing import TYPE_CHECKING
 
 import pytest
 
@@ -22,6 +23,9 @@ import cirq
 import cirq.contrib.routing as ccr
 from cirq.contrib.routing.greedy import route_circuit_greedily
 
+if TYPE_CHECKING:
+    import networkx as nx
+
 
 def test_bad_args() -> None:
     """Test zero valued arguments in greedy router."""
@@ -34,18 +38,19 @@ def test_bad_args() -> None:
         route_circuit_greedily(circuit, device_graph, max_num_empty_steps=0)
 
 
-def create_circuit_and_device():
+def create_circuit_and_device() -> tuple[cirq.Circuit, nx.Graph]:
     """Construct a small circuit and a device with line connectivity
     to test the greedy router. This instance hangs router in Cirq 8.2.
     """
     num_qubits = 6
+    gate_domain: dict[cirq.Gate, int]
     gate_domain = {cirq.ops.CNOT: 2}
     circuit = cirq.testing.random_circuit(num_qubits, 15, 0.5, gate_domain, random_state=37)
     device_graph = ccr.get_linear_device_graph(num_qubits)
     return circuit, device_graph
 
 
-def create_hanging_routing_instance(circuit, device_graph):
+def create_hanging_routing_instance(circuit, device_graph) -> None:
     """Create a test problem instance."""
     route_circuit_greedily(  # pragma: no cover
         circuit, device_graph, max_search_radius=2, random_state=1

cirq/contrib/routing/initialization_test.py

@@ -24,7 +24,7 @@ import cirq
 import cirq.contrib.routing as ccr
 
 
-def get_seeded_initial_mapping(graph_seed, init_seed):
+def get_seeded_initial_mapping(graph_seed, init_seed) -> dict[cirq.Qid, cirq.Qid]:
     logical_graph = nx.erdos_renyi_graph(10, 0.5, seed=graph_seed)
     logical_graph = nx.relabel_nodes(logical_graph, cirq.LineQubit)
     device_graph = ccr.get_grid_device_graph(4, 4)

cirq/contrib/routing/router_test.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import itertools
 import random
 
 import numpy as np
@@ -25,7 +24,7 @@ import cirq.contrib.acquaintance as cca
 import cirq.contrib.routing as ccr
 
 
-def random_seed():
+def random_seed() -> int:
     return random.randint(0, 2**32)
 
 
@@ -35,7 +34,7 @@ def random_seed():
     + [(0, 'greedy', random_seed(), random_seed())]
     + [(10, 'greedy', random_seed(), None)],
 )
-def test_route_circuit(n_moments, algo, circuit_seed, routing_seed):
+def test_route_circuit(n_moments, algo, circuit_seed, routing_seed) -> None:
     circuit = cirq.testing.random_circuit(10, n_moments, 0.5, random_state=circuit_seed)
     device_graph = ccr.get_grid_device_graph(4, 3)
     swap_network = ccr.route_circuit(
@@ -52,15 +51,15 @@ def test_route_circuit(n_moments, algo, circuit_seed, routing_seed):
 @pytest.mark.parametrize(
     'algo,seed', [(algo, random_seed()) for algo in ccr.ROUTERS for _ in range(3)]
 )
-def test_route_circuit_reproducible_with_seed(algo, seed):
+def test_route_circuit_reproducible_with_seed(algo, seed) -> None:
     circuit = cirq.testing.random_circuit(8, 20, 0.5, random_state=seed)
     device_graph = ccr.get_grid_device_graph(4, 3)
-    wrappers = (lambda s: s, np.random.RandomState)
+    random_states = [seed, seed, seed] + [np.random.RandomState(seed) for _ in range(3)]
 
     swap_networks = []
-    for wrapper, _ in itertools.product(wrappers, range(3)):
+    for random_state in random_states:
         swap_network = ccr.route_circuit(
-            circuit, device_graph, algo_name=algo, random_state=wrapper(seed)
+            circuit, device_graph, algo_name=algo, random_state=random_state
         )
         swap_networks.append(swap_network)
 
@@ -69,7 +68,7 @@ def test_route_circuit_reproducible_with_seed(algo, seed):
 
 
 @pytest.mark.parametrize('algo', ccr.ROUTERS.keys())
-def test_route_circuit_reproducible_between_runs(algo):
+def test_route_circuit_reproducible_between_runs(algo) -> None:
     seed = 23
     circuit = cirq.testing.random_circuit(6, 5, 0.5, random_state=seed)
     device_graph = ccr.get_grid_device_graph(2, 3)
@@ -106,7 +105,7 @@ def test_route_circuit_reproducible_between_runs(algo):
     ]
     + [(0, 'greedy', random_seed(), False)],
 )
-def test_route_circuit_via_unitaries(n_moments, algo, seed, make_bad):
+def test_route_circuit_via_unitaries(n_moments, algo, seed, make_bad) -> None:
     circuit = cirq.testing.random_circuit(4, n_moments, 0.5, random_state=seed)
     device_graph = ccr.get_grid_device_graph(3, 2)
 
@@ -132,7 +131,7 @@ def test_route_circuit_via_unitaries(n_moments, algo, seed, make_bad):
     assert np.allclose(physical_unitary, logical_unitary) == (not make_bad)
 
 
-def test_router_bad_args():
+def test_router_bad_args() -> None:
     circuit = cirq.Circuit()
     device_graph = ccr.get_linear_device_graph(5)
     with pytest.raises(ValueError):

cirq/contrib/routing/swap_network_test.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import itertools
+from typing import Any
 
 import pytest
 
@@ -23,9 +24,10 @@ import cirq.contrib.acquaintance as cca
 import cirq.contrib.routing as ccr
 
 
-def test_final_mapping():
+def test_final_mapping() -> None:
     n_qubits = 10
     qubits = cirq.LineQubit.range(n_qubits)
+    initial_mapping: dict[cirq.Qid, cirq.Qid]
     initial_mapping = dict(zip(qubits, qubits))
     expected_final_mapping = dict(zip(qubits, reversed(qubits)))
     SWAP = cca.SwapPermutationGate()
@@ -37,10 +39,11 @@ def test_final_mapping():
     assert swap_network.final_mapping() == expected_final_mapping
 
 
-def test_swap_network_bad_args():
+def test_swap_network_bad_args() -> None:
     n_qubits = 10
     qubits = cirq.LineQubit.range(n_qubits)
     circuit = cirq.Circuit()
+    initial_mapping: dict[Any, Any]
     with pytest.raises(ValueError):
         initial_mapping = dict(zip(qubits, range(n_qubits)))
         ccr.SwapNetwork(circuit, initial_mapping)
@@ -50,7 +53,8 @@ def test_swap_network_bad_args():
 
 
 @pytest.mark.parametrize('circuits', [[cirq.testing.random_circuit(10, 10, 0.5) for _ in range(3)]])
-def test_swap_network_equality(circuits):
+def test_swap_network_equality(circuits) -> None:
+    mapping: dict[cirq.Qid, cirq.Qid]
     et = cirq.testing.EqualsTester()
     for circuit in circuits:  # NB: tiny prob. that circuits aren't unique
         qubits = sorted(circuit.all_qubits())
@@ -59,11 +63,13 @@ def test_swap_network_equality(circuits):
             et.add_equality_group(ccr.SwapNetwork(circuit, mapping))
 
 
-def test_swap_network_str():
+def test_swap_network_str() -> None:
     n_qubits = 5
     phys_qubits = cirq.GridQubit.rect(n_qubits, 1)
     log_qubits = cirq.LineQubit.range(n_qubits)
 
+    gates: dict[tuple[cirq.Qid, cirq.Qid], cirq.Gate]
+    initial_mapping: dict[cirq.Qid, cirq.Qid]
     gates = {(l, ll): cirq.ZZ for l, ll in itertools.combinations(log_qubits, 2)}
     initial_mapping = {p: l for p, l in zip(phys_qubits, log_qubits)}
     execution_strategy = cca.GreedyExecutionStrategy(gates, initial_mapping)

cirq/contrib/routing/utils_test.py

@@ -21,7 +21,7 @@ import cirq
 import cirq.contrib.routing as ccr
 
 
-def test_ops_are_consistent_with_device_graph():
+def test_ops_are_consistent_with_device_graph() -> None:
     device_graph = ccr.get_linear_device_graph(3)
     qubits = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(cirq.ZZ(qubits[0], qubits[2]))
@@ -31,7 +31,7 @@ def test_ops_are_consistent_with_device_graph():
     )
 
 
-def test_get_circuit_connectivity():
+def test_get_circuit_connectivity() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     circuit = cirq.Circuit(cirq.CZ(a, b), cirq.CZ(b, c), cirq.CZ(c, d), cirq.CZ(d, a))
     graph = ccr.get_circuit_connectivity(circuit)
@@ -41,12 +41,12 @@ def test_get_circuit_connectivity():
     assert is_planar
 
 
-def test_is_valid_routing_with_bad_args():
+def test_is_valid_routing_with_bad_args() -> None:
     p, q, r = cirq.LineQubit.range(3)
     x, y = cirq.NamedQubit('x'), cirq.NamedQubit('y')
     circuit = cirq.Circuit([cirq.CNOT(x, y), cirq.CZ(x, y)])
     routed_circuit = cirq.Circuit([cirq.CNOT(p, q), cirq.CZ(q, r)])
-    initial_mapping = {p: x, q: y}
+    initial_mapping: dict[cirq.Qid, cirq.Qid] = {p: x, q: y}
     swap_network = ccr.SwapNetwork(routed_circuit, initial_mapping)
     assert not ccr.is_valid_routing(circuit, swap_network)
 

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking.py

@@ -17,7 +17,7 @@
 from __future__ import annotations
 
 import time
-from typing import Optional, Sequence, TYPE_CHECKING
+from typing import Sequence, TYPE_CHECKING
 
 import attrs
 import numpy as np
@@ -64,7 +64,7 @@ class ReadoutBenchmarkingParams:
 def _validate_experiment_input(
     input_circuits: Sequence[circuits.Circuit],
     circuit_repetitions: int | list[int],
-    rng_or_seed: Optional[np.random.Generator | int] = None,
+    rng_or_seed: np.random.Generator | int | None = None,
 ):
     if not input_circuits:
         raise ValueError("Input circuits must not be empty.")
@@ -84,7 +84,7 @@ def _validate_experiment_input_with_sweep(
     input_circuits: Sequence[circuits.Circuit],
     sweep_params: Sequence[study.Sweepable],
     circuit_repetitions: int | list[int],
-    rng_or_seed: Optional[np.random.Generator | int] = None,
+    rng_or_seed: np.random.Generator | int | None = None,
 ):
     """Validates the input for the run_sweep_with_readout_benchmarking function."""
     if not sweep_params:
@@ -183,7 +183,7 @@ def _generate_all_readout_calibration_circuits(
 
 def _determine_qubits_to_measure(
     input_circuits: Sequence[circuits.Circuit],
-    qubits: Optional[Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]]],
+    qubits: Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]] | None,
 ) -> list[list[ops.Qid]]:
     """Determine the qubits to measure based on the input circuits and provided qubits."""
     # If input qubits is None, extract qubits from input circuits
@@ -280,7 +280,7 @@ def run_shuffled_with_readout_benchmarking(
     rng_or_seed: np.random.Generator | int,
     num_random_bitstrings: int = 100,
     readout_repetitions: int = 1000,
-    qubits: Optional[Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]]] = None,
+    qubits: Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]] | None = None,
 ) -> tuple[Sequence[ResultDict], dict[tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult]]:
     """Run the circuits in a shuffled order with readout error benchmarking.
 
@@ -373,8 +373,8 @@ def run_shuffled_circuits_with_readout_benchmarking(
     sampler: work.Sampler,
     input_circuits: list[circuits.Circuit],
     parameters: ReadoutBenchmarkingParams,
-    qubits: Optional[Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]]] = None,
-    rng_or_seed: Optional[np.random.Generator | int] = None,
+    qubits: Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]] | None = None,
+    rng_or_seed: np.random.Generator | int | None = None,
 ) -> tuple[Sequence[ResultDict], dict[tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult]]:
     """Run the circuits in a shuffled order with readout error benchmarking.
 
@@ -458,8 +458,8 @@ def run_sweep_with_readout_benchmarking(
     input_circuits: list[circuits.Circuit],
     sweep_params: Sequence[study.Sweepable],
     parameters: ReadoutBenchmarkingParams,
-    qubits: Optional[Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]]] = None,
-    rng_or_seed: Optional[np.random.Generator | int] = None,
+    qubits: Sequence[ops.Qid] | Sequence[Sequence[ops.Qid]] | None = None,
+    rng_or_seed: np.random.Generator | int | None = None,
 ) -> tuple[
     Sequence[Sequence[study.Result]], dict[tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult]
 ]:

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking_test.py

@@ -124,7 +124,7 @@ def _circuits_with_readout_benchmarking_errors_sweep(
 
 
 @pytest.mark.parametrize("mode", ["shuffled", "sweep"])
-def test_circuits_with_readout_benchmarking_errors_no_noise(mode: str):
+def test_circuits_with_readout_benchmarking_errors_no_noise(mode: str) -> None:
     """Test shuffled/sweep circuits with readout benchmarking with no noise from sampler."""
     qubits = cirq.LineQubit.range(5)
 
@@ -166,7 +166,7 @@ def test_circuits_with_readout_benchmarking_errors_no_noise(mode: str):
 
 
 @pytest.mark.parametrize("mode", ["shuffled", "sweep"])
-def test_circuits_with_readout_benchmarking_errors_with_noise(mode: str):
+def test_circuits_with_readout_benchmarking_errors_with_noise(mode: str) -> None:
     """Test shuffled/sweep circuits with readout benchmarking with noise from sampler."""
     qubits = cirq.LineQubit.range(6)
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.2, seed=1234)
@@ -209,7 +209,7 @@ def test_circuits_with_readout_benchmarking_errors_with_noise(mode: str):
 
 
 @pytest.mark.parametrize("mode", ["shuffled", "sweep"])
-def test_circuits_with_readout_benchmarking_errors_with_noise_and_input_qubits(mode: str):
+def test_circuits_with_readout_benchmarking_errors_with_noise_and_input_qubits(mode: str) -> None:
     """Test shuffled/sweep circuits with readout benchmarking with
     noise from sampler and input qubits."""
     qubits = cirq.LineQubit.range(6)
@@ -255,7 +255,9 @@ def test_circuits_with_readout_benchmarking_errors_with_noise_and_input_qubits(m
 
 
 @pytest.mark.parametrize("mode", ["shuffled", "sweep"])
-def test_circuits_with_readout_benchmarking_errors_with_noise_and_lists_input_qubits(mode: str):
+def test_circuits_with_readout_benchmarking_errors_with_noise_and_lists_input_qubits(
+    mode: str,
+) -> None:
     """Test shuffled/sweep circuits with readout benchmarking with noise
     from sampler and input qubits."""
     qubits_1 = cirq.LineQubit.range(3)
@@ -305,7 +307,7 @@ def test_circuits_with_readout_benchmarking_errors_with_noise_and_lists_input_qu
 
 
 @pytest.mark.parametrize("mode", ["shuffled", "sweep"])
-def test_can_handle_zero_random_bitstring(mode: str):
+def test_can_handle_zero_random_bitstring(mode: str) -> None:
     """Test shuffled/sweep circuits without readout benchmarking."""
     qubits_1 = cirq.LineQubit.range(3)
     qubits_2 = cirq.LineQubit.range(4)
@@ -345,7 +347,7 @@ def test_can_handle_zero_random_bitstring(mode: str):
 
 
 @pytest.mark.parametrize("mode", ["shuffled", "sweep"])
-def test_circuits_with_readout_benchmarking_no_qubits_arg_empty_rng(mode: str):
+def test_circuits_with_readout_benchmarking_no_qubits_arg_empty_rng(mode: str) -> None:
     """Test benchmarking when the `qubits` argument is not provided."""
     qubits = cirq.LineQubit.range(3)
     sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.2, seed=1234)
@@ -389,7 +391,7 @@ def test_circuits_with_readout_benchmarking_no_qubits_arg_empty_rng(mode: str):
     assert result.repetitions == readout_repetitions
 
 
-def test_deprecated_run_shuffled_with_readout_benchmarking():
+def test_deprecated_run_shuffled_with_readout_benchmarking() -> None:
     """Test that the deprecated function works correctly and is covered."""
     qubits = cirq.LineQubit.range(3)
     input_circuits = _create_test_circuits(qubits, 3)
@@ -470,7 +472,7 @@ def test_deprecated_run_shuffled_with_readout_benchmarking():
             )
 
 
-def test_empty_input_circuits():
+def test_empty_input_circuits() -> None:
     """Test that the input circuits are empty."""
     readout_benchmarking_params = sc_readout.ReadoutBenchmarkingParams(
         circuit_repetitions=10, num_random_bitstrings=5, readout_repetitions=100
@@ -484,7 +486,7 @@ def test_empty_input_circuits():
         )
 
 
-def test_non_circuit_input():
+def test_non_circuit_input() -> None:
     """Test that the input circuits are not of type cirq.Circuit."""
     q = cirq.LineQubit(0)
     readout_benchmarking_params = sc_readout.ReadoutBenchmarkingParams(
@@ -493,13 +495,13 @@ def test_non_circuit_input():
     with pytest.raises(ValueError, match="Input circuits must be of type cirq.Circuit."):
         sc_readout.run_shuffled_circuits_with_readout_benchmarking(
             cirq.ZerosSampler(),
-            [q],
+            [q],  # type: ignore[list-item]
             readout_benchmarking_params,
             rng_or_seed=np.random.default_rng(456),
         )
 
 
-def test_no_measurements():
+def test_no_measurements() -> None:
     """Test that the input circuits don't have measurements."""
     q = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.H(q))
@@ -515,7 +517,7 @@ def test_no_measurements():
         )
 
 
-def test_zero_circuit_repetitions():
+def test_zero_circuit_repetitions() -> None:
     """Test that the circuit repetitions are zero."""
     with pytest.raises(ValueError, match="Must provide non-zero circuit_repetitions."):
         sc_readout.ReadoutBenchmarkingParams(
@@ -523,7 +525,7 @@ def test_zero_circuit_repetitions():
         )
 
 
-def test_mismatch_circuit_repetitions():
+def test_mismatch_circuit_repetitions() -> None:
     """Test that the number of circuit repetitions don't match the number of input circuits."""
     q = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
@@ -542,7 +544,7 @@ def test_mismatch_circuit_repetitions():
         )
 
 
-def test_zero_num_random_bitstrings():
+def test_zero_num_random_bitstrings() -> None:
     """Test that the number of random bitstrings is smaller than zero."""
     with pytest.raises(ValueError, match="Must provide zero or more num_random_bitstrings."):
         sc_readout.ReadoutBenchmarkingParams(
@@ -550,7 +552,7 @@ def test_zero_num_random_bitstrings():
         )
 
 
-def test_zero_readout_repetitions():
+def test_zero_readout_repetitions() -> None:
     """Test that the readout repetitions is zero."""
     with pytest.raises(
         ValueError, match="Must provide non-zero readout_repetitions for readout" + " calibration."
@@ -560,7 +562,7 @@ def test_zero_readout_repetitions():
         )
 
 
-def test_empty_sweep_params():
+def test_empty_sweep_params() -> None:
     """Test that the sweep params are empty."""
     q = cirq.LineQubit(5)
     circuit = cirq.Circuit(cirq.H(q))

cirq/contrib/svg/svg.py

@@ -15,7 +15,7 @@ FONT = matplotlib.font_manager.FontProperties()
 EMPTY_MOMENT_COLWIDTH = float(21)  # assumed default column width
 
 
-def fixup_text(text: str):
+def fixup_text(text: str) -> str:
     if '\n' in text:
         # https://github.com/quantumlib/Cirq/issues/4499
         # TODO: Visualize Custom MatrixGate

cirq/devices/grid_device_metadata_test.py

@@ -22,15 +22,15 @@ import pytest
 import cirq
 
 
-def test_griddevice_metadata():
+def test_griddevice_metadata() -> None:
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
     isolated_qubits = [cirq.GridQubit(9, 9), cirq.GridQubit(10, 10)]
     gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)
     gate_durations = {
-        cirq.GateFamily(cirq.XPowGate): 1_000,
-        cirq.GateFamily(cirq.YPowGate): 1_000,
-        cirq.GateFamily(cirq.ZPowGate): 1_000,
+        cirq.GateFamily(cirq.XPowGate): cirq.Duration(nanos=10),
+        cirq.GateFamily(cirq.YPowGate): cirq.Duration(nanos=10),
+        cirq.GateFamily(cirq.ZPowGate): cirq.Duration(nanos=10),
         # omitting cirq.CZ
     }
     target_gatesets = (cirq.CZTargetGateset(),)
@@ -65,8 +65,8 @@ def test_griddevice_metadata():
     assert metadata.compilation_target_gatesets == target_gatesets
 
 
-def test_griddevice_metadata_bad_durations():
-    qubits = tuple(cirq.GridQubit.rect(1, 2))
+def test_griddevice_metadata_bad_durations() -> None:
+    qubits: tuple[cirq.GridQubit, cirq.GridQubit] = (cirq.GridQubit(0, 0), cirq.GridQubit(0, 1))
 
     gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate)
     invalid_duration = {
@@ -77,7 +77,7 @@ def test_griddevice_metadata_bad_durations():
         cirq.GridDeviceMetadata([qubits], gateset, gate_durations=invalid_duration)
 
 
-def test_griddevice_metadata_bad_isolated():
+def test_griddevice_metadata_bad_isolated() -> None:
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
     fewer_qubits = [cirq.GridQubit(0, 0)]
@@ -86,7 +86,7 @@ def test_griddevice_metadata_bad_isolated():
         _ = cirq.GridDeviceMetadata(qubit_pairs, gateset, all_qubits=fewer_qubits)
 
 
-def test_griddevice_self_loop():
+def test_griddevice_self_loop() -> None:
     bad_pairs = [
         (cirq.GridQubit(0, 0), cirq.GridQubit(0, 0)),
         (cirq.GridQubit(1, 0), cirq.GridQubit(1, 1)),
@@ -95,7 +95,7 @@ def test_griddevice_self_loop():
         _ = cirq.GridDeviceMetadata(bad_pairs, cirq.Gateset(cirq.XPowGate))
 
 
-def test_griddevice_json_load():
+def test_griddevice_json_load() -> None:
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
     gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)
@@ -118,7 +118,7 @@ def test_griddevice_json_load():
     assert metadata == cirq.read_json(json_text=rep_str)
 
 
-def test_griddevice_json_load_with_defaults():
+def test_griddevice_json_load_with_defaults() -> None:
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
     gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)
@@ -130,7 +130,7 @@ def test_griddevice_json_load_with_defaults():
     assert metadata == cirq.read_json(json_text=rep_str)
 
 
-def test_griddevice_metadata_equality():
+def test_griddevice_metadata_equality() -> None:
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
     gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ, cirq.SQRT_ISWAP)
@@ -182,7 +182,7 @@ def test_griddevice_metadata_equality():
     assert metadata == metadata5
 
 
-def test_repr():
+def test_repr() -> None:
     qubits = cirq.GridQubit.rect(2, 3)
     qubit_pairs = [(a, b) for a in qubits for b in qubits if a != b and a.is_adjacent(b)]
     gateset = cirq.Gateset(cirq.XPowGate, cirq.YPowGate, cirq.ZPowGate, cirq.CZ)