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

cirq/contrib/routing/greedy.py

@@ -15,18 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import (
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    TYPE_CHECKING,
-)
+from typing import Callable, cast, Iterable, Sequence, TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
@@ -42,7 +31,7 @@ if TYPE_CHECKING:
     import cirq
 
 SWAP = cca.SwapPermutationGate()
-QidPair = Tuple[ops.Qid, ops.Qid]
+QidPair = tuple[ops.Qid, ops.Qid]
 
 
 def route_circuit_greedily(
@@ -106,7 +95,7 @@ class _GreedyRouter:
         *,
         max_search_radius: int = 1,
         max_num_empty_steps: int = 5,
-        initial_mapping: Optional[Dict[ops.Qid, ops.Qid]] = None,
+        initial_mapping: dict[ops.Qid, ops.Qid] | None = None,
         can_reorder: Callable[[ops.Operation, ops.Operation], bool] = lambda op1, op2: not set(
             op1.qubits
         )
@@ -117,7 +106,7 @@ class _GreedyRouter:
         self.prng = value.parse_random_state(random_state)
 
         self.device_graph = device_graph
-        self.physical_distances: Dict[QidPair, int] = {
+        self.physical_distances: dict[QidPair, int] = {
             (a, b): d
             for a, neighbor_distances in nx.shortest_path_length(device_graph)
             for b, d in neighbor_distances.items()
@@ -126,9 +115,9 @@ class _GreedyRouter:
         self.remaining_dag = circuitdag.CircuitDag.from_circuit(circuit, can_reorder=can_reorder)
         self.logical_qubits = list(self.remaining_dag.all_qubits())
         self.physical_qubits = list(self.device_graph.nodes)
-        self.edge_sets: Dict[int, List[Sequence[QidPair]]] = {}
+        self.edge_sets: dict[int, list[Sequence[QidPair]]] = {}
 
-        self.physical_ops: List[ops.Operation] = []
+        self.physical_ops: list[ops.Operation] = []
 
         self.set_initial_mapping(initial_mapping)
 
@@ -155,7 +144,7 @@ class _GreedyRouter:
         logical qubits."""
         return (self._log_to_phys[q] for q in qubits)
 
-    def phys_to_log(self, *qubits: cirq.Qid) -> Iterable[Optional[ops.Qid]]:
+    def phys_to_log(self, *qubits: cirq.Qid) -> Iterable[ops.Qid | None]:
         """Returns an iterator over the logical qubits that map to the given
         physical qubits."""
         return (self._phys_to_log[q] for q in qubits)
@@ -176,7 +165,7 @@ class _GreedyRouter:
                 if l is not None:
                     self._log_to_phys[l] = p
 
-    def set_initial_mapping(self, initial_mapping: Optional[Dict[ops.Qid, ops.Qid]] = None):
+    def set_initial_mapping(self, initial_mapping: dict[ops.Qid, ops.Qid] | None = None):
         """Sets the internal state according to an initial mapping.
 
         Args:
@@ -237,7 +226,7 @@ class _GreedyRouter:
         logical qubits."""
         return self.physical_distances[cast(QidPair, tuple(self.log_to_phys(*edge)))]
 
-    def swap_along_path(self, path: Tuple[ops.Qid]):
+    def swap_along_path(self, path: tuple[ops.Qid]):
         """Adds SWAPs to move a logical qubit along a specified path."""
         for i in range(len(path) - 1):
             self.apply_swap(cast(QidPair, path[i : i + 2]))
@@ -317,7 +306,7 @@ class _GreedyRouter:
         assert ops_are_consistent_with_device_graph(self.physical_ops, self.device_graph)
 
 
-def _get_dominated_indices(vectors: List[np.ndarray]) -> Set[int]:
+def _get_dominated_indices(vectors: list[np.ndarray]) -> set[int]:
     """Get the indices of vectors that are element-wise at least some other
     vector.
     """

cirq/contrib/routing/greedy_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from multiprocessing import Process
 
 import pytest
@@ -21,7 +23,7 @@ import cirq.contrib.routing as ccr
 from cirq.contrib.routing.greedy import route_circuit_greedily
 
 
-def test_bad_args():
+def test_bad_args() -> None:
     """Test zero valued arguments in greedy router."""
     circuit = cirq.testing.random_circuit(4, 2, 0.5, random_state=5)
     device_graph = ccr.get_grid_device_graph(3, 2)
@@ -50,7 +52,7 @@ def create_hanging_routing_instance(circuit, device_graph):
     )
 
 
-def test_router_hanging():
+def test_router_hanging() -> None:
     """Run a separate process and check if greedy router hits timeout (20s)."""
     circuit, device_graph = create_circuit_and_device()
     process = Process(target=create_hanging_routing_instance, args=[circuit, device_graph])

cirq/contrib/routing/initialization.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import cast, Dict, Hashable, TYPE_CHECKING
+from typing import cast, Hashable, TYPE_CHECKING
 
 import networkx as nx
 from sortedcontainers import SortedDict, SortedSet
@@ -35,7 +35,7 @@ def get_initial_mapping(
     logical_graph: nx.Graph,
     device_graph: nx.Graph,
     random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
-) -> Dict[ops.Qid, ops.Qid]:
+) -> dict[ops.Qid, ops.Qid]:
     """Gets an initial mapping of logical to physical qubits for routing.
 
     Args:

cirq/contrib/routing/initialization_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 random
 
 import networkx as nx
@@ -30,7 +32,7 @@ def get_seeded_initial_mapping(graph_seed, init_seed):
 
 
 @pytest.mark.parametrize('seed', [random.randint(0, 2**32) for _ in range(10)])
-def test_initialization_reproducible_with_seed(seed):
+def test_initialization_reproducible_with_seed(seed) -> None:
     wrappers = (lambda s: s, np.random.RandomState)
     mappings = [
         get_seeded_initial_mapping(seed, wrapper(seed)) for wrapper in wrappers for _ in range(5)
@@ -39,7 +41,7 @@ def test_initialization_reproducible_with_seed(seed):
     eq.add_equality_group(*mappings)
 
 
-def test_initialization_with_no_seed():
+def test_initialization_with_no_seed() -> None:
     graph_seed = random.randint(0, 2**32)
     state = np.random.get_state()
     mappings = []
@@ -50,7 +52,7 @@ def test_initialization_with_no_seed():
     eq.add_equality_group(*mappings)
 
 
-def test_initialization_reproducible_between_runs():
+def test_initialization_reproducible_between_runs() -> None:
     seed = 45
     logical_graph = nx.erdos_renyi_graph(6, 0.5, seed=seed)
     logical_graph = nx.relabel_nodes(logical_graph, cirq.LineQubit)

cirq/contrib/routing/router.py

@@ -12,13 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable, Optional
+from __future__ import annotations
 
-import networkx as nx
+from typing import Callable, TYPE_CHECKING
 
 from cirq import circuits, protocols
 from cirq.contrib.routing.greedy import route_circuit_greedily
-from cirq.contrib.routing.swap_network import SwapNetwork
+
+if TYPE_CHECKING:
+    import networkx as nx
+
+    from cirq.contrib.routing.swap_network import SwapNetwork
 
 ROUTERS = {'greedy': route_circuit_greedily}
 
@@ -27,8 +31,8 @@ def route_circuit(
     circuit: circuits.Circuit,
     device_graph: nx.Graph,
     *,
-    algo_name: Optional[str] = None,
-    router: Optional[Callable[..., SwapNetwork]] = None,
+    algo_name: str | None = None,
+    router: Callable[..., SwapNetwork] | None = None,
     **kwargs,
 ) -> SwapNetwork:
     """Routes a circuit on a given device.

cirq/contrib/routing/router_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 itertools
 import random
 

cirq/contrib/routing/swap_network.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import Dict, Iterable, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING
 
 import cirq.contrib.acquaintance as cca
 from cirq import ops
@@ -37,13 +37,13 @@ class SwapNetwork:
         initial_mapping: The initial mapping from physical to logical qubits.
     """
 
-    def __init__(self, circuit: cirq.Circuit, initial_mapping: Dict[cirq.Qid, cirq.Qid]) -> None:
+    def __init__(self, circuit: cirq.Circuit, initial_mapping: dict[cirq.Qid, cirq.Qid]) -> None:
         if not all(isinstance(i, ops.Qid) for I in initial_mapping.items() for i in I):
             raise ValueError('Mapping must be from Qids to Qids.')
         self.circuit = circuit
         self.initial_mapping = initial_mapping
 
-    def final_mapping(self) -> Dict[cirq.Qid, cirq.Qid]:
+    def final_mapping(self) -> dict[cirq.Qid, cirq.Qid]:
         mapping = dict(self.initial_mapping)
         cca.update_mapping(mapping, self.circuit.all_operations())
         return mapping

cirq/contrib/routing/swap_network_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 itertools
 
 import pytest
@@ -79,5 +81,5 @@ def test_swap_network_str():
 (3, 0): ───q(3)───ZZ───q(3)───╱1╲───q(2)───ZZ───q(2)───╲0╱───q(4)───ZZ───q(4)───╱1╲───q(0)───ZZ───q(0)───╲0╱───q(2)───ZZ───q(2)───╱1╲───q(1)───
                                            │           │                                     │           │
 (4, 0): ───q(4)────────q(4)─────────q(4)───ZZ───q(4)───╱1╲───q(2)────────q(2)─────────q(2)───ZZ───q(2)───╱1╲───q(0)────────q(0)─────────q(0)───
-    """.strip()
+    """.strip()  # noqa: E501
     assert actual_str == expected_str

cirq/contrib/routing/utils.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import operator
 import re
-from typing import Callable, Iterable, List, TYPE_CHECKING
+from typing import Callable, Iterable, TYPE_CHECKING
 
 import networkx as nx
 
@@ -31,7 +31,7 @@ if TYPE_CHECKING:
 BINARY_OP_PREDICATE = Callable[[ops.Operation, ops.Operation], bool]
 
 
-def get_time_slices(dag: CircuitDag) -> List[nx.Graph]:
+def get_time_slices(dag: CircuitDag) -> list[nx.Graph]:
     """Slices the DAG into logical graphs.
 
     Each time slice is a graph whose vertices are qubits and whose edges

cirq/contrib/routing/utils_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 networkx as nx
 import pytest
 

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking.py

@@ -11,21 +11,27 @@
 # 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.
+
 """Tools for running circuits in a shuffled order with readout error benchmarking."""
+
+from __future__ import annotations
+
 import time
-from typing import Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
 
 from cirq import circuits, ops, protocols, work
 from cirq.experiments import SingleQubitReadoutCalibrationResult
-from cirq.study import ResultDict
+
+if TYPE_CHECKING:
+    from cirq.study import ResultDict
 
 
 def _validate_input(
     input_circuits: list[circuits.Circuit],
-    circuit_repetitions: Union[int, list[int]],
-    rng_or_seed: Union[np.random.Generator, int],
+    circuit_repetitions: int | list[int],
+    rng_or_seed: np.random.Generator | int,
     num_random_bitstrings: int,
     readout_repetitions: int,
 ):
@@ -153,12 +159,12 @@ def _analyze_readout_results(
 def run_shuffled_with_readout_benchmarking(
     input_circuits: list[circuits.Circuit],
     sampler: work.Sampler,
-    circuit_repetitions: Union[int, list[int]],
-    rng_or_seed: Union[np.random.Generator, int],
+    circuit_repetitions: int | list[int],
+    rng_or_seed: np.random.Generator | int,
     num_random_bitstrings: int = 100,
     readout_repetitions: int = 1000,
-    qubits: Optional[Union[List[ops.Qid], List[List[ops.Qid]]]] = None,
-) -> tuple[list[ResultDict], Dict[Tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult]]:
+    qubits: list[ops.Qid] | list[list[ops.Qid]] | None = None,
+) -> tuple[list[ResultDict], dict[tuple[ops.Qid, ...], SingleQubitReadoutCalibrationResult]]:
     """Run the circuits in a shuffled order with readout error benchmarking.
 
     Args:
@@ -186,7 +192,7 @@ def run_shuffled_with_readout_benchmarking(
     )
 
     # If input qubits is None, extract qubits from input circuits
-    qubits_to_measure: List[List[ops.Qid]] = []
+    qubits_to_measure: list[list[ops.Qid]] = []
     if qubits is None:
         qubits_set: set[ops.Qid] = set()
         for circuit in input_circuits:

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking_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
 
 import numpy as np

cirq/contrib/svg/svg.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import cast, Dict, List, Tuple, TYPE_CHECKING
+from typing import cast, TYPE_CHECKING
 
 import matplotlib.font_manager
 import matplotlib.textpath
@@ -63,7 +63,7 @@ def _text(x: float, y: float, text: str, fontsize: int = 14):
 
 def _fit_horizontal(
     tdd: cirq.TextDiagramDrawer, ref_boxwidth: float, col_padding: float
-) -> Tuple[List[float], List[float]]:
+) -> tuple[list[float], list[float]]:
     """Figure out the horizontal spacing of columns to fit everything in.
 
     Returns:
@@ -93,7 +93,7 @@ def _fit_horizontal(
 
 def _fit_vertical(
     tdd: cirq.TextDiagramDrawer, ref_boxheight: float, row_padding: float
-) -> Tuple[List[float], List[float], Dict[float, int]]:
+) -> tuple[list[float], list[float], dict[float, int]]:
     """Return data structures used to turn tdd vertical coordinates into
     well-spaced SVG coordinates.
 

cirq/contrib/svg/svg_test.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import IPython.display
 import numpy as np
 import pytest
@@ -7,7 +10,7 @@ import cirq
 from cirq.contrib.svg import circuit_to_svg, SVGCircuit
 
 
-def test_svg():
+def test_svg() -> None:
     a, b, c = cirq.LineQubit.range(3)
 
     svg_text = circuit_to_svg(
@@ -26,7 +29,7 @@ def test_svg():
     assert '</svg>' in svg_text
 
 
-def test_svg_noise():
+def test_svg_noise() -> None:
     noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3))
     q = cirq.LineQubit(0)
     circuit = cirq.Circuit(cirq.X(q))
@@ -35,12 +38,12 @@ def test_svg_noise():
     assert '>D(0.001)</text>' in svg
 
 
-def test_validation():
+def test_validation() -> None:
     with pytest.raises(ValueError):
         circuit_to_svg(cirq.Circuit())
 
 
-def test_empty_moments():
+def test_empty_moments() -> None:
     a, b = cirq.LineQubit.range(2)
     svg_1 = circuit_to_svg(
         cirq.Circuit(
@@ -73,7 +76,7 @@ def test_empty_moments():
         ('A[<virtual>]B[cirq.VirtualTag()]C>D<E', 'ABC&gt;D&lt;E'),
     ],
 )
-def test_gate_with_less_greater_str(symbol, svg_symbol):
+def test_gate_with_less_greater_str(symbol, svg_symbol) -> None:
     class CustomGate(cirq.Gate):
         def _num_qubits_(self) -> int:
             return 1

cirq/devices/device.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 import abc
-from typing import FrozenSet, Iterable, Optional, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING
 
 import networkx as nx
 
@@ -59,7 +59,7 @@ class Device(metaclass=abc.ABCMeta):
     """
 
     @property
-    def metadata(self) -> Optional[DeviceMetadata]:
+    def metadata(self) -> DeviceMetadata | None:
         """Returns the associated Metadata with the device if applicable.
 
         Returns:
@@ -116,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:

cirq/devices/device_test.py

@@ -1,17 +1,20 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import networkx as nx
 
 import cirq
 
 
-def test_device_metadata():
+def test_device_metadata() -> None:
     class RawDevice(cirq.Device):
         pass
 
     assert RawDevice().metadata is None
 
 
-def test_metadata():
+def test_metadata() -> None:
     qubits = cirq.LineQubit.range(4)
     graph = nx.star_graph(3)
     metadata = cirq.DeviceMetadata(qubits, graph)
@@ -19,7 +22,7 @@ def test_metadata():
     assert metadata.nx_graph == graph
 
 
-def test_metadata_json_load_logic():
+def test_metadata_json_load_logic() -> None:
     qubits = cirq.LineQubit.range(4)
     graph = nx.star_graph(3)
     metadata = cirq.DeviceMetadata(qubits, graph)
@@ -27,7 +30,7 @@ def test_metadata_json_load_logic():
     assert metadata == cirq.read_json(json_text=str_rep)
 
 
-def test_metadata_equality():
+def test_metadata_equality() -> None:
     qubits = cirq.LineQubit.range(4)
     graph = nx.star_graph(3)
     graph2 = nx.star_graph(3)

cirq/devices/grid_device_metadata.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-from typing import cast, FrozenSet, Iterable, Mapping, Optional, Tuple, TYPE_CHECKING
+from typing import cast, Iterable, Mapping, TYPE_CHECKING
 
 import networkx as nx
 
@@ -33,10 +33,10 @@ class GridDeviceMetadata(device.DeviceMetadata):
 
     def __init__(
         self,
-        qubit_pairs: Iterable[Tuple[cirq.GridQubit, cirq.GridQubit]],
+        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,
+        gate_durations: Mapping[cirq.GateFamily, cirq.Duration] | None = None,
+        all_qubits: Iterable[cirq.GridQubit] | None = None,
         compilation_target_gatesets: Iterable[cirq.CompilationTargetGateset] = (),
     ):
         """Create a GridDeviceMetadata object.
@@ -118,16 +118,16 @@ 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:
             Frozenset of qubits on device.
         """
-        return cast(FrozenSet['cirq.GridQubit'], super().qubit_set)
+        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
@@ -136,7 +136,7 @@ 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
 
@@ -146,12 +146,12 @@ class GridDeviceMetadata(device.DeviceMetadata):
         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) -> Mapping[cirq.GateFamily, cirq.Duration] | None:
         """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

@@ -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 GridDevicemetadata."""
 
+from __future__ import annotations
+
 import networkx as nx
 import pytest