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

cirq/devices/grid_qubit_test.py

@@ -24,18 +24,18 @@ import pytest
 import cirq
 
 
-def test_init():
+def test_init() -> None:
     q = cirq.GridQubit(3, 4)
     assert q.row == 3
     assert q.col == 4
 
-    q = cirq.GridQid(1, 2, dimension=3)
-    assert q.row == 1
-    assert q.col == 2
-    assert q.dimension == 3
+    qid = cirq.GridQid(1, 2, dimension=3)
+    assert qid.row == 1
+    assert qid.col == 2
+    assert qid.dimension == 3
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: cirq.GridQubit(0, 0), lambda: cirq.GridQid(0, 0, dimension=2))
     eq.make_equality_group(lambda: cirq.GridQubit(1, 0), lambda: cirq.GridQid(1, 0, dimension=2))
@@ -43,7 +43,7 @@ def test_eq():
     eq.make_equality_group(lambda: cirq.GridQid(0, 0, dimension=3))
 
 
-def test_grid_qubit_pickled_hash():
+def test_grid_qubit_pickled_hash() -> None:
     # Use a large number that is unlikely to be used by any other tests.
     row, col = 123456789, 2345678910
     q_bad = cirq.GridQubit(row, col)
@@ -52,7 +52,7 @@ def test_grid_qubit_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def test_grid_qid_pickled_hash():
+def test_grid_qid_pickled_hash() -> None:
     # Use a large number that is unlikely to be used by any other tests.
     row, col = 123456789, 2345678910
     q_bad = cirq.GridQid(row, col, dimension=3)
@@ -74,12 +74,12 @@ def _test_qid_pickled_hash(q: cirq.Qid, q_bad: cirq.Qid) -> None:
     assert hash(q_ok) == hash(q)
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.GridQubit(5, 2)) == 'q(5, 2)'
     assert str(cirq.GridQid(5, 2, dimension=3)) == 'q(5, 2) (d=3)'
 
 
-def test_circuit_info():
+def test_circuit_info() -> None:
     assert cirq.circuit_diagram_info(cirq.GridQubit(5, 2)) == cirq.CircuitDiagramInfo(
         wire_symbols=('(5, 2)',)
     )
@@ -88,12 +88,12 @@ def test_circuit_info():
     )
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.GridQubit(5, 2))
     cirq.testing.assert_equivalent_repr(cirq.GridQid(5, 2, dimension=3))
 
 
-def test_cmp():
+def test_cmp() -> None:
     order = cirq.testing.OrderTester()
     order.add_ascending_equivalence_group(cirq.GridQubit(0, 0), cirq.GridQid(0, 0, dimension=2))
     order.add_ascending(
@@ -110,7 +110,7 @@ def test_cmp():
     )
 
 
-def test_cmp_failure():
+def test_cmp_failure() -> None:
     with pytest.raises(TypeError, match='not supported between instances'):
         _ = 0 < cirq.GridQubit(0, 0)
     with pytest.raises(TypeError, match='not supported between instances'):
@@ -121,7 +121,7 @@ def test_cmp_failure():
         _ = cirq.GridQid(1, 1, dimension=3) < 0
 
 
-def test_is_adjacent():
+def test_is_adjacent() -> None:
     assert cirq.GridQubit(0, 0).is_adjacent(cirq.GridQubit(0, 1))
     assert cirq.GridQubit(0, 0).is_adjacent(cirq.GridQubit(0, -1))
     assert cirq.GridQubit(0, 0).is_adjacent(cirq.GridQubit(1, 0))
@@ -138,7 +138,7 @@ def test_is_adjacent():
     assert not cirq.GridQubit(500, 999).is_adjacent(cirq.GridQubit(5034, 999))
 
 
