cirq-core 1.6.0.dev20250520054601__py3-none-any.whl → 1.6.0.dev20250520181654__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,7 +116,7 @@ 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]:
+    def neighbors(self, qids: Iterable[ops.Qid] | None = None) -> set[_BaseGridQid]:
         """Returns qubits that are potential neighbors to this GridQid
 
         Args:
@@ -135,7 +135,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 +154,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 +173,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 +204,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 +233,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 +256,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 +277,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 +342,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 +367,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 +391,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 +412,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 +431,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 +491,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/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, 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: dict[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):
@@ -82,7 +82,7 @@ class InsertionNoiseModel(devices.NoiseModel):
             + 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/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/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/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:

cirq/devices/noise_properties.py

@@ -22,7 +22,7 @@ noise models to produce a single noise model which replicates device noise.
 from __future__ import annotations
 
 import abc
-from typing import Iterable, List, Sequence, TYPE_CHECKING
+from typing import Iterable, Sequence, TYPE_CHECKING
 
 from cirq import _import, devices, ops, protocols
 from cirq.devices.noise_utils import PHYSICAL_GATE_TAG
@@ -37,7 +37,7 @@ class NoiseProperties(abc.ABC):
     """Noise-defining properties for a quantum device."""
 
     @abc.abstractmethod
-    def build_noise_models(self) -> List[cirq.NoiseModel]:
+    def build_noise_models(self) -> list[cirq.NoiseModel]:
         """Construct all NoiseModels associated with this NoiseProperties."""
 
 

cirq/devices/noise_properties_test.py

@@ -14,8 +14,6 @@
 
 from __future__ import annotations
 
-from typing import List, Tuple
-
 import cirq
 from cirq.devices.insertion_noise_model import InsertionNoiseModel
 from cirq.devices.noise_properties import NoiseModelFromNoiseProperties, NoiseProperties
@@ -25,7 +23,7 @@ from cirq.devices.noise_utils import OpIdentifier, PHYSICAL_GATE_TAG
 # These properties are for testing purposes only - they are not representative
 # of device behavior for any existing hardware.
 class SampleNoiseProperties(NoiseProperties):
-    def __init__(self, system_qubits: List[cirq.Qid], qubit_pairs: List[Tuple[cirq.Qid, cirq.Qid]]):
+    def __init__(self, system_qubits: list[cirq.Qid], qubit_pairs: list[tuple[cirq.Qid, cirq.Qid]]):
         self.qubits = system_qubits
         self.qubit_pairs = qubit_pairs
 

cirq/devices/noise_utils.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict, Tuple, Type, TYPE_CHECKING, Union
+from typing import Any, TYPE_CHECKING
 
 from cirq import ops, protocols, qis, value
 from cirq._compat import deprecated, proper_repr
@@ -31,18 +31,18 @@ PHYSICAL_GATE_TAG = 'physical_gate'
 class OpIdentifier:
     """Identifies an operation by gate and (optionally) target qubits."""
 
-    def __init__(self, gate_type: Type[cirq.Gate], *qubits: cirq.Qid):
+    def __init__(self, gate_type: type[cirq.Gate], *qubits: cirq.Qid):
         self._gate_type = gate_type
         self._gate_family = ops.GateFamily(gate_type)
-        self._qubits: Tuple[cirq.Qid, ...] = tuple(qubits)
+        self._qubits: tuple[cirq.Qid, ...] = tuple(qubits)
 
     @property
-    def gate_type(self) -> Type[cirq.Gate]:
+    def gate_type(self) -> type[cirq.Gate]:
         # set to a type during initialization, never modified
         return self._gate_type
 
     @property
-    def qubits(self) -> Tuple[cirq.Qid, ...]:
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         return self._qubits
 
     def _predicate(self, *args, **kwargs):
@@ -67,7 +67,7 @@ class OpIdentifier:
         else:
             return False
 
-    def __contains__(self, item: Union[ops.Gate, ops.Operation]) -> bool:
+    def __contains__(self, item: ops.Gate | ops.Operation) -> bool:
         if isinstance(item, ops.Gate):
             return (not self._qubits) and self._predicate(item)
         return (
@@ -86,7 +86,7 @@ class OpIdentifier:
     def _value_equality_values_(self) -> Any:
         return (self.gate_type, self.qubits)
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         if hasattr(self.gate_type, '__name__'):
             return {'gate_type': protocols.json_cirq_type(self._gate_type), 'qubits': self._qubits}
         return {'gate_type': self._gate_type, 'qubits': self._qubits}