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

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking_test.py

@@ -0,0 +1,363 @@
+# Copyright 2025 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+import itertools
+
+import numpy as np
+import pytest
+
+import cirq
+from cirq.experiments import (
+    random_quantum_circuit_generation as rqcg,
+    SingleQubitReadoutCalibrationResult,
+)
+from cirq.experiments.single_qubit_readout_calibration_test import NoisySingleQubitReadoutSampler
+from cirq.study import ResultDict
+
+
+def _create_test_circuits(qubits: list[cirq.Qid], n_circuits: int) -> list[cirq.Circuit]:
+    """Helper function to generate circuits for testing."""
+    if len(qubits) < 2:
+        raise ValueError(
+            "Need at least two qubits to generate two-qubit circuits."
+        )  # pragma: no cover
+    two_qubit_gates = [cirq.ISWAP**0.5, cirq.CNOT**0.5]
+    input_circuits = []
+    qubit_pairs = list(itertools.combinations(qubits, 2))
+    num_pairs = len(qubit_pairs)
+    for i in range(n_circuits):
+        gate = two_qubit_gates[i % len(two_qubit_gates)]
+        q0, q1 = qubit_pairs[i % num_pairs]
+        circuits = rqcg.generate_library_of_2q_circuits(
+            n_library_circuits=5, two_qubit_gate=gate, q0=q0, q1=q1
+        )
+        for circuit in circuits:
+            circuit.append(cirq.measure(*qubits, key="m"))
+        input_circuits.extend(circuits)
+    return input_circuits
+
+
+def test_shuffled_circuits_with_readout_benchmarking_errors_no_noise():
+    """Test shuffled circuits with readout benchmarking with no noise from sampler."""
+    qubits = cirq.LineQubit.range(5)
+
+    # Generate random input circuits
+    input_circuits = _create_test_circuits(qubits, 3)
+
+    sampler = cirq.Simulator()
+    circuit_repetitions = 1
+    # allow passing a seed
+    rng = 123
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=100,
+            readout_repetitions=readout_repetitions,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+
+    for qlist, readout_calibration_result in readout_calibration_results.items():
+        assert isinstance(qlist, tuple)
+        assert all(isinstance(q, cirq.Qid) for q in qlist)
+        assert isinstance(readout_calibration_result, SingleQubitReadoutCalibrationResult)
+
+        assert readout_calibration_result.zero_state_errors == {q: 0 for q in qubits}
+        assert readout_calibration_result.one_state_errors == {q: 0 for q in qubits}
+        assert readout_calibration_result.repetitions == readout_repetitions
+        assert isinstance(readout_calibration_result.timestamp, float)
+
+
+def test_shuffled_circuits_with_readout_benchmarking_errors_with_noise():
+    """Test shuffled circuits with readout benchmarking with noise from sampler."""
+    qubits = cirq.LineQubit.range(6)
+
+    # Generate random input circuits
+    input_circuits = _create_test_circuits(qubits, 6)
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.2, seed=1234)
+    circuit_repetitions = 1
+    rng = np.random.default_rng()
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=100,
+            readout_repetitions=readout_repetitions,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+
+    for qlist, readout_calibration_result in readout_calibration_results.items():
+        assert isinstance(qlist, tuple)
+        assert all(isinstance(q, cirq.Qid) for q in qlist)
+        assert isinstance(readout_calibration_result, SingleQubitReadoutCalibrationResult)
+
+        for error in readout_calibration_result.zero_state_errors.values():
+            assert 0.08 < error < 0.12
+        for error in readout_calibration_result.one_state_errors.values():
+            assert 0.18 < error < 0.22
+        assert readout_calibration_result.repetitions == readout_repetitions
+        assert isinstance(readout_calibration_result.timestamp, float)
+
+
+def test_shuffled_circuits_with_readout_benchmarking_errors_with_noise_and_input_qubits():
+    """Test shuffled circuits with readout benchmarking with noise from sampler and input qubits."""
+    qubits = cirq.LineQubit.range(6)
+    readout_qubits = qubits[:4]
+
+    # Generate random input circuits
+    input_circuits = _create_test_circuits(qubits, 6)
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.3, seed=1234)
+    circuit_repetitions = 1
+    rng = np.random.default_rng()
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=100,
+            readout_repetitions=readout_repetitions,
+            qubits=readout_qubits,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+
+    for qlist, readout_calibration_result in readout_calibration_results.items():
+        assert isinstance(qlist, tuple)
+        assert all(isinstance(q, cirq.Qid) for q in qlist)
+        assert isinstance(readout_calibration_result, SingleQubitReadoutCalibrationResult)
+
+        for error in readout_calibration_result.zero_state_errors.values():
+            assert 0.08 < error < 0.12
+        for error in readout_calibration_result.one_state_errors.values():
+            assert 0.28 < error < 0.32
+        assert readout_calibration_result.repetitions == readout_repetitions
+        assert isinstance(readout_calibration_result.timestamp, float)
+
+
+def test_shuffled_circuits_with_readout_benchmarking_errors_with_noise_and_lists_input_qubits():
+    """Test shuffled circuits with readout benchmarking with noise from sampler and input qubits."""
+    qubits_1 = cirq.LineQubit.range(3)
+    qubits_2 = cirq.LineQubit.range(4)
+
+    readout_qubits = [qubits_1, qubits_2]
+
+    # Generate random input circuits and append measurements
+    input_circuits = _create_test_circuits(qubits_1, 6) + _create_test_circuits(qubits_2, 4)
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.3, seed=1234)
+    circuit_repetitions = 1
+    rng = np.random.default_rng()
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=100,
+            readout_repetitions=readout_repetitions,
+            qubits=readout_qubits,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+
+    for qlist, readout_calibration_result in readout_calibration_results.items():
+        assert isinstance(qlist, tuple)
+        assert all(isinstance(q, cirq.Qid) for q in qlist)
+        assert isinstance(readout_calibration_result, SingleQubitReadoutCalibrationResult)
+
+        for error in readout_calibration_result.zero_state_errors.values():
+            assert 0.08 < error < 0.12
+        for error in readout_calibration_result.one_state_errors.values():
+            assert 0.28 < error < 0.32
+        assert readout_calibration_result.repetitions == readout_repetitions
+        assert isinstance(readout_calibration_result.timestamp, float)
+
+
+def test_can_handle_zero_random_bitstring():
+    """Test shuffled circuits without readout benchmarking."""
+    qubits_1 = cirq.LineQubit.range(3)
+    qubits_2 = cirq.LineQubit.range(4)
+
+    readout_qubits = [qubits_1, qubits_2]
+
+    # Generate random input circuits and append measurements
+    input_circuits = _create_test_circuits(qubits_1, 6) + _create_test_circuits(qubits_2, 4)
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.3, seed=1234)
+    circuit_repetitions = 1
+    rng = np.random.default_rng()
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=0,
+            readout_repetitions=readout_repetitions,
+            qubits=readout_qubits,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+    # Check that the readout_calibration_results is empty
+    assert len(readout_calibration_results.items()) == 0
+
+
+def test_empty_input_circuits():
+    """Test that the input circuits are empty."""
+    with pytest.raises(ValueError, match="Input circuits must not be empty."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_non_circuit_input():
+    """Test that the input circuits are not of type cirq.Circuit."""
+    q = cirq.LineQubit(0)
+    with pytest.raises(ValueError, match="Input circuits must be of type cirq.Circuit."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [q],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_no_measurements():
+    """Test that the input circuits don't have measurements."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q))
+    with pytest.raises(ValueError, match="Input circuits must have measurements."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_zero_circuit_repetitions():
+    """Test that the circuit repetitions are zero."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(ValueError, match="Must provide non-zero circuit_repetitions."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=0,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_mismatch_circuit_repetitions():
+    """Test that the number of circuit repetitions don't match the number of input circuits."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(
+        ValueError,
+        match="Number of circuit_repetitions must match the number of" + " input circuits.",
+    ):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=[10, 20],
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_zero_num_random_bitstrings():
+    """Test that the number of random bitstrings is smaller than zero."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(ValueError, match="Must provide zero or more num_random_bitstrings."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=-1,
+            readout_repetitions=100,
+        )
+
+
+def test_zero_readout_repetitions():
+    """Test that the readout repetitions is zero."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(
+        ValueError, match="Must provide non-zero readout_repetitions for readout" + " calibration."
+    ):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=0,
+        )
+
+
+def test_rng_type_mismatch():
+    """Test that the rng is not a numpy random generator or a seed."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(ValueError, match="Must provide a numpy random generator or a seed"):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed="not a random generator or seed",
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )

cirq/contrib/svg/__init__.py

@@ -1,2 +1,2 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
-from cirq.contrib.svg.svg import SVGCircuit, circuit_to_svg
+from cirq.contrib.svg.svg import SVGCircuit as SVGCircuit, circuit_to_svg as circuit_to_svg

cirq/contrib/svg/svg.py

@@ -1,9 +1,11 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
-from typing import TYPE_CHECKING, List, Tuple, cast, Dict
 
-import matplotlib.textpath
-import matplotlib.font_manager
+from __future__ import annotations
+
+from typing import cast, Dict, List, Tuple, TYPE_CHECKING
 
+import matplotlib.font_manager
+import matplotlib.textpath
 
 if TYPE_CHECKING:
     import cirq
@@ -60,7 +62,7 @@ def _text(x: float, y: float, text: str, fontsize: int = 14):
 
 
 def _fit_horizontal(
-    tdd: 'cirq.TextDiagramDrawer', ref_boxwidth: float, col_padding: float
+    tdd: cirq.TextDiagramDrawer, ref_boxwidth: float, col_padding: float
 ) -> Tuple[List[float], List[float]]:
     """Figure out the horizontal spacing of columns to fit everything in.
 
@@ -90,7 +92,7 @@ def _fit_horizontal(
 
 
 def _fit_vertical(
-    tdd: 'cirq.TextDiagramDrawer', ref_boxheight: float, row_padding: float
+    tdd: cirq.TextDiagramDrawer, ref_boxheight: float, row_padding: float
 ) -> Tuple[List[float], List[float], Dict[float, int]]:
     """Return data structures used to turn tdd vertical coordinates into
     well-spaced SVG coordinates.