-def test_neighbors():
+def test_neighbors() -> None:
     assert cirq.GridQubit(1, 1).neighbors() == {
         cirq.GridQubit(1, 2),
         cirq.GridQubit(2, 1),
@@ -151,7 +151,7 @@ def test_neighbors():
     assert cirq.GridQubit(1, 1).neighbors(restricted_qubits) == {cirq.GridQubit(2, 1)}
 
 
-def test_square():
+def test_square() -> None:
     assert cirq.GridQubit.square(2, top=1, left=1) == [
         cirq.GridQubit(1, 1),
         cirq.GridQubit(1, 2),
@@ -179,7 +179,7 @@ def test_square():
     ]
 
 
-def test_rect():
+def test_rect() -> None:
     assert cirq.GridQubit.rect(1, 2, top=5, left=6) == [cirq.GridQubit(5, 6), cirq.GridQubit(5, 7)]
     assert cirq.GridQubit.rect(2, 2) == [
         cirq.GridQubit(0, 0),
@@ -200,7 +200,7 @@ def test_rect():
     ]
 
 
-def test_diagram():
+def test_diagram() -> None:
     s = """
 -----AB-----
 ----ABCD----
@@ -237,7 +237,7 @@ BA"""
         cirq.GridQubit.from_diagram('@')
 
 
-def test_addition_subtraction():
+def test_addition_subtraction() -> None:
     # GridQubits
     assert cirq.GridQubit(1, 2) + (2, 5) == cirq.GridQubit(3, 7)
     assert cirq.GridQubit(1, 2) + (0, 0) == cirq.GridQubit(1, 2)
@@ -276,7 +276,7 @@ def test_addition_subtraction():
 
 
 @pytest.mark.parametrize('dtype', (np.int8, np.int16, np.int32, np.int64, int))
-def test_addition_subtraction_numpy_array(dtype):
+def test_addition_subtraction_numpy_array(dtype) -> None:
     assert cirq.GridQubit(1, 2) + np.array([1, 2], dtype=dtype) == cirq.GridQubit(2, 4)
     assert cirq.GridQubit(1, 2) + np.array([0, 0], dtype=dtype) == cirq.GridQubit(1, 2)
     assert cirq.GridQubit(1, 2) + np.array([-1, 0], dtype=dtype) == cirq.GridQubit(0, 2)
@@ -306,18 +306,18 @@ def test_addition_subtraction_numpy_array(dtype):
     )
 
 
-def test_unsupported_add():
+def test_unsupported_add() -> None:
     with pytest.raises(TypeError, match='1'):
-        _ = cirq.GridQubit(1, 1) + 1
+        _ = cirq.GridQubit(1, 1) + 1  # type: ignore[operator]
     with pytest.raises(TypeError, match='(1,)'):
-        _ = cirq.GridQubit(1, 1) + (1,)
+        _ = cirq.GridQubit(1, 1) + (1,)  # type: ignore[operator]
     with pytest.raises(TypeError, match='(1, 2, 3)'):
-        _ = cirq.GridQubit(1, 1) + (1, 2, 3)
+        _ = cirq.GridQubit(1, 1) + (1, 2, 3)  # type: ignore[operator]
     with pytest.raises(TypeError, match='(1, 2.0)'):
-        _ = cirq.GridQubit(1, 1) + (1, 2.0)
+        _ = cirq.GridQubit(1, 1) + (1, 2.0)  # type: ignore[operator]
 
     with pytest.raises(TypeError, match='1'):
-        _ = cirq.GridQubit(1, 1) - 1
+        _ = cirq.GridQubit(1, 1) - 1  # type: ignore[operator]
 
     with pytest.raises(TypeError, match='[1., 2.]'):
         _ = cirq.GridQubit(1, 1) + np.array([1.0, 2.0])
@@ -325,16 +325,16 @@ def test_unsupported_add():
         _ = cirq.GridQubit(1, 1) + np.array([1, 2, 3], dtype=int)
 
 
-def test_addition_subtraction_type_error():
+def test_addition_subtraction_type_error() -> None:
     with pytest.raises(TypeError, match="bort"):
-        _ = cirq.GridQubit(5, 3) + "bort"
+        _ = cirq.GridQubit(5, 3) + "bort"  # type: ignore[operator]
     with pytest.raises(TypeError, match="bort"):
-        _ = cirq.GridQubit(5, 3) - "bort"
+        _ = cirq.GridQubit(5, 3) - "bort"  # type: ignore[operator]
 
     with pytest.raises(TypeError, match="bort"):
-        _ = cirq.GridQid(5, 3, dimension=3) + "bort"
+        _ = cirq.GridQid(5, 3, dimension=3) + "bort"  # type: ignore[operator]
     with pytest.raises(TypeError, match="bort"):
