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

cirq/devices/grid_qubit.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import abc
 import functools
 import weakref
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, TYPE_CHECKING, Union
+from typing import Any, Iterable, TYPE_CHECKING
 
 import numpy as np
 from typing_extensions import Self
@@ -35,7 +35,7 @@ class _BaseGridQid(ops.Qid):
     _row: int
     _col: int
     _dimension: int
-    _comp_key: Optional[Tuple[int, int]] = None
+    _comp_key: tuple[int, int] | None = None
     _hash: int
 
     def __hash__(self) -> int:
@@ -116,8 +116,16 @@ class _BaseGridQid(ops.Qid):
             and abs(self._row - other._row) + abs(self._col - other._col) == 1
         )
 
-    def neighbors(self, qids: Optional[Iterable[ops.Qid]] = None) -> Set[_BaseGridQid]:
-        """Returns qubits that are potential neighbors to this GridQid
+    def neighbors(self, qids: Iterable[ops.Qid] | None = None) -> set[_BaseGridQid]:
+        """Returns qubits that are potential neighbors to this GridQid.
+
+        Note that this returns _potential_ neighbors.  That is, if no arguments
+        are given, this returns the qubits above, below, to the right and left of
+        the Qid in the grid.  It does not take into account any hardware device
+        layout.
+
+        If you want to take into account the device layout, you must pass in the
+        device's qubit set as the `qids` parameter.
 
         Args:
             qids: optional Iterable of qubits to constrain neighbors to.
@@ -135,7 +143,7 @@ class _BaseGridQid(ops.Qid):
     def __complex__(self) -> complex:
         return self._col + 1j * self._row
 
-    def __add__(self, other: Union[Tuple[int, int], Self]) -> Self:
+    def __add__(self, other: tuple[int, int] | Self) -> Self:
         if isinstance(other, _BaseGridQid):
             if self.dimension != other.dimension:
                 raise TypeError(
@@ -154,7 +162,7 @@ class _BaseGridQid(ops.Qid):
             )
         return self._with_row_col(row=self._row + other[0], col=self._col + other[1])
 
-    def __sub__(self, other: Union[Tuple[int, int], Self]) -> Self:
+    def __sub__(self, other: tuple[int, int] | Self) -> Self:
         if isinstance(other, _BaseGridQid):
             if self.dimension != other.dimension:
                 raise TypeError(
@@ -173,10 +181,10 @@ class _BaseGridQid(ops.Qid):
             )
         return self._with_row_col(row=self._row - other[0], col=self._col - other[1])
 
-    def __radd__(self, other: Tuple[int, int]) -> Self:
+    def __radd__(self, other: tuple[int, int]) -> Self:
         return self + other
 
-    def __rsub__(self, other: Tuple[int, int]) -> Self:
+    def __rsub__(self, other: tuple[int, int]) -> Self:
         return -self + other
 
     def __neg__(self) -> Self:
@@ -204,7 +212,7 @@ class GridQid(_BaseGridQid):
 
     # Cache of existing GridQid instances, returned by __new__ if available.
     # Holds weak references so instances can still be garbage collected.
-    _cache = weakref.WeakValueDictionary[Tuple[int, int, int], 'cirq.GridQid']()
+    _cache = weakref.WeakValueDictionary[tuple[int, int, int], 'cirq.GridQid']()
 
     def __new__(cls, row: int, col: int, *, dimension: int) -> cirq.GridQid:
         """Creates a grid qid at the given row, col coordinate
@@ -233,14 +241,14 @@ class GridQid(_BaseGridQid):
         return (self._row, self._col), {"dimension": self._dimension}
 
     # avoid pickling the _hash value, attributes are already stored with __getnewargs_ex__
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         return {}
 
     def _with_row_col(self, row: int, col: int) -> GridQid:
         return GridQid(row, col, dimension=self._dimension)
 
     @staticmethod
-    def square(diameter: int, top: int = 0, left: int = 0, *, dimension: int) -> List[GridQid]:
+    def square(diameter: int, top: int = 0, left: int = 0, *, dimension: int) -> list[GridQid]:
         """Returns a square of GridQid.
 
         Args:
@@ -256,7 +264,7 @@ class GridQid(_BaseGridQid):
         return GridQid.rect(diameter, diameter, top=top, left=left, dimension=dimension)
 
     @staticmethod
