cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/devices/grid_device_metadata.py

@@ -11,11 +11,15 @@
 # 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.
+
 """Metadata subtype for 2D Homogenous devices."""
 
-from typing import TYPE_CHECKING, cast, FrozenSet, Iterable, Mapping, Optional, Tuple
+from __future__ import annotations
+
+from typing import cast, FrozenSet, Iterable, Mapping, Optional, Tuple, TYPE_CHECKING
 
 import networkx as nx
+
 from cirq import value
 from cirq.devices import device
 
@@ -29,11 +33,11 @@ class GridDeviceMetadata(device.DeviceMetadata):
 
     def __init__(
         self,
-        qubit_pairs: Iterable[Tuple['cirq.GridQubit', 'cirq.GridQubit']],
-        gateset: 'cirq.Gateset',
-        gate_durations: Optional[Mapping['cirq.GateFamily', 'cirq.Duration']] = None,
-        all_qubits: Optional[Iterable['cirq.GridQubit']] = None,
-        compilation_target_gatesets: Iterable['cirq.CompilationTargetGateset'] = (),
+        qubit_pairs: Iterable[Tuple[cirq.GridQubit, cirq.GridQubit]],
+        gateset: cirq.Gateset,
+        gate_durations: Optional[Mapping[cirq.GateFamily, cirq.Duration]] = None,
+        all_qubits: Optional[Iterable[cirq.GridQubit]] = None,
+        compilation_target_gatesets: Iterable[cirq.CompilationTargetGateset] = (),
     ):
         """Create a GridDeviceMetadata object.
 
@@ -114,7 +118,7 @@ class GridDeviceMetadata(device.DeviceMetadata):
         self._gate_durations = gate_durations
 
     @property
-    def qubit_set(self) -> FrozenSet['cirq.GridQubit']:
+    def qubit_set(self) -> FrozenSet[cirq.GridQubit]:
         """Returns the set of grid qubits on the device.
 
         Returns:
@@ -123,7 +127,7 @@ class GridDeviceMetadata(device.DeviceMetadata):
         return cast(FrozenSet['cirq.GridQubit'], super().qubit_set)
 
     @property
-    def qubit_pairs(self) -> FrozenSet[FrozenSet['cirq.GridQubit']]:
+    def qubit_pairs(self) -> FrozenSet[FrozenSet[cirq.GridQubit]]:
         """Returns the set of all couple-able qubits on the device.
 
         Each element in the outer frozenset is a 2-element frozenset representing a bidirectional
@@ -132,22 +136,22 @@ class GridDeviceMetadata(device.DeviceMetadata):
         return self._qubit_pairs
 
     @property
-    def isolated_qubits(self) -> FrozenSet['cirq.GridQubit']:
+    def isolated_qubits(self) -> FrozenSet[cirq.GridQubit]:
         """Returns the set of all isolated qubits on the device (if applicable)."""
         return self._isolated_qubits
 
     @property
-    def gateset(self) -> 'cirq.Gateset':
+    def gateset(self) -> cirq.Gateset:
         """Returns the `cirq.Gateset` of supported gates on this device."""
         return self._gateset
 
     @property
-    def compilation_target_gatesets(self) -> Tuple['cirq.CompilationTargetGateset', ...]:
+    def compilation_target_gatesets(self) -> Tuple[cirq.CompilationTargetGateset, ...]:
         """Returns a sequence of valid `cirq.CompilationTargetGateset`s for this device."""
         return self._compilation_target_gatesets
 
     @property
-    def gate_durations(self) -> Optional[Mapping['cirq.GateFamily', 'cirq.Duration']]:
+    def gate_durations(self) -> Optional[Mapping[cirq.GateFamily, cirq.Duration]]:
         """Get a dictionary mapping from gate family to duration for gates.
 
         To look up the duration of a specific gate instance / gate type / operation which is part of

cirq/devices/grid_device_metadata_test.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 """Tests for GridDevicemetadata."""
 
+import networkx as nx
 import pytest
+
 import cirq
-import networkx as nx
 
 
 def test_griddevice_metadata():

cirq/devices/grid_qubit.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import functools
 import weakref