-        _ = cirq.GridQid(5, 3, dimension=3) - "bort"
+        _ = cirq.GridQid(5, 3, dimension=3) - "bort"  # type: ignore[operator]
 
     with pytest.raises(TypeError, match="Can only add GridQids with identical dimension."):
         _ = cirq.GridQid(5, 3, dimension=3) + cirq.GridQid(3, 5, dimension=4)
@@ -342,62 +342,62 @@ def test_addition_subtraction_type_error():
         _ = cirq.GridQid(5, 3, dimension=3) - cirq.GridQid(3, 5, dimension=4)
 
 
-def test_neg():
+def test_neg() -> None:
     assert -cirq.GridQubit(1, 2) == cirq.GridQubit(-1, -2)
     assert -cirq.GridQid(1, 2, dimension=3) == cirq.GridQid(-1, -2, dimension=3)
 
 
-def test_to_json():
+def test_to_json() -> None:
     assert cirq.GridQubit(5, 6)._json_dict_() == {'row': 5, 'col': 6}
 
     assert cirq.GridQid(5, 6, dimension=3)._json_dict_() == {'row': 5, 'col': 6, 'dimension': 3}
 
 
-def test_immutable():
+def test_immutable() -> None:
     # Match one of two strings. The second one is message returned since python 3.11.
     with pytest.raises(
         AttributeError,
         match="(can't set attribute)|(property 'col' of 'GridQubit' object has no setter)",
     ):
         q = cirq.GridQubit(1, 2)
-        q.col = 3
+        q.col = 3  # type: ignore[misc]
 
     with pytest.raises(
         AttributeError,
         match="(can't set attribute)|(property 'row' of 'GridQubit' object has no setter)",
     ):
         q = cirq.GridQubit(1, 2)
-        q.row = 3
+        q.row = 3  # type: ignore[misc]
 
     with pytest.raises(
         AttributeError,
         match="(can't set attribute)|(property 'col' of 'GridQid' object has no setter)",
     ):
-        q = cirq.GridQid(1, 2, dimension=3)
-        q.col = 3
+        qid = cirq.GridQid(1, 2, dimension=3)
+        qid.col = 3  # type: ignore[misc]
 
     with pytest.raises(
         AttributeError,
         match="(can't set attribute)|(property 'row' of 'GridQid' object has no setter)",
     ):
-        q = cirq.GridQid(1, 2, dimension=3)
-        q.row = 3
+        qid = cirq.GridQid(1, 2, dimension=3)
+        qid.row = 3  # type: ignore[misc]
 
     with pytest.raises(
         AttributeError,
         match="(can't set attribute)|(property 'dimension' of 'GridQid' object has no setter)",
     ):
-        q = cirq.GridQid(1, 2, dimension=3)
-        q.dimension = 3
+        qid = cirq.GridQid(1, 2, dimension=3)
+        qid.dimension = 3  # type: ignore[misc]
 
 
-def test_complex():
+def test_complex() -> None:
     assert complex(cirq.GridQubit(row=1, col=2)) == 2 + 1j
     assert isinstance(complex(cirq.GridQubit(row=1, col=2)), complex)
 
 
 @pytest.mark.parametrize('dtype', (np.int8, np.int64, float, np.float64))
-def test_numpy_index(dtype):
+def test_numpy_index(dtype) -> None:
     np5, np6, np3 = [dtype(i) for i in [5, 6, 3]]
     q = cirq.GridQubit(np5, np6)
     assert hash(q) == hash(cirq.GridQubit(5, 6))
@@ -406,19 +406,19 @@ def test_numpy_index(dtype):
     assert q.dimension == 2
     assert isinstance(q.dimension, int)
 
-    q = cirq.GridQid(np5, np6, dimension=np3)
-    assert hash(q) == hash(cirq.GridQid(5, 6, dimension=3))
-    assert q.row == 5
-    assert q.col == 6
-    assert q.dimension == 3
-    assert isinstance(q.dimension, int)
+    qid = cirq.GridQid(np5, np6, dimension=np3)
+    assert hash(qid) == hash(cirq.GridQid(5, 6, dimension=3))
+    assert qid.row == 5
+    assert qid.col == 6
+    assert qid.dimension == 3
+    assert isinstance(qid.dimension, int)
 
 
 @pytest.mark.parametrize('dtype', (float, np.float64))