-    def rect(rows: int, cols: int, top: int = 0, left: int = 0, *, dimension: int) -> List[GridQid]:
+    def rect(rows: int, cols: int, top: int = 0, left: int = 0, *, dimension: int) -> list[GridQid]:
         """Returns a rectangle of GridQid.
 
         Args:
@@ -277,7 +285,7 @@ class GridQid(_BaseGridQid):
         ]
 
     @staticmethod
-    def from_diagram(diagram: str, dimension: int) -> List[GridQid]:
+    def from_diagram(diagram: str, dimension: int) -> list[GridQid]:
         """Parse ASCII art device layout into a device.
 
         As an example, the below diagram will create a list of GridQid in a
@@ -342,7 +350,7 @@ class GridQid(_BaseGridQid):
             wire_symbols=(f"({self._row}, {self._col}) (d={self._dimension})",)
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['row', 'col', 'dimension'])
 
 
@@ -367,7 +375,7 @@ class GridQubit(_BaseGridQid):
 
     # Cache of existing GridQubit instances, returned by __new__ if available.
     # Holds weak references so instances can still be garbage collected.
-    _cache = weakref.WeakValueDictionary[Tuple[int, int], 'cirq.GridQubit']()
+    _cache = weakref.WeakValueDictionary[tuple[int, int], 'cirq.GridQubit']()
 
     def __new__(cls, row: int, col: int) -> cirq.GridQubit:
         """Creates a grid qubit at the given row, col coordinate
@@ -391,14 +399,14 @@ class GridQubit(_BaseGridQid):
         return (self._row, self._col)
 
     # avoid pickling the _hash value, attributes are already stored with __getnewargs__
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         return {}
 
     def _with_row_col(self, row: int, col: int) -> GridQubit:
         return GridQubit(row, col)
 
     @staticmethod
-    def square(diameter: int, top: int = 0, left: int = 0) -> List[GridQubit]:
+    def square(diameter: int, top: int = 0, left: int = 0) -> list[GridQubit]:
         """Returns a square of GridQubits.
 
         Args:
@@ -412,7 +420,7 @@ class GridQubit(_BaseGridQid):
         return GridQubit.rect(diameter, diameter, top=top, left=left)
 
     @staticmethod
-    def rect(rows: int, cols: int, top: int = 0, left: int = 0) -> List[GridQubit]:
+    def rect(rows: int, cols: int, top: int = 0, left: int = 0) -> list[GridQubit]:
         """Returns a rectangle of GridQubits.
 
         Args:
@@ -431,7 +439,7 @@ class GridQubit(_BaseGridQid):
         ]
 
     @staticmethod
-    def from_diagram(diagram: str) -> List[GridQubit]:
+    def from_diagram(diagram: str) -> list[GridQubit]:
         """Parse ASCII art into device layout info.
 
         As an example, the below diagram will create a list of
@@ -491,11 +499,11 @@ class GridQubit(_BaseGridQid):
     def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(wire_symbols=(f"({self._row}, {self._col})",))
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['row', 'col'])
 
 
-def _ascii_diagram_to_coords(diagram: str) -> List[Tuple[int, int]]:
+def _ascii_diagram_to_coords(diagram: str) -> list[tuple[int, int]]:
     """Parse ASCII art device layout into info about qids coordinates
 
     Args:

cirq/devices/grid_qubit_test.py

@@ -11,8 +11,11 @@
 # 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.
+
 """Tests for grid_qubit."""
 
+from __future__ import annotations
+
 import pickle
 
 import numpy as np

cirq/devices/insertion_noise_model.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
+from typing import Any, Mapping, Sequence, TYPE_CHECKING
 
 from cirq import devices
 from cirq.devices import noise_utils
@@ -44,21 +44,21 @@ class InsertionNoiseModel(devices.NoiseModel):
             with PHYSICAL_GATE_TAG.
     """
 