-from typing import Any, Dict, Iterable, List, Optional, Tuple, Set, TYPE_CHECKING, Union
-from typing_extensions import Self
+from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
+from typing_extensions import Self
 
 from cirq import ops, protocols
 
@@ -34,11 +36,9 @@ class _BaseGridQid(ops.Qid):
     _col: int
     _dimension: int
     _comp_key: Optional[Tuple[int, int]] = None
-    _hash: Optional[int] = None
+    _hash: int
 
     def __hash__(self) -> int:
-        if self._hash is None:
-            self._hash = hash((self._row, self._col, self._dimension))
         return self._hash
 
     def __eq__(self, other) -> bool:
@@ -106,17 +106,17 @@ class _BaseGridQid(ops.Qid):
     def dimension(self) -> int:
         return self._dimension
 
-    def with_dimension(self, dimension: int) -> 'GridQid':
+    def with_dimension(self, dimension: int) -> GridQid:
         return GridQid(self._row, self._col, dimension=dimension)
 
-    def is_adjacent(self, other: 'cirq.Qid') -> bool:
+    def is_adjacent(self, other: cirq.Qid) -> bool:
         """Determines if two qubits are adjacent qubits."""
         return (
             isinstance(other, GridQubit)
             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: Optional[Iterable[ops.Qid]] = None) -> Set[_BaseGridQid]:
         """Returns qubits that are potential neighbors to this GridQid
 
         Args:
@@ -206,7 +206,7 @@ class GridQid(_BaseGridQid):
     # Holds weak references so instances can still be garbage collected.
     _cache = weakref.WeakValueDictionary[Tuple[int, int, int], 'cirq.GridQid']()
 
-    def __new__(cls, row: int, col: int, *, dimension: int) -> 'cirq.GridQid':
+    def __new__(cls, row: int, col: int, *, dimension: int) -> cirq.GridQid:
         """Creates a grid qid at the given row, col coordinate
 
         Args:
@@ -215,6 +215,7 @@ class GridQid(_BaseGridQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
+        dimension = int(dimension)
         key = (row, col, dimension)
         inst = cls._cache.get(key)
         if inst is None:
@@ -223,6 +224,7 @@ class GridQid(_BaseGridQid):
             inst._row = row
             inst._col = col
             inst._dimension = dimension
+            inst._hash = ((dimension - 2) * 1_000_003 + hash(col)) * 1_000_003 + hash(row)
             cls._cache[key] = inst
         return inst
 
@@ -230,11 +232,15 @@ class GridQid(_BaseGridQid):
         """Returns a tuple of (args, kwargs) to pass to __new__ when unpickling."""
         return (self._row, self._col), {"dimension": self._dimension}
 
-    def _with_row_col(self, row: int, col: int) -> 'GridQid':
+    # avoid pickling the _hash value, attributes are already stored with __getnewargs_ex__
+    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:
@@ -250,9 +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:
@@ -273,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
@@ -333,9 +337,7 @@ class GridQid(_BaseGridQid):
     def __str__(self) -> str:
         return f"q({self._row}, {self._col}) (d={self._dimension})"
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         return protocols.CircuitDiagramInfo(
             wire_symbols=(f"({self._row}, {self._col}) (d={self._dimension})",)
         )
@@ -367,7 +369,7 @@ class GridQubit(_BaseGridQid):
     # Holds weak references so instances can still be garbage collected.
     _cache = weakref.WeakValueDictionary[Tuple[int, int], 'cirq.GridQubit']()
 
-    def __new__(cls, row: int, col: int) -> 'cirq.GridQubit':
+    def __new__(cls, row: int, col: int) -> cirq.GridQubit:
         """Creates a grid qubit at the given row, col coordinate
 
         Args:
@@ -380,6 +382,7 @@ class GridQubit(_BaseGridQid):
             inst = super().__new__(cls)
             inst._row = row
             inst._col = col
+            inst._hash = hash(col) * 1_000_003 + hash(row)
             cls._cache[key] = inst
         return inst
 
@@ -387,11 +390,15 @@ class GridQubit(_BaseGridQid):
         """Returns a tuple of args to pass to __new__ when unpickling."""
         return (self._row, self._col)
 
-    def _with_row_col(self, row: int, col: int) -> 'GridQubit':
+    # avoid pickling the _hash value, attributes are already stored with __getnewargs__
+    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:
@@ -405,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:
@@ -424,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
@@ -481,9 +488,7 @@ class GridQubit(_BaseGridQid):
     def __str__(self) -> str:
         return f"q({self._row}, {self._col})"
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    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]:

cirq/devices/grid_qubit_test.py

@@ -58,7 +58,7 @@ def test_grid_qid_pickled_hash():
     _test_qid_pickled_hash(q, q_bad)
 
 
-def _test_qid_pickled_hash(q: 'cirq.Qid', q_bad: 'cirq.Qid') -> None:
+def _test_qid_pickled_hash(q: cirq.Qid, q_bad: cirq.Qid) -> None:
     """Test that hashes are not pickled with Qid instances."""
     assert q_bad is not q
     _ = hash(q_bad)  # compute hash to ensure it is cached.
@@ -391,3 +391,32 @@ def test_immutable():
 def test_complex():
     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):
+    np5, np6, np3 = [dtype(i) for i in [5, 6, 3]]
+    q = cirq.GridQubit(np5, np6)
+    assert hash(q) == hash(cirq.GridQubit(5, 6))
+    assert q.row == 5
+    assert q.col == 6
+    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)
+
+
+@pytest.mark.parametrize('dtype', (float, np.float64))
+def test_non_integer_index(dtype):
+    # 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 q.row == 5.5
+    assert q.col == 6.5
+    assert isinstance(q.row, dtype)
+    assert isinstance(q.col, dtype)

cirq/devices/insertion_noise_model.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import dataclasses
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
 
 from cirq import devices
 from cirq.devices import noise_utils
@@ -42,16 +44,14 @@ 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'] = []
+    def noisy_moment(self, moment: cirq.Moment, system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
+        noise_ops: List[cirq.Operation] = []
         candidate_ops = [
             op
             for op in moment

cirq/devices/insertion_noise_model_test.py

@@ -14,7 +14,7 @@
 
 import cirq
 from cirq.devices.insertion_noise_model import InsertionNoiseModel
-from cirq.devices.noise_utils import PHYSICAL_GATE_TAG, OpIdentifier
+from cirq.devices.noise_utils import OpIdentifier, PHYSICAL_GATE_TAG
 
 
 def test_insertion_noise():

cirq/devices/line_qubit.py

@@ -12,10 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+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_extensions import Self
 
 from cirq import ops, protocols
@@ -30,11 +33,9 @@ class _BaseLineQid(ops.Qid):
 
     _x: int
     _dimension: int
-    _hash: Optional[int] = None
+    _hash: int
 
     def __hash__(self) -> int:
-        if self._hash is None:
-            self._hash = hash((self._x, self._dimension))
         return self._hash
 
     def __eq__(self, other) -> bool:
@@ -94,10 +95,10 @@ class _BaseLineQid(ops.Qid):
     def dimension(self) -> int:
         return self._dimension
 
-    def with_dimension(self, dimension: int) -> 'LineQid':
+    def with_dimension(self, dimension: int) -> LineQid:
         return LineQid(self._x, dimension)
 
-    def is_adjacent(self, other: 'cirq.Qid') -> bool:
+    def is_adjacent(self, other: cirq.Qid) -> bool:
         """Determines if two qubits are adjacent line qubits.
 
         Args:
@@ -107,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: Optional[Iterable[ops.Qid]] = None) -> Set[_BaseLineQid]:
         """Returns qubits that are potential neighbors to this LineQubit
 
         Args:
@@ -185,7 +186,7 @@ class LineQid(_BaseLineQid):
     # Holds weak references so instances can still be garbage collected.
     _cache = weakref.WeakValueDictionary[Tuple[int, int], 'cirq.LineQid']()
 
-    def __new__(cls, x: int, dimension: int) -> 'cirq.LineQid':
+    def __new__(cls, x: int, dimension: int) -> cirq.LineQid:
         """Initializes a line qid at the given x coordinate.
 
         Args:
@@ -193,6 +194,7 @@ class LineQid(_BaseLineQid):
             dimension: The dimension of the qid's Hilbert space, i.e.
                 the number of quantum levels.
         """
+        dimension = int(dimension)
         key = (x, dimension)
         inst = cls._cache.get(key)
         if inst is None:
@@ -200,6 +202,7 @@ class LineQid(_BaseLineQid):
             inst = super().__new__(cls)
             inst._x = x
             inst._dimension = dimension
+            inst._hash = (dimension - 2) * 1_000_003 + hash(x)
             cls._cache[key] = inst
         return inst
 
@@ -207,11 +210,15 @@ class LineQid(_BaseLineQid):
         """Returns a tuple of args to pass to __new__ when unpickling."""
         return (self._x, self._dimension)
 
-    def _with_x(self, x: int) -> 'LineQid':
+    # avoid pickling the _hash value, attributes are already stored with __getnewargs__
+    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:
@@ -225,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.
 
@@ -239,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:
@@ -259,9 +266,7 @@ class LineQid(_BaseLineQid):
     def __str__(self) -> str:
         return f"q({self._x}) (d={self._dimension})"
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    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]:
@@ -291,7 +296,7 @@ class LineQubit(_BaseLineQid):
     # Holds weak references so instances can still be garbage collected.
     _cache = weakref.WeakValueDictionary[int, 'cirq.LineQubit']()
 
-    def __new__(cls, x: int) -> 'cirq.LineQubit':
+    def __new__(cls, x: int) -> cirq.LineQubit:
         """Initializes a line qid at the given x coordinate.
 
         Args:
@@ -301,6 +306,7 @@ class LineQubit(_BaseLineQid):
         if inst is None:
             inst = super().__new__(cls)
             inst._x = x
+            inst._hash = hash(x)
             cls._cache[x] = inst
         return inst
 
@@ -308,11 +314,15 @@ class LineQubit(_BaseLineQid):
         """Returns a tuple of args to pass to __new__ when unpickling."""
         return (self._x,)
 
-    def _with_x(self, x: int) -> 'LineQubit':
+    # avoid pickling the _hash value, attributes are already stored with __getnewargs__
+    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:
@@ -329,9 +339,7 @@ class LineQubit(_BaseLineQid):
     def __str__(self) -> str:
         return f"q({self._x})"
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    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]:

cirq/devices/line_qubit_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import numpy as np
 import pytest
 
 import cirq
@@ -284,3 +285,28 @@ def test_numeric():
     assert isinstance(int(cirq.LineQubit(x=5)), int)
     assert isinstance(float(cirq.LineQubit(x=5)), float)
     assert isinstance(complex(cirq.LineQubit(x=5)), complex)
+
+
+@pytest.mark.parametrize('dtype', (np.int8, np.int64, float, np.float64))
+def test_numpy_index(dtype):
+    np5 = dtype(5)
+    q = cirq.LineQubit(np5)
+    assert hash(q) == 5
+    assert q.x == 5
+    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)
+
+
+@pytest.mark.parametrize('dtype', (float, np.float64))
+def test_non_integer_index(dtype):
+    # 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
+    assert q.x == dtype(5.5)
+    assert isinstance(q.x, dtype)

cirq/devices/named_topologies.py

@@ -12,20 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
 import warnings
 from dataclasses import dataclass
 from typing import (
+    Any,
+    Callable,
     Dict,
+    Iterable,
     List,
-    Tuple,
-    Any,
+    Optional,
     Sequence,
-    Union,
-    Iterable,
+    Tuple,
     TYPE_CHECKING,
-    Callable,
-    Optional,
+    Union,
 )
 
 import networkx as nx
@@ -127,7 +129,7 @@ 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)]
 
@@ -142,7 +144,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:
@@ -240,11 +242,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:

cirq/devices/named_topologies_test.py

@@ -14,16 +14,17 @@
 import itertools
 from unittest.mock import MagicMock
 
-import cirq
 import networkx as nx
 import pytest
+
+import cirq
 from cirq import (
     draw_gridlike,
-    LineTopology,
-    TiltedSquareLattice,
-    get_placements,
     draw_placements,
+    get_placements,
     is_valid_placement,
+    LineTopology,
+    TiltedSquareLattice,
 )