-def test_non_integer_index(dtype):
+def test_non_integer_index(dtype) -> None:
     # Not supported type-wise, but is used in practice, so behavior needs to be preserved.
     q = cirq.GridQubit(dtype(5.5), dtype(6.5))
-    assert hash(q) == hash(cirq.GridQubit(5.5, 6.5))
+    assert hash(q) == hash(cirq.GridQubit(5.5, 6.5))  # type: ignore[arg-type]
     assert q.row == 5.5
     assert q.col == 6.5
     assert isinstance(q.row, dtype)

cirq/devices/line_qubit_test.py

@@ -21,16 +21,16 @@ import cirq
 from cirq.devices.grid_qubit_test import _test_qid_pickled_hash
 
 
-def test_init():
+def test_init() -> None:
     q = cirq.LineQubit(1)
     assert q.x == 1
 
-    q = cirq.LineQid(1, dimension=3)
-    assert q.x == 1
-    assert q.dimension == 3
+    qid = cirq.LineQid(1, dimension=3)
+    assert qid.x == 1
+    assert qid.dimension == 3
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: cirq.LineQubit(1), lambda: cirq.LineQid(1, dimension=2))
     eq.add_equality_group(cirq.LineQubit(2))
@@ -38,17 +38,17 @@ def test_eq():
     eq.add_equality_group(cirq.LineQid(1, dimension=3))
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.LineQubit(5)) == 'q(5)'
     assert str(cirq.LineQid(5, dimension=3)) == 'q(5) (d=3)'
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.LineQubit(5))
     cirq.testing.assert_equivalent_repr(cirq.LineQid(5, dimension=3))
 
 
-def test_cmp():
+def test_cmp() -> None:
     order = cirq.testing.OrderTester()
     order.add_ascending_equivalence_group(cirq.LineQubit(0), cirq.LineQid(0, 2))
     order.add_ascending(
@@ -60,7 +60,7 @@ def test_cmp():
     )
 
 
-def test_cmp_failure():
+def test_cmp_failure() -> None:
     with pytest.raises(TypeError, match='not supported between instances'):
         _ = 0 < cirq.LineQubit(1)
     with pytest.raises(TypeError, match='not supported between instances'):
@@ -71,7 +71,7 @@ def test_cmp_failure():
         _ = cirq.LineQid(1, 3) < 0
 
 
-def test_line_qubit_pickled_hash():
+def test_line_qubit_pickled_hash() -> None:
     # Use a large number that is unlikely to be used by any other tests.
     x = 1234567891011
     q_bad = cirq.LineQubit(x)
@@ -80,7 +80,7 @@ def test_line_qubit_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def test_line_qid_pickled_hash():
+def test_line_qid_pickled_hash() -> None:
     # Use a large number that is unlikely to be used by any other tests.
     x = 1234567891011
     q_bad = cirq.LineQid(x, dimension=3)
@@ -89,7 +89,7 @@ def test_line_qid_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def test_is_adjacent():
+def test_is_adjacent() -> None:
     assert cirq.LineQubit(1).is_adjacent(cirq.LineQubit(2))
     assert cirq.LineQubit(1).is_adjacent(cirq.LineQubit(0))
     assert cirq.LineQubit(2).is_adjacent(cirq.LineQubit(3))
@@ -100,13 +100,13 @@ def test_is_adjacent():
     assert not cirq.LineQubit(2).is_adjacent(cirq.LineQid(0, 3))
 
 
-def test_neighborhood():
+def test_neighborhood() -> None:
     assert cirq.LineQubit(1).neighbors() == {cirq.LineQubit(0), cirq.LineQubit(2)}
     restricted_qubits = [cirq.LineQubit(2), cirq.LineQubit(3)]
     assert cirq.LineQubit(1).neighbors(restricted_qubits) == {cirq.LineQubit(2)}
 
 
-def test_range():
+def test_range() -> None:
     assert cirq.LineQubit.range(0) == []
     assert cirq.LineQubit.range(1) == [cirq.LineQubit(0)]
     assert cirq.LineQubit.range(2) == [cirq.LineQubit(0), cirq.LineQubit(1)]