-    ops_added: Dict[noise_utils.OpIdentifier, cirq.Operation] = dataclasses.field(
+    ops_added: Mapping[noise_utils.OpIdentifier, cirq.Operation] = dataclasses.field(
         default_factory=dict
     )
     prepend: bool = False
     require_physical_tag: bool = True
 
     def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
-        noise_ops: List[cirq.Operation] = []
+        noise_ops: list[cirq.Operation] = []
         candidate_ops = [
             op
             for op in moment
             if (not self.require_physical_tag) or noise_utils.PHYSICAL_GATE_TAG in op.tags
         ]
         for op in candidate_ops:
-            match_id: Optional[noise_utils.OpIdentifier] = None
+            match_id: noise_utils.OpIdentifier | None = None
             candidate_ids = [op_id for op_id in self.ops_added if op in op_id]
             for op_id in candidate_ids:
                 if match_id is None or op_id.is_proper_subtype_of(match_id):
@@ -78,11 +78,11 @@ class InsertionNoiseModel(devices.NoiseModel):
     def __repr__(self) -> str:
         return (
             f'cirq.devices.InsertionNoiseModel(ops_added={self.ops_added},'
-            + f' prepend={self.prepend},'
-            + f' require_physical_tag={self.require_physical_tag})'
+            f' prepend={self.prepend},'
+            f' require_physical_tag={self.require_physical_tag})'
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'ops_added': list(self.ops_added.items()),
             'prepend': self.prepend,

cirq/devices/insertion_noise_model_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 cirq
 from cirq.devices.insertion_noise_model import InsertionNoiseModel
 from cirq.devices.noise_utils import OpIdentifier, PHYSICAL_GATE_TAG
 
 
-def test_insertion_noise():
+def test_insertion_noise() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     op_id0 = OpIdentifier(cirq.XPowGate, q0)
     op_id1 = OpIdentifier(cirq.ZPowGate, q1)
@@ -50,7 +52,7 @@ def test_insertion_noise():
     cirq.testing.assert_equivalent_repr(model)
 
 
-def test_colliding_noise_qubits():
+def test_colliding_noise_qubits() -> None:
     # Check that noise affecting other qubits doesn't cause issues.
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     op_id0 = OpIdentifier(cirq.CZPowGate)
@@ -66,7 +68,7 @@ def test_colliding_noise_qubits():
     cirq.testing.assert_equivalent_repr(model)
 
 
-def test_prepend():
+def test_prepend() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     op_id0 = OpIdentifier(cirq.XPowGate, q0)
     op_id1 = OpIdentifier(cirq.ZPowGate, q1)
@@ -81,7 +83,7 @@ def test_prepend():
     ]
 
 
-def test_require_physical_tag():
+def test_require_physical_tag() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     op_id0 = OpIdentifier(cirq.XPowGate, q0)
     op_id1 = OpIdentifier(cirq.ZPowGate, q1)
@@ -95,7 +97,7 @@ def test_require_physical_tag():
     ]
 
 
-def test_supertype_matching():
+def test_supertype_matching() -> None:
     # Demonstrate that the model applies the closest matching type
     # if multiple types match a given gate.
     q0 = cirq.LineQubit(0)

cirq/devices/line_qubit.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import abc
 import functools
 import weakref
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Set, Tuple, TYPE_CHECKING, Union
+from typing import Any, Iterable, Sequence, TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -108,7 +108,7 @@ class _BaseLineQid(ops.Qid):
         """
         return isinstance(other, _BaseLineQid) and abs(self._x - other._x) == 1
 
-    def neighbors(self, qids: Optional[Iterable[ops.Qid]] = None) -> Set[_BaseLineQid]:
+    def neighbors(self, qids: Iterable[ops.Qid] | None = None) -> set[_BaseLineQid]:
         """Returns qubits that are potential neighbors to this LineQubit
 
         Args:
@@ -120,7 +120,7 @@ class _BaseLineQid(ops.Qid):
     def _with_x(self, x: int) -> Self:
         """Returns a qubit with the same type but a different value of `x`."""
 