@@ -165,7 +167,7 @@ def _debug_spacing(col_starts, row_starts):  # pragma: no cover
 
 
 def tdd_to_svg(
-    tdd: 'cirq.TextDiagramDrawer',
+    tdd: cirq.TextDiagramDrawer,
     ref_boxwidth: float = 40,
     ref_boxheight: float = 40,
     col_padding: float = 20,
@@ -200,7 +202,7 @@ def tdd_to_svg(
             # qubits start at far left and their wires shall be blue
             stroke = QBLUE
         else:
-            stroke = 'black'
+            stroke = 'black'  # pragma: no cover
         t += f'<line x1="{x1}" x2="{x2}" y1="{y}" y2="{y}" stroke="{stroke}" stroke-width="1" />'
 
     for xi, yi1, yi2, _, _ in tdd.vertical_lines:
@@ -247,7 +249,7 @@ def tdd_to_svg(
     return t
 
 
-def _validate_circuit(circuit: 'cirq.Circuit'):
+def _validate_circuit(circuit: cirq.Circuit):
     if len(circuit) == 0:
         raise ValueError("Can't draw SVG diagram for empty circuits")
 
@@ -261,14 +263,14 @@ class SVGCircuit:
     which will cause the circuit to be displayed as an SVG image.
     """
 
-    def __init__(self, circuit: 'cirq.Circuit'):
+    def __init__(self, circuit: cirq.Circuit):
         self.circuit = circuit
 
     def _repr_svg_(self) -> str:
         return circuit_to_svg(self.circuit)
 
 
-def circuit_to_svg(circuit: 'cirq.Circuit') -> str:
+def circuit_to_svg(circuit: cirq.Circuit) -> str:
     """Render a circuit as SVG."""
     _validate_circuit(circuit)
     tdd = circuit.to_text_diagram_drawer(transpose=False)

cirq/contrib/svg/svg_test.py

@@ -4,7 +4,7 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq.contrib.svg import circuit_to_svg
+from cirq.contrib.svg import circuit_to_svg, SVGCircuit
 
 
 def test_svg():
@@ -82,7 +82,8 @@ def test_gate_with_less_greater_str(symbol, svg_symbol):
             return cirq.CircuitDiagramInfo(wire_symbols=[symbol])
 
     circuit = cirq.Circuit(CustomGate().on(cirq.LineQubit(0)))
-    svg = circuit_to_svg(circuit)
+    svg_circuit = SVGCircuit(circuit)
+    svg = svg_circuit._repr_svg_()
 
     _ = IPython.display.SVG(svg)
     assert svg_symbol in svg

cirq/devices/__init__.py

@@ -14,45 +14,54 @@
 
 """Device classes, qubits, and topologies, as well as noise models."""
 
-from cirq.devices.device import Device, DeviceMetadata
 
-from cirq.devices.grid_device_metadata import GridDeviceMetadata
+from cirq.devices.device import Device as Device, DeviceMetadata as DeviceMetadata
 
-from cirq.devices.grid_qubit import GridQid, GridQubit
+from cirq.devices.grid_device_metadata import GridDeviceMetadata as GridDeviceMetadata
 
-from cirq.devices.line_qubit import LineQubit, LineQid
+from cirq.devices.grid_qubit import GridQid as GridQid, GridQubit as GridQubit
 
-from cirq.devices.unconstrained_device import UNCONSTRAINED_DEVICE
+from cirq.devices.line_qubit import LineQubit as LineQubit, LineQid as LineQid
 
-from cirq.devices.noise_model import NO_NOISE, NOISE_MODEL_LIKE, NoiseModel, ConstantQubitNoiseModel
+from cirq.devices.unconstrained_device import UNCONSTRAINED_DEVICE as UNCONSTRAINED_DEVICE
+
+from cirq.devices.noise_model import (
+    NO_NOISE as NO_NOISE,
+    NOISE_MODEL_LIKE as NOISE_MODEL_LIKE,
+    NoiseModel as NoiseModel,
+    ConstantQubitNoiseModel as ConstantQubitNoiseModel,
+)
 
 from cirq.devices.named_topologies import (
-    NamedTopology,
-    draw_gridlike,
-    LineTopology,
-    TiltedSquareLattice,
-    get_placements,
-    is_valid_placement,
-    draw_placements,
+    NamedTopology as NamedTopology,
+    draw_gridlike as draw_gridlike,
+    LineTopology as LineTopology,
+    TiltedSquareLattice as TiltedSquareLattice,
+    get_placements as get_placements,
+    is_valid_placement as is_valid_placement,
+    draw_placements as draw_placements,
 )
 
-from cirq.devices.insertion_noise_model import InsertionNoiseModel
+from cirq.devices.insertion_noise_model import InsertionNoiseModel as InsertionNoiseModel
 
-from cirq.devices.thermal_noise_model import ThermalNoiseModel
+from cirq.devices.thermal_noise_model import ThermalNoiseModel as ThermalNoiseModel
 
-from cirq.devices.noise_properties import NoiseModelFromNoiseProperties, NoiseProperties
+from cirq.devices.noise_properties import (
+    NoiseModelFromNoiseProperties as NoiseModelFromNoiseProperties,
+    NoiseProperties as NoiseProperties,
+)
 
 from cirq.devices.superconducting_qubits_noise_properties import (
-    SuperconductingQubitsNoiseProperties,
+    SuperconductingQubitsNoiseProperties as SuperconductingQubitsNoiseProperties,
 )
 
 from cirq.devices.noise_utils import (
-    OpIdentifier,
-    decay_constant_to_xeb_fidelity,
-    decay_constant_to_pauli_error,
-    pauli_error_to_decay_constant,
-    xeb_fidelity_to_decay_constant,
-    pauli_error_from_t1,
-    average_error,
-    decoherence_pauli_error,
+    OpIdentifier as OpIdentifier,
+    decay_constant_to_xeb_fidelity as decay_constant_to_xeb_fidelity,
+    decay_constant_to_pauli_error as decay_constant_to_pauli_error,
+    pauli_error_to_decay_constant as pauli_error_to_decay_constant,
+    xeb_fidelity_to_decay_constant as xeb_fidelity_to_decay_constant,
+    pauli_error_from_t1 as pauli_error_from_t1,
+    average_error as average_error,
+    decoherence_pauli_error as decoherence_pauli_error,
 )

cirq/devices/device.py

@@ -12,9 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
-from typing import TYPE_CHECKING, Optional, FrozenSet, Iterable
+from typing import FrozenSet, Iterable, Optional, TYPE_CHECKING
+
 import networkx as nx
+
 from cirq import value
 
 if TYPE_CHECKING:
@@ -55,7 +59,7 @@ class Device(metaclass=abc.ABCMeta):
     """
 
     @property
-    def metadata(self) -> Optional['DeviceMetadata']:
+    def metadata(self) -> Optional[DeviceMetadata]:
         """Returns the associated Metadata with the device if applicable.
 
         Returns:
@@ -63,7 +67,7 @@ class Device(metaclass=abc.ABCMeta):
         """
         return None
 
-    def validate_operation(self, operation: 'cirq.Operation') -> None:
+    def validate_operation(self, operation: cirq.Operation) -> None:
         """Raises an exception if an operation is not valid.
 
         Args:
@@ -73,7 +77,7 @@ class Device(metaclass=abc.ABCMeta):
             ValueError: The operation isn't valid for this device.
         """
 
-    def validate_circuit(self, circuit: 'cirq.AbstractCircuit') -> None:
+    def validate_circuit(self, circuit: cirq.AbstractCircuit) -> None:
         """Raises an exception if a circuit is not valid.
 
         Args:
@@ -85,7 +89,7 @@ class Device(metaclass=abc.ABCMeta):
         for moment in circuit:
             self.validate_moment(moment)
 
-    def validate_moment(self, moment: 'cirq.Moment') -> None:
+    def validate_moment(self, moment: cirq.Moment) -> None:
         """Raises an exception if a moment is not valid.
 
         Args:
@@ -102,7 +106,7 @@ class Device(metaclass=abc.ABCMeta):
 class DeviceMetadata:
     """Parent type for all device specific metadata classes."""
 
-    def __init__(self, qubits: Iterable['cirq.Qid'], nx_graph: 'nx.Graph'):
+    def __init__(self, qubits: Iterable[cirq.Qid], nx_graph: nx.Graph):
         """Construct a DeviceMetadata object.
 
         Args:
@@ -112,11 +116,11 @@ class DeviceMetadata:
                 directional coupling, undirected edges indicate bi-directional
                 coupling.
         """
-        self._qubits_set: FrozenSet['cirq.Qid'] = frozenset(qubits)
+        self._qubits_set: FrozenSet[cirq.Qid] = frozenset(qubits)
         self._nx_graph = nx_graph
 
     @property
-    def qubit_set(self) -> FrozenSet['cirq.Qid']:
+    def qubit_set(self) -> FrozenSet[cirq.Qid]:
         """Returns the set of qubits on the device.
 
         Returns:
@@ -125,7 +129,7 @@ class DeviceMetadata:
         return self._qubits_set
 
     @property
-    def nx_graph(self) -> 'nx.Graph':
+    def nx_graph(self) -> nx.Graph:
         """Returns a nx.Graph where nodes are qubits and edges are couple-able qubits.
 
         Returns:
@@ -142,12 +146,12 @@ class DeviceMetadata:
         return self._qubits_set, graph_equality
 
     def _json_dict_(self):
-        graph_payload = nx.readwrite.json_graph.node_link_data(self._nx_graph)
+        graph_payload = nx.readwrite.json_graph.node_link_data(self._nx_graph, edges='links')
         qubits_payload = sorted(list(self._qubits_set))
 
         return {'qubits': qubits_payload, 'nx_graph': graph_payload}
 
     @classmethod
-    def _from_json_dict_(cls, qubits: Iterable['cirq.Qid'], nx_graph: 'nx.Graph', **kwargs):
-        graph_obj = nx.readwrite.json_graph.node_link_graph(nx_graph)
+    def _from_json_dict_(cls, qubits: Iterable[cirq.Qid], nx_graph: nx.Graph, **kwargs):
+        graph_obj = nx.readwrite.json_graph.node_link_graph(nx_graph, edges='links')
         return cls(qubits, graph_obj)

cirq/devices/device_test.py

@@ -1,5 +1,6 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 import networkx as nx
+
 import cirq