@@ -127,7 +127,7 @@ def test_range():
     assert cirq.LineQubit.range(1, 5, 2) == [cirq.LineQubit(1), cirq.LineQubit(3)]
 
 
-def test_qid_range():
+def test_qid_range() -> None:
     assert cirq.LineQid.range(0, dimension=3) == []
     assert cirq.LineQid.range(1, dimension=3) == [cirq.LineQid(0, 3)]
     assert cirq.LineQid.range(2, dimension=3) == [cirq.LineQid(0, 3), cirq.LineQid(1, 3)]
@@ -152,7 +152,7 @@ def test_qid_range():
     assert cirq.LineQid.range(1, 5, 2, dimension=2) == [cirq.LineQid(1, 2), cirq.LineQid(3, 2)]
 
 
-def test_for_qid_shape():
+def test_for_qid_shape() -> None:
     assert cirq.LineQid.for_qid_shape(()) == []
     assert cirq.LineQid.for_qid_shape((4, 2, 3, 1)) == [
         cirq.LineQid(0, 4),
@@ -180,7 +180,7 @@ def test_for_qid_shape():
     ]
 
 
-def test_addition_subtraction():
+def test_addition_subtraction() -> None:
     assert cirq.LineQubit(1) + 2 == cirq.LineQubit(3)
     assert cirq.LineQubit(3) - 1 == cirq.LineQubit(2)
     assert 1 + cirq.LineQubit(4) == cirq.LineQubit(5)
@@ -199,16 +199,16 @@ def test_addition_subtraction():
     )
 
 
-def test_addition_subtraction_type_error():
+def test_addition_subtraction_type_error() -> None:
     with pytest.raises(TypeError, match='dave'):
-        _ = cirq.LineQubit(1) + 'dave'
+        _ = cirq.LineQubit(1) + 'dave'  # type: ignore[operator]
     with pytest.raises(TypeError, match='dave'):
-        _ = cirq.LineQubit(1) - 'dave'
+        _ = cirq.LineQubit(1) - 'dave'  # type: ignore[operator]
 
     with pytest.raises(TypeError, match='dave'):
-        _ = cirq.LineQid(1, 3) + 'dave'
+        _ = cirq.LineQid(1, 3) + 'dave'  # type: ignore[operator]
     with pytest.raises(TypeError, match='dave'):
-        _ = cirq.LineQid(1, 3) - 'dave'
+        _ = cirq.LineQid(1, 3) - 'dave'  # type: ignore[operator]
 
     with pytest.raises(TypeError, match="Can only add LineQids with identical dimension."):
         _ = cirq.LineQid(5, dimension=3) + cirq.LineQid(3, dimension=4)
@@ -217,17 +217,17 @@ def test_addition_subtraction_type_error():
         _ = cirq.LineQid(5, dimension=3) - cirq.LineQid(3, dimension=4)
 
 
-def test_neg():
+def test_neg() -> None:
     assert -cirq.LineQubit(1) == cirq.LineQubit(-1)
     assert -cirq.LineQid(1, dimension=3) == cirq.LineQid(-1, dimension=3)
 
 
-def test_json_dict():
+def test_json_dict() -> None:
     assert cirq.LineQubit(5)._json_dict_() == {'x': 5}
     assert cirq.LineQid(5, 3)._json_dict_() == {'x': 5, 'dimension': 3}
 
 
-def test_for_gate():
+def test_for_gate() -> None:
     class NoQidGate:
         def _qid_shape_(self):
             return ()
@@ -263,24 +263,24 @@ def test_for_gate():
     ]
 
 
-def test_immutable():
+def test_immutable() -> None:
     # Match one of two strings. The second one is message returned since python 3.11.
     with pytest.raises(
         AttributeError,
         match="(can't set attribute)|(property 'x' of 'LineQubit' object has no setter)",
     ):
         q = cirq.LineQubit(5)
-        q.x = 6
+        q.x = 6  # type: ignore[misc]
 
     with pytest.raises(
         AttributeError,
         match="(can't set attribute)|(property 'x' of 'LineQid' object has no setter)",
     ):
-        q = cirq.LineQid(5, dimension=4)
-        q.x = 6
+        qid = cirq.LineQid(5, dimension=4)
+        qid.x = 6  # type: ignore[misc]
 
 
-def test_numeric():
+def test_numeric() -> None:
     assert int(cirq.LineQubit(x=5)) == 5
     assert float(cirq.LineQubit(x=5)) == 5
     assert complex(cirq.LineQubit(x=5)) == 5 + 0j
@@ -290,7 +290,7 @@ def test_numeric():
 
 
 @pytest.mark.parametrize('dtype', (np.int8, np.int64, float, np.float64))
-def test_numpy_index(dtype):
+def test_numpy_index(dtype) -> None:
     np5 = dtype(5)
     q = cirq.LineQubit(np5)
     assert hash(q) == 5
@@ -298,15 +298,15 @@ def test_numpy_index(dtype):
     assert q.dimension == 2
     assert isinstance(q.dimension, int)
 
-    q = cirq.LineQid(np5, dtype(3))
-    hash(q)  # doesn't throw
-    assert q.x == 5
-    assert q.dimension == 3
-    assert isinstance(q.dimension, int)
+    qid = cirq.LineQid(np5, dtype(3))
+    hash(qid)  # doesn't throw
+    assert qid.x == 5
+    assert qid.dimension == 3
+    assert isinstance(qid.dimension, int)
 
 
 @pytest.mark.parametrize('dtype', (float, np.float64))
-def test_non_integer_index(dtype):
+def test_non_integer_index(dtype) -> None:
     # Not supported type-wise, but is used in practice, so behavior needs to be preserved.
     q = cirq.LineQubit(dtype(5.5))
     assert q.x == 5.5

cirq/devices/named_topologies.py

@@ -66,7 +66,7 @@ def _node_and_coordinates(
 
 def draw_gridlike(
     graph: nx.Graph, ax: plt.Axes | None = None, tilted: bool = True, **kwargs
-) -> dict[Any, tuple[int, int]]:
+) -> dict[_GRIDLIKE_NODE, tuple[int, int]]:
     """Draw a grid-like graph using Matplotlib.
 
     This wraps nx.draw_networkx to produce a matplotlib drawing of the graph. Nodes
@@ -220,7 +220,7 @@ class TiltedSquareLattice(NamedTopology):
         n_nodes += ((self.width + 1) // 2) * ((self.height + 1) // 2)
         object.__setattr__(self, 'n_nodes', n_nodes)
 
-    def draw(self, ax=None, tilted=True, **kwargs):
+    def draw(self, ax=None, tilted=True, **kwargs) -> dict[_GRIDLIKE_NODE, tuple[int, int]]:
         """Draw this graph using Matplotlib.
 
         Args:
@@ -301,7 +301,7 @@ def get_placements(
 
 def _is_valid_placement_helper(
     big_graph: nx.Graph, small_mapped: nx.Graph, small_to_big_mapping: dict
-):
+) -> bool:
     """Helper function for `is_valid_placement` that assumes the mapping of `small_graph` has
     already occurred.
 
@@ -311,7 +311,9 @@ def _is_valid_placement_helper(
     return (subgraph.nodes == small_mapped.nodes) and (subgraph.edges == small_mapped.edges)
 
 
-def is_valid_placement(big_graph: nx.Graph, small_graph: nx.Graph, small_to_big_mapping: dict):
+def is_valid_placement(
+    big_graph: nx.Graph, small_graph: nx.Graph, small_to_big_mapping: dict
+) -> bool:
     """Return whether the given placement is a valid placement of small_graph onto big_graph.
 
     This is done by making sure all the nodes and edges on the mapped version of `small_graph`
@@ -338,7 +340,7 @@ def draw_placements(
     axes: Sequence[plt.Axes] | None = None,
     tilted: bool = True,
     bad_placement_callback: Callable[[plt.Axes, int], None] | None = None,
-):
+) -> None:
     """Draw a visualization of placements from small_graph onto big_graph using Matplotlib.
 
     The entire `big_graph` will be drawn with default blue colored nodes. `small_graph` nodes

cirq/devices/named_topologies_test.py

@@ -108,7 +108,7 @@ def test_draw_gridlike(tilted) -> None:
     ax = MagicMock()
     pos = draw_gridlike(graph, tilted=tilted, ax=ax)
     ax.scatter.assert_called()
-    for (row, column), _ in pos.items():
+    for row, column in pos.keys():  # type: ignore[misc]
         assert 0 <= row < 3
         assert 0 <= column < 3
 
@@ -120,7 +120,8 @@ def test_draw_gridlike_qubits(tilted) -> None:
     ax = MagicMock()
     pos = draw_gridlike(graph, tilted=tilted, ax=ax)
     ax.scatter.assert_called()
-    for q, _ in pos.items():
+    for q in pos.keys():
+        assert isinstance(q, cirq.GridQubit)
         assert 0 <= q.row < 3
         assert 0 <= q.col < 3
 

cirq/devices/noise_model.py

@@ -235,7 +235,7 @@ class ConstantQubitNoiseModel(NoiseModel):
     def __repr__(self) -> str:
         return f'cirq.ConstantQubitNoiseModel({self.qubit_noise_gate!r})'
 
-    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]):
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         # Noise should not be appended to previously-added noise.
         if self.is_virtual_moment(moment):
             return moment

cirq/devices/noise_properties_test.py

@@ -34,7 +34,7 @@ class SampleNoiseProperties(NoiseProperties):
         self.qubits = system_qubits
         self.qubit_pairs = qubit_pairs
 
-    def build_noise_models(self):
+    def build_noise_models(self) -> list[cirq.NoiseModel]:
         add_h = InsertionNoiseModel({OpIdentifier(cirq.Gate, q): cirq.H(q) for q in self.qubits})
         add_iswap = InsertionNoiseModel(
             {OpIdentifier(cirq.Gate, *qs): cirq.ISWAP(*qs) for qs in self.qubit_pairs}

cirq/devices/noise_utils.py

@@ -48,7 +48,7 @@ class OpIdentifier:
     def _predicate(self, *args, **kwargs):
         return self._gate_family._predicate(*args, **kwargs)
 
-    def is_proper_subtype_of(self, op_id: OpIdentifier):
+    def is_proper_subtype_of(self, op_id: OpIdentifier) -> bool:
         """Returns true if this is contained within op_id, but not equal to it.
 
         If this returns true, (x in self) implies (x in op_id), but the reverse

cirq/devices/noise_utils_test.py

@@ -18,13 +18,13 @@ import cirq
 from cirq.devices.noise_utils import OpIdentifier
 
 
-def test_op_identifier():
+def test_op_identifier() -> None:
     op_id = OpIdentifier(cirq.XPowGate)
     assert cirq.X(cirq.LineQubit(1)) in op_id
     assert cirq.Rx(rads=1) in op_id
 
 
-def test_op_identifier_subtypes():
+def test_op_identifier_subtypes() -> None:
     gate_id = OpIdentifier(cirq.Gate)
     xpow_id = OpIdentifier(cirq.XPowGate)
     x_on_q0_id = OpIdentifier(cirq.XPowGate, cirq.LineQubit(0))
@@ -34,7 +34,7 @@ def test_op_identifier_subtypes():
     assert not xpow_id.is_proper_subtype_of(xpow_id)
 
 
-def test_op_id_str():
+def test_op_id_str() -> None:
     op_id = OpIdentifier(cirq.XPowGate, cirq.LineQubit(0))
     assert str(op_id) == "<class 'cirq.ops.common_gates.XPowGate'>(cirq.LineQubit(0),)"
     assert repr(op_id) == (
@@ -42,7 +42,7 @@ def test_op_id_str():
     )
 
 
-def test_op_id_swap():
+def test_op_id_swap() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     base_id = OpIdentifier(cirq.CZPowGate, q0, q1)
     swap_id = OpIdentifier(base_id.gate_type, *base_id.qubits[::-1])
@@ -52,8 +52,8 @@ def test_op_id_swap():
     assert cirq.CZ(q1, q0) in swap_id
 
 
-def test_op_id_instance():
+def test_op_id_instance() -> None:
     q0 = cirq.LineQubit.range(1)[0]
     gate = cirq.SingleQubitCliffordGate.from_xz_map((cirq.X, False), (cirq.Z, False))
-    op_id = OpIdentifier(gate, q0)
+    op_id = OpIdentifier(type(gate), q0)
     cirq.testing.assert_equivalent_repr(op_id)