-    def __add__(self, other: Union[int, Self]) -> Self:
+    def __add__(self, other: int | Self) -> Self:
         if isinstance(other, _BaseLineQid):
             if self._dimension != other._dimension:
                 raise TypeError(
@@ -132,7 +132,7 @@ class _BaseLineQid(ops.Qid):
             raise TypeError(f"Can only add ints and {type(self).__name__}. Instead was {other}")
         return self._with_x(self._x + other)
 
-    def __sub__(self, other: Union[int, Self]) -> Self:
+    def __sub__(self, other: int | Self) -> Self:
         if isinstance(other, _BaseLineQid):
             if self._dimension != other._dimension:
                 raise TypeError(
@@ -184,7 +184,7 @@ class LineQid(_BaseLineQid):
 
     # Cache of existing LineQid instances, returned by __new__ if available.
     # Holds weak references so instances can still be garbage collected.
-    _cache = weakref.WeakValueDictionary[Tuple[int, int], 'cirq.LineQid']()
+    _cache = weakref.WeakValueDictionary[tuple[int, int], 'cirq.LineQid']()
 
     def __new__(cls, x: int, dimension: int) -> cirq.LineQid:
         """Initializes a line qid at the given x coordinate.
@@ -211,14 +211,14 @@ class LineQid(_BaseLineQid):
         return (self._x, self._dimension)
 
     # avoid pickling the _hash value, attributes are already stored with __getnewargs__
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         return {}
 
     def _with_x(self, x: int) -> LineQid:
         return LineQid(x, dimension=self._dimension)
 
     @staticmethod
-    def range(*range_args, dimension: int) -> List[LineQid]:
+    def range(*range_args, dimension: int) -> list[LineQid]:
         """Returns a range of line qids.
 
         Args:
@@ -232,7 +232,7 @@ class LineQid(_BaseLineQid):
         return [LineQid(i, dimension=dimension) for i in range(*range_args)]
 
     @staticmethod
-    def for_qid_shape(qid_shape: Sequence[int], start: int = 0, step: int = 1) -> List[LineQid]:
+    def for_qid_shape(qid_shape: Sequence[int], start: int = 0, step: int = 1) -> list[LineQid]:
         """Returns a range of line qids for each entry in `qid_shape` with
         matching dimension.
 
@@ -246,7 +246,7 @@ class LineQid(_BaseLineQid):
         ]
 
     @staticmethod
-    def for_gate(val: Any, start: int = 0, step: int = 1) -> List[LineQid]:
+    def for_gate(val: Any, start: int = 0, step: int = 1) -> list[LineQid]:
         """Returns a range of line qids with the same qid shape as the gate.
 
         Args:
@@ -269,7 +269,7 @@ class LineQid(_BaseLineQid):
     def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(wire_symbols=(f"{self._x} (d={self._dimension})",))
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['x', 'dimension'])
 
 
@@ -315,14 +315,14 @@ class LineQubit(_BaseLineQid):
         return (self._x,)
 
     # avoid pickling the _hash value, attributes are already stored with __getnewargs__
-    def __getstate__(self) -> Dict[str, Any]:
+    def __getstate__(self) -> dict[str, Any]:
         return {}
 
     def _with_x(self, x: int) -> LineQubit:
         return LineQubit(x)
 
     @staticmethod
-    def range(*range_args) -> List[LineQubit]:
+    def range(*range_args) -> list[LineQubit]:
         """Returns a range of line qubits.
 
         Args:
@@ -342,5 +342,5 @@ class LineQubit(_BaseLineQid):
     def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(wire_symbols=(f"{self._x}",))
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['x'])

cirq/devices/line_qubit_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 numpy as np
 import pytest
 

cirq/devices/named_topologies.py

@@ -17,18 +17,7 @@ from __future__ import annotations
 import abc
 import warnings
 from dataclasses import dataclass
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, Iterable, Sequence, TYPE_CHECKING, Union
 
 import networkx as nx
 from matplotlib import pyplot as plt
@@ -59,12 +48,12 @@ class NamedTopology(metaclass=abc.ABCMeta):
     """A networkx graph representation of the topology."""
 
 
-_GRIDLIKE_NODE = Union['cirq.GridQubit', Tuple[int, int]]
+_GRIDLIKE_NODE = Union['cirq.GridQubit', tuple[int, int]]
 
 
 def _node_and_coordinates(
     nodes: Iterable[_GRIDLIKE_NODE],
-) -> Iterable[Tuple[_GRIDLIKE_NODE, Tuple[int, int]]]:
+) -> Iterable[tuple[_GRIDLIKE_NODE, tuple[int, int]]]:
     """Yield tuples whose first element is the input node and the second is guaranteed to be a tuple
     of two integers. The input node can be a tuple of ints or a GridQubit."""
     for node in nodes:
@@ -76,8 +65,8 @@ def _node_and_coordinates(
 
 
 def draw_gridlike(
-    graph: nx.Graph, ax: Optional[plt.Axes] = None, tilted: bool = True, **kwargs
-) -> Dict[Any, Tuple[int, int]]:
+    graph: nx.Graph, ax: plt.Axes | None = None, tilted: bool = True, **kwargs
+) -> dict[Any, tuple[int, int]]:
     """Draw a grid-like graph using Matplotlib.
 
     This wraps nx.draw_networkx to produce a matplotlib drawing of the graph. Nodes
@@ -129,11 +118,11 @@ class LineTopology(NamedTopology):
         )
         object.__setattr__(self, 'graph', graph)
 
-    def nodes_as_linequbits(self) -> List[cirq.LineQubit]:
+    def nodes_as_linequbits(self) -> list[cirq.LineQubit]:
         """Get the graph nodes as cirq.LineQubit"""
         return [LineQubit(x) for x in sorted(self.graph.nodes)]
 
-    def draw(self, ax=None, tilted: bool = True, **kwargs) -> Dict[Any, Tuple[int, int]]:
+    def draw(self, ax=None, tilted: bool = True, **kwargs) -> dict[Any, tuple[int, int]]:
         """Draw this graph using Matplotlib.
 
         Args:
@@ -144,7 +133,7 @@ class LineTopology(NamedTopology):
         g2 = nx.relabel_nodes(self.graph, {n: (n, 1) for n in self.graph.nodes})
         return draw_gridlike(g2, ax=ax, tilted=tilted, **kwargs)
 
-    def nodes_to_linequbits(self, offset: int = 0) -> Dict[int, cirq.LineQubit]:
+    def nodes_to_linequbits(self, offset: int = 0) -> dict[int, cirq.LineQubit]:
         """Return a mapping from graph nodes to `cirq.LineQubit`
 
         Args:
@@ -152,7 +141,7 @@ class LineTopology(NamedTopology):
         """
         return dict(enumerate(LineQubit.range(offset, offset + self.n_nodes)))
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return dataclass_json_dict(self)
 
     def __repr__(self) -> str:
@@ -242,11 +231,11 @@ class TiltedSquareLattice(NamedTopology):
         """
         return draw_gridlike(self.graph, ax=ax, tilted=tilted, **kwargs)
 
-    def nodes_as_gridqubits(self) -> List[cirq.GridQubit]:
+    def nodes_as_gridqubits(self) -> list[cirq.GridQubit]:
         """Get the graph nodes as cirq.GridQubit"""
         return [GridQubit(r, c) for r, c in sorted(self.graph.nodes)]
 
-    def nodes_to_gridqubits(self, offset=(0, 0)) -> Dict[Tuple[int, int], cirq.GridQubit]:
+    def nodes_to_gridqubits(self, offset=(0, 0)) -> dict[tuple[int, int], cirq.GridQubit]:
         """Return a mapping from graph nodes to `cirq.GridQubit`
 
         Args:
@@ -255,7 +244,7 @@ class TiltedSquareLattice(NamedTopology):
         """
         return {(r, c): GridQubit(r, c) + offset for r, c in self.graph.nodes}
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return dataclass_json_dict(self)
 
     def __repr__(self) -> str:
@@ -264,7 +253,7 @@ class TiltedSquareLattice(NamedTopology):
 
 def get_placements(
     big_graph: nx.Graph, small_graph: nx.Graph, max_placements=100_000
-) -> List[Dict]:
+) -> list[dict]:
     """Get 'placements' mapping small_graph nodes onto those of `big_graph`.
 
     This function considers monomorphisms with a restriction: we restrict only to unique set
@@ -311,7 +300,7 @@ def get_placements(
 
 
 def _is_valid_placement_helper(
-    big_graph: nx.Graph, small_mapped: nx.Graph, small_to_big_mapping: Dict
+    big_graph: nx.Graph, small_mapped: nx.Graph, small_to_big_mapping: dict
 ):
     """Helper function for `is_valid_placement` that assumes the mapping of `small_graph` has
     already occurred.
@@ -322,7 +311,7 @@ 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):
     """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`
@@ -344,11 +333,11 @@ def is_valid_placement(big_graph: nx.Graph, small_graph: nx.Graph, small_to_big_
 def draw_placements(
     big_graph: nx.Graph,
     small_graph: nx.Graph,
-    small_to_big_mappings: Sequence[Dict],
+    small_to_big_mappings: Sequence[dict],
     max_plots: int = 20,
-    axes: Optional[Sequence[plt.Axes]] = None,
+    axes: Sequence[plt.Axes] | None = None,
     tilted: bool = True,
-    bad_placement_callback: Optional[Callable[[plt.Axes, int], None]] = None,
+    bad_placement_callback: Callable[[plt.Axes, int], None] | None = None,
 ):
     """Draw a visualization of placements from small_graph onto big_graph using Matplotlib.
 

cirq/devices/named_topologies_test.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
+
 import itertools
 from unittest.mock import MagicMock
 
@@ -29,7 +32,7 @@ from cirq import (
 
 
 @pytest.mark.parametrize('width, height', list(itertools.product([1, 2, 3, 24], repeat=2)))
-def test_tilted_square_lattice(width, height):
+def test_tilted_square_lattice(width, height) -> None:
     topo = TiltedSquareLattice(width, height)
     assert topo.graph.number_of_edges() == width * height
     assert all(1 <= topo.graph.degree[node] <= 4 for node in topo.graph.nodes)
@@ -41,14 +44,14 @@ def test_tilted_square_lattice(width, height):
     cirq.testing.assert_equivalent_repr(topo)
 
 
-def test_bad_tilted_square_lattice():
+def test_bad_tilted_square_lattice() -> None:
     with pytest.raises(ValueError):
         _ = TiltedSquareLattice(0, 3)
     with pytest.raises(ValueError):
         _ = TiltedSquareLattice(3, 0)
 
 
-def test_tilted_square_methods():
+def test_tilted_square_methods() -> None:
     topo = TiltedSquareLattice(5, 5)
     ax = MagicMock()
     topo.draw(ax=ax)
@@ -63,13 +66,13 @@ def test_tilted_square_methods():
     )
 
 
-def test_tilted_square_lattice_n_nodes():
+def test_tilted_square_lattice_n_nodes() -> None:
     for width, height in itertools.product(list(range(1, 4 + 1)), repeat=2):
         topo = TiltedSquareLattice(width, height)
         assert topo.n_nodes == topo.graph.number_of_nodes()
 
 
-def test_line_topology():
+def test_line_topology() -> None:
     n = 10
     topo = LineTopology(n)
     assert topo.n_nodes == n
@@ -94,13 +97,13 @@ def test_line_topology():
     cirq.testing.assert_equivalent_repr(topo)
 
 
-def test_line_topology_nodes_as_qubits():
+def test_line_topology_nodes_as_qubits() -> None:
     for n in range(2, 10, 2):
         assert LineTopology(n).nodes_as_linequbits() == cirq.LineQubit.range(n)
 
 
 @pytest.mark.parametrize('tilted', [True, False])
-def test_draw_gridlike(tilted):
+def test_draw_gridlike(tilted) -> None:
     graph = nx.grid_2d_graph(3, 3)
     ax = MagicMock()
     pos = draw_gridlike(graph, tilted=tilted, ax=ax)
@@ -111,7 +114,7 @@ def test_draw_gridlike(tilted):
 
 
 @pytest.mark.parametrize('tilted', [True, False])
-def test_draw_gridlike_qubits(tilted):
+def test_draw_gridlike_qubits(tilted) -> None:
     graph = nx.grid_2d_graph(3, 3)
     graph = nx.relabel_nodes(graph, {(r, c): cirq.GridQubit(r, c) for r, c in sorted(graph.nodes)})
     ax = MagicMock()
@@ -122,7 +125,7 @@ def test_draw_gridlike_qubits(tilted):
         assert 0 <= q.col < 3
 
 
-def test_get_placements():
+def test_get_placements() -> None:
     topo = TiltedSquareLattice(4, 2)
     syc23 = TiltedSquareLattice(8, 4).graph
     placements = get_placements(syc23, topo.graph)
@@ -134,7 +137,7 @@ def test_get_placements():
         ax.scatter.assert_called()
 
 
-def test_is_valid_placement():
+def test_is_valid_placement() -> None:
     topo = TiltedSquareLattice(4, 2)
     syc23 = TiltedSquareLattice(8, 4).graph
     placements = get_placements(syc23, topo.graph)

cirq/devices/noise_model.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Callable, Dict, Iterable, Sequence, TYPE_CHECKING, Union
+from typing import Any, Callable, Iterable, Sequence, TYPE_CHECKING, Union
 
 from cirq import ops, protocols, value
 from cirq._doc import document
@@ -196,7 +196,7 @@ class _NoNoiseModel(NoiseModel):
     def __repr__(self) -> str:
         return 'cirq.NO_NOISE'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, [])
 
     def _has_unitary_(self) -> bool:
@@ -247,7 +247,7 @@ class ConstantQubitNoiseModel(NoiseModel):
         ]
         return output[::-1] if self._prepend else output
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, ['qubit_noise_gate'])
 
     def _has_unitary_(self) -> bool: