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

cirq/contrib/acquaintance/mutation_utils.py

@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import collections
+from __future__ import annotations
 
-from typing import cast, Dict, List, Optional, Sequence, Union, TYPE_CHECKING
+import collections
+from typing import cast, Dict, List, Optional, Sequence, TYPE_CHECKING, Union
 
 from cirq import circuits, ops, transformers
-
-from cirq.contrib.acquaintance.gates import SwapNetworkGate, AcquaintanceOpportunityGate
 from cirq.contrib.acquaintance.devices import get_acquaintance_size
+from cirq.contrib.acquaintance.gates import AcquaintanceOpportunityGate, SwapNetworkGate
 from cirq.contrib.acquaintance.permutation import PermutationGate
 
 if TYPE_CHECKING:
@@ -28,7 +28,7 @@ if TYPE_CHECKING:
 STRATEGY_GATE = Union[AcquaintanceOpportunityGate, PermutationGate]
 
 
-def rectify_acquaintance_strategy(circuit: 'cirq.Circuit', acquaint_first: bool = True) -> None:
+def rectify_acquaintance_strategy(circuit: cirq.Circuit, acquaint_first: bool = True) -> None:
     """Splits moments so that they contain either only acquaintance or permutation gates.
 
     Orders resulting moments so that the first one is of the same type as the previous one.
@@ -57,10 +57,10 @@ def rectify_acquaintance_strategy(circuit: 'cirq.Circuit', acquaint_first: bool
 
 
 def replace_acquaintance_with_swap_network(
-    circuit: 'cirq.Circuit',
-    qubit_order: Sequence['cirq.Qid'],
+    circuit: cirq.Circuit,
+    qubit_order: Sequence[cirq.Qid],
     acquaintance_size: Optional[int] = 0,
-    swap_gate: 'cirq.Gate' = ops.SWAP,
+    swap_gate: cirq.Gate = ops.SWAP,
 ) -> bool:
     """Replace every rectified moment with acquaintance gates with a generalized swap network.
 
@@ -106,10 +106,10 @@ class ExposeAcquaintanceGates:
             not get_acquaintance_size(op) or isinstance(op.gate, AcquaintanceOpportunityGate)
         )
 
-    def optimize_circuit(self, circuit: 'cirq.Circuit') -> None:
+    def optimize_circuit(self, circuit: cirq.Circuit) -> None:
         circuit._moments = [*transformers.expand_composite(circuit, no_decomp=self.no_decomp)]
 
-    def __call__(self, circuit: 'cirq.Circuit') -> None:
+    def __call__(self, circuit: cirq.Circuit) -> None:
         self.optimize_circuit(circuit)
 
 

cirq/contrib/acquaintance/optimizers.py

@@ -12,20 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import cast, FrozenSet, List, Sequence, Set, TYPE_CHECKING
 
 from cirq import circuits
-
-from cirq.contrib.acquaintance.gates import acquaint
 from cirq.contrib.acquaintance.executor import AcquaintanceOperation
-from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
+from cirq.contrib.acquaintance.gates import acquaint
 from cirq.contrib.acquaintance.inspection_utils import LogicalAnnotator
+from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
 
 if TYPE_CHECKING:
     import cirq
 
 
-def remove_redundant_acquaintance_opportunities(strategy: 'cirq.Circuit') -> int:
+def remove_redundant_acquaintance_opportunities(strategy: cirq.Circuit) -> int:
     """Removes redundant acquaintance opportunities."""
 
     qubits = sorted(strategy.all_qubits())
@@ -35,11 +36,11 @@ def remove_redundant_acquaintance_opportunities(strategy: 'cirq.Circuit') -> int
     annotated_strategy = strategy.copy()
     LogicalAnnotator(mapping)(annotated_strategy)
 
-    new_moments: List['cirq.Moment'] = []
+    new_moments: List[cirq.Moment] = []
     acquaintance_opps: Set[FrozenSet[int]] = set()
     n_removed = 0
     for moment in annotated_strategy:
-        new_moment: List['cirq.Operation'] = []
+        new_moment: List[cirq.Operation] = []
         for op in moment:
             if isinstance(op, AcquaintanceOperation):
                 opp = frozenset(cast(Sequence[int], op.logical_indices))

cirq/contrib/acquaintance/optimizers_test.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import cirq
-import cirq.testing as ct
 import cirq.contrib.acquaintance as cca
+import cirq.testing as ct
 
 
 def test_remove_redundant_acquaintance_opportunities():

cirq/contrib/acquaintance/permutation.py

@@ -12,22 +12,25 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import abc
+from types import NotImplementedType
 from typing import (
     Any,
     cast,
     Dict,
     Iterable,
+    Iterator,
     Optional,
     Sequence,
     Tuple,
+    TYPE_CHECKING,
     TypeVar,
     Union,
-    TYPE_CHECKING,
 )
 
 from cirq import circuits, ops, protocols, transformers, value
-from cirq.type_workarounds import NotImplementedType
 
 if TYPE_CHECKING:
     import cirq
@@ -50,7 +53,7 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
             qubits (e.g. SWAP or fermionic swap).
     """
 
-    def __init__(self, num_qubits: int, swap_gate: 'cirq.Gate' = ops.SWAP) -> None:
+    def __init__(self, num_qubits: int, swap_gate: cirq.Gate = ops.SWAP) -> None:
         self._num_qubits = num_qubits
         self.swap_gate = swap_gate
 
@@ -63,7 +66,7 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
         the s[i]-th element."""
 
     def update_mapping(
-        self, mapping: Dict[ops.Qid, LogicalIndex], keys: Sequence['cirq.Qid']
+        self, mapping: Dict[ops.Qid, LogicalIndex], keys: Sequence[cirq.Qid]
     ) -> None:
         """Updates a mapping (in place) from qubits to logical indices.
 
@@ -95,8 +98,8 @@ class PermutationGate(ops.Gate, metaclass=abc.ABCMeta):
                 raise IndexError('key is out of bounds.')
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Union[str, Iterable[str], 'cirq.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> Union[str, Iterable[str], cirq.CircuitDiagramInfo]:
         if args.known_qubit_count is None:
             return NotImplemented
         permutation = self.permutation()
@@ -117,14 +120,12 @@ class MappingDisplayGate(ops.Gate):
     def num_qubits(self) -> int:
         return self._num_qubits
 
-    def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> 'cirq.CircuitDiagramInfo':
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> cirq.CircuitDiagramInfo:
         wire_symbols = tuple('' if i is None else str(i) for i in self.indices)
         return protocols.CircuitDiagramInfo(wire_symbols, connected=False)
 
 
-def display_mapping(circuit: 'cirq.Circuit', initial_mapping: LogicalMapping) -> None:
+def display_mapping(circuit: cirq.Circuit, initial_mapping: LogicalMapping) -> None:
     """Inserts display gates between moments to indicate the mapping throughout
     the circuit."""
     qubits = sorted(circuit.all_qubits())
@@ -146,13 +147,13 @@ def display_mapping(circuit: 'cirq.Circuit', initial_mapping: LogicalMapping) ->
 class SwapPermutationGate(PermutationGate):
     """Generic swap gate."""
 
-    def __init__(self, swap_gate: 'cirq.Gate' = ops.SWAP):
+    def __init__(self, swap_gate: cirq.Gate = ops.SWAP):
         super().__init__(2, swap_gate)
 
     def permutation(self) -> Dict[int, int]:
         return {0: 1, 1: 0}
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         yield self.swap_gate(*qubits)
 
     def __repr__(self) -> str:
@@ -185,7 +186,7 @@ class LinearPermutationGate(PermutationGate):
     sorting network."""
 
     def __init__(
-        self, num_qubits: int, permutation: Dict[int, int], swap_gate: 'cirq.Gate' = ops.SWAP
+        self, num_qubits: int, permutation: Dict[int, int], swap_gate: cirq.Gate = ops.SWAP
     ) -> None:
         """Initializes a linear permutation gate.
 
@@ -201,7 +202,7 @@ class LinearPermutationGate(PermutationGate):
     def permutation(self) -> Dict[int, int]:
         return self._permutation
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         swap_gate = SwapPermutationGate(self.swap_gate)
         n_qubits = len(qubits)
         mapping = {i: self._permutation.get(i, i) for i in range(n_qubits)}
@@ -237,7 +238,7 @@ class LinearPermutationGate(PermutationGate):
         return NotImplemented
 
 
-def update_mapping(mapping: Dict[ops.Qid, LogicalIndex], operations: 'cirq.OP_TREE') -> None:
+def update_mapping(mapping: Dict[ops.Qid, LogicalIndex], operations: cirq.OP_TREE) -> None:
     """Updates a mapping (in place) from qubits to logical indices according to
     a set of permutation gates. Any gates other than permutation gates are
     ignored.
@@ -252,8 +253,8 @@ def update_mapping(mapping: Dict[ops.Qid, LogicalIndex], operations: 'cirq.OP_TR
 
 
 def get_logical_operations(
-    operations: 'cirq.OP_TREE', initial_mapping: Dict[ops.Qid, ops.Qid]
-) -> Iterable['cirq.Operation']:
+    operations: cirq.OP_TREE, initial_mapping: Dict[ops.Qid, ops.Qid]
+) -> Iterable[cirq.Operation]:
     """Gets the logical operations specified by the physical operations and
     initial mapping.
 
@@ -299,10 +300,10 @@ class DecomposePermutationGates:
                 not all([isinstance(op, ops.GateOperation), isinstance(op.gate, PermutationGate)])
             )
 
-    def optimize_circuit(self, circuit: 'cirq.Circuit') -> None:
+    def optimize_circuit(self, circuit: cirq.Circuit) -> None:
         circuit._moments = [*transformers.expand_composite(circuit, no_decomp=self.no_decomp)]
 
-    def __call__(self, circuit: 'cirq.Circuit') -> None:
+    def __call__(self, circuit: cirq.Circuit) -> None:
         self.optimize_circuit(circuit)
 
 
@@ -310,7 +311,7 @@ EXPAND_PERMUTATION_GATES = DecomposePermutationGates(keep_swap_permutations=True
 DECOMPOSE_PERMUTATION_GATES = DecomposePermutationGates(keep_swap_permutations=False)
 
 
-def return_to_initial_mapping(circuit: 'cirq.Circuit', swap_gate: 'cirq.Gate' = ops.SWAP) -> None:
+def return_to_initial_mapping(circuit: cirq.Circuit, swap_gate: cirq.Gate = ops.SWAP) -> None:
     qubits = sorted(circuit.all_qubits())
     n_qubits = len(qubits)
 
@@ -322,7 +323,7 @@ def return_to_initial_mapping(circuit: 'cirq.Circuit', swap_gate: 'cirq.Gate' =
     circuit.append(returning_permutation_op)
 
 
-def uses_consistent_swap_gate(circuit: 'cirq.Circuit', swap_gate: 'cirq.Gate') -> bool:
+def uses_consistent_swap_gate(circuit: cirq.Circuit, swap_gate: cirq.Gate) -> bool:
     for op in circuit.all_operations():
         if isinstance(op, ops.GateOperation) and isinstance(op.gate, PermutationGate):
             if op.gate.swap_gate != swap_gate:

cirq/contrib/acquaintance/permutation_test.py

@@ -17,8 +17,8 @@ import random
 import pytest
 
 import cirq
-import cirq.testing as ct
 import cirq.contrib.acquaintance as cca
+import cirq.testing as ct
 
 
 def test_swap_permutation_gate():

cirq/contrib/acquaintance/shift.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
-from typing import Any, Dict, Sequence, Tuple, TYPE_CHECKING
+from typing import Any, Dict, Iterator, Sequence, Tuple, TYPE_CHECKING
 
 from cirq import ops, value
-from cirq.contrib.acquaintance.permutation import SwapPermutationGate, PermutationGate
+from cirq.contrib.acquaintance.permutation import PermutationGate, SwapPermutationGate
 
 if TYPE_CHECKING:
     import cirq
@@ -26,7 +28,7 @@ if TYPE_CHECKING:
 class CircularShiftGate(PermutationGate):
     """Performs a cyclical permutation of the qubits to the left by a specified amount."""
 
-    def __init__(self, num_qubits: int, shift: int, swap_gate: 'cirq.Gate' = ops.SWAP) -> None:
+    def __init__(self, num_qubits: int, shift: int, swap_gate: cirq.Gate = ops.SWAP) -> None:
         """Construct a circular shift gate.
 
         Args:
@@ -47,7 +49,7 @@ class CircularShiftGate(PermutationGate):
     def _value_equality_values_(self) -> Any:
         return self.shift, self.swap_gate, self.num_qubits()
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         n = len(qubits)
         left_shift = self.shift % n
         right_shift = n - left_shift
@@ -58,9 +60,9 @@ class CircularShiftGate(PermutationGate):
             for k in range(i, j, 2):
                 yield swap_gate(*qubits[k : k + 2])
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         if args.known_qubit_count is None:
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         direction_symbols = ('╲', '╱') if args.use_unicode_characters else ('\\', '/')
         wire_symbols = tuple(
             direction_symbols[int(i >= self.shift)]

cirq/contrib/acquaintance/shift_swap_network.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import functools
 import itertools
-from typing import Dict, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING
+from typing import Dict, Iterable, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
 
 from cirq import ops
 from cirq.contrib.acquaintance.gates import acquaint
@@ -51,7 +53,7 @@ class ShiftSwapNetworkGate(PermutationGate):
         self,
         left_part_lens: Iterable[int],
         right_part_lens: Iterable[int],
-        swap_gate: 'cirq.Gate' = ops.SWAP,
+        swap_gate: cirq.Gate = ops.SWAP,
     ) -> None:
 
         self.part_lens = {'left': tuple(left_part_lens), 'right': tuple(right_part_lens)}
@@ -65,7 +67,7 @@ class ShiftSwapNetworkGate(PermutationGate):
     def acquaintance_size(self) -> int:
         return sum(max(self.part_lens[side]) for side in ('left', 'right'))
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         part_lens = list(itertools.chain(*(self.part_lens[side] for side in ('left', 'right'))))
 
         n_qubits = 0
@@ -110,7 +112,7 @@ class ShiftSwapNetworkGate(PermutationGate):
             )
         )
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         qubit_count = self.qubit_count()
         assert args.known_qubit_count in (None, qubit_count)
 

cirq/contrib/acquaintance/strategies/__init__.py

@@ -14,6 +14,12 @@
 
 """Acquaintance strategies."""
 
-from cirq.contrib.acquaintance.strategies.complete import complete_acquaintance_strategy
-from cirq.contrib.acquaintance.strategies.cubic import cubic_acquaintance_strategy
-from cirq.contrib.acquaintance.strategies.quartic_paired import quartic_paired_acquaintance_strategy
+from cirq.contrib.acquaintance.strategies.complete import (
+    complete_acquaintance_strategy as complete_acquaintance_strategy,
+)
+from cirq.contrib.acquaintance.strategies.cubic import (
+    cubic_acquaintance_strategy as cubic_acquaintance_strategy,
+)
+from cirq.contrib.acquaintance.strategies.quartic_paired import (
+    quartic_paired_acquaintance_strategy as quartic_paired_acquaintance_strategy,
+)

cirq/contrib/acquaintance/strategies/complete.py

@@ -12,10 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Sequence, TYPE_CHECKING
 
 from cirq import circuits, ops
-
 from cirq.contrib.acquaintance.gates import acquaint
 from cirq.contrib.acquaintance.mutation_utils import (
     expose_acquaintance_gates,
@@ -27,8 +28,8 @@ if TYPE_CHECKING:
 
 
 def complete_acquaintance_strategy(
-    qubit_order: Sequence['cirq.Qid'], acquaintance_size: int = 0, swap_gate: 'cirq.Gate' = ops.SWAP
-) -> 'cirq.Circuit':
+    qubit_order: Sequence[cirq.Qid], acquaintance_size: int = 0, swap_gate: cirq.Gate = ops.SWAP
+) -> cirq.Circuit:
     """Returns an acquaintance strategy with can handle the given number of qubits.
 
     Args:

cirq/contrib/acquaintance/strategies/cubic.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
-from typing import Iterable, Sequence, Tuple, TypeVar, TYPE_CHECKING
+from typing import Iterable, Sequence, Tuple, TYPE_CHECKING, TypeVar
 
 from cirq import circuits, ops
 from cirq.contrib.acquaintance.gates import acquaint
@@ -35,8 +37,8 @@ def skip_and_wrap_around(items: Sequence[TItem]) -> Tuple[TItem, ...]:
 
 
 def cubic_acquaintance_strategy(
-    qubits: Iterable['cirq.Qid'], swap_gate: 'cirq.Gate' = ops.SWAP
-) -> 'cirq.Circuit':
+    qubits: Iterable[cirq.Qid], swap_gate: cirq.Gate = ops.SWAP
+) -> cirq.Circuit:
     """Acquaints every triple of qubits.
 
     Exploits the fact that in a simple linear swap network every pair of

cirq/contrib/acquaintance/strategies/quartic_paired.py

@@ -12,9 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import cast, Iterable, List, Sequence, Tuple, TYPE_CHECKING
 
-from cirq import circuits, ops
+from cirq import circuits
 from cirq.contrib.acquaintance.gates import acquaint, SwapNetworkGate
 from cirq.contrib.acquaintance.mutation_utils import expose_acquaintance_gates
 
@@ -22,7 +24,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence['cirq.Qid']]) -> List['cirq.Qid']:
+def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence[cirq.Qid]]) -> List[cirq.Qid]:
     """Takes a sequence of qubit pairs and returns a sequence in which every
     pair is at distance two.
 
@@ -33,7 +35,7 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence['cirq.Qid']]) -> L
     if set(len(qubit_pair) for qubit_pair in qubit_pairs) != set((2,)):
         raise ValueError('set(len(qubit_pair) for qubit_pair in qubit_pairs) != set((2,))')
     n_pairs = len(qubit_pairs)
-    qubits: List['cirq.Qid'] = []
+    qubits: List[cirq.Qid] = []
     for i in range(0, 2 * (n_pairs // 2), 2):
         qubits += [
             qubit_pairs[i][0],
@@ -47,15 +49,15 @@ def qubit_pairs_to_qubit_order(qubit_pairs: Sequence[Sequence['cirq.Qid']]) -> L
 
 
 def quartic_paired_acquaintance_strategy(
-    qubit_pairs: Iterable[Tuple['cirq.Qid', ops.Qid]]
-) -> Tuple['cirq.Circuit', Sequence['cirq.Qid']]:
+    qubit_pairs: Iterable[Tuple[cirq.Qid, cirq.Qid]],
+) -> Tuple[cirq.Circuit, Sequence[cirq.Qid]]:
     """Acquaintance strategy for pairs of pairs.
 
     Implements UpCCGSD ansatz from arXiv:1810.02327.
     """
 
     qubit_pairs = tuple(
-        cast(Tuple['cirq.Qid', ops.Qid], tuple(qubit_pair)) for qubit_pair in qubit_pairs
+        cast(Tuple['cirq.Qid', 'cirq.Qid'], tuple(qubit_pair)) for qubit_pair in qubit_pairs
     )
     qubits = qubit_pairs_to_qubit_order(qubit_pairs)
     n_qubits = len(qubits)

cirq/contrib/acquaintance/topological_sort.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import operator
 import random
 from typing import Any, Callable, cast, Iterable, TYPE_CHECKING
@@ -25,8 +27,8 @@ if TYPE_CHECKING:
 
 
 def is_topologically_sorted(
-    dag: 'cirq.contrib.CircuitDag',
-    operations: 'cirq.OP_TREE',
+    dag: cirq.contrib.CircuitDag,
+    operations: cirq.OP_TREE,
     equals: Callable[[ops.Operation, ops.Operation], bool] = operator.eq,
 ) -> bool:
     """Whether a given order of operations is consistent with the DAG.

cirq/contrib/bayesian_network/__init__.py

@@ -12,4 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cirq.contrib.bayesian_network.bayesian_network_gate import BayesianNetworkGate
+from cirq.contrib.bayesian_network.bayesian_network_gate import (
+    BayesianNetworkGate as BayesianNetworkGate,
+)

cirq/contrib/bayesian_network/bayesian_network_gate.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import math
-from typing import Any, cast, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
+from typing import Any, cast, Dict, Iterator, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 from sympy.combinatorics import GrayCode
 
@@ -158,7 +160,7 @@ class BayesianNetworkGate(raw_types.Gate):
                     raise ValueError('Conditional prob should be between 0 and 1.')
         self._arc_probs = arc_probs
 
-    def _decompose_(self, qubits: Sequence['raw_types.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         parameter_names = [init_prob[0] for init_prob in self._init_probs]
         qubit_map = dict(zip(parameter_names, qubits))
 
@@ -188,7 +190,7 @@ class BayesianNetworkGate(raw_types.Gate):
         init_probs: List[List[Union[str, Optional[float]]]],
         arc_probs: List[List[Union[str, List[str], List[float]]]],
         **kwargs,
-    ) -> 'BayesianNetworkGate':
+    ) -> BayesianNetworkGate:
         converted_init_probs = cast(
             List[Tuple[str, Optional[float]]],
             [(param, init_prob) for param, init_prob in init_probs],

cirq/contrib/circuitdag/__init__.py

@@ -14,4 +14,4 @@
 
 """Tools for representing a Circuit as a directed acyclic graph."""
 
-from cirq.contrib.circuitdag.circuit_dag import CircuitDag, Unique
+from cirq.contrib.circuitdag.circuit_dag import CircuitDag as CircuitDag, Unique as Unique

cirq/contrib/circuitdag/circuit_dag.py

@@ -11,16 +11,16 @@
 # 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 typing import Any, Callable, Dict, Generic, Iterator, TypeVar, cast, TYPE_CHECKING
+
+from __future__ import annotations
 
 import functools
+from typing import Any, Callable, cast, Dict, Generic, Iterator, TypeVar
+
 import networkx
 
+import cirq
 from cirq import ops
-from cirq.circuits import circuit
-
-if TYPE_CHECKING:
-    import cirq
 
 T = TypeVar('T')
 
@@ -50,7 +50,7 @@ class Unique(Generic[T]):
         return id(self) < id(other)
 
 
-def _disjoint_qubits(op1: 'cirq.Operation', op2: 'cirq.Operation') -> bool:
+def _disjoint_qubits(op1: cirq.Operation, op2: cirq.Operation) -> bool:
     """Returns true only if the operations have qubits in common."""
     return not set(op1.qubits) & set(op2.qubits)
 
@@ -72,7 +72,7 @@ class CircuitDag(networkx.DiGraph):
 
     def __init__(
         self,
-        can_reorder: Callable[['cirq.Operation', 'cirq.Operation'], bool] = _disjoint_qubits,
+        can_reorder: Callable[[cirq.Operation, cirq.Operation], bool] = _disjoint_qubits,
         incoming_graph_data: Any = None,
     ) -> None:
         """Initializes a CircuitDag.
@@ -93,27 +93,27 @@ class CircuitDag(networkx.DiGraph):
         self.can_reorder = can_reorder
 
     @staticmethod
-    def make_node(op: 'cirq.Operation') -> Unique:
+    def make_node(op: cirq.Operation) -> Unique:
         return Unique(op)
 
     @staticmethod
     def from_circuit(
-        circuit: circuit.Circuit,
-        can_reorder: Callable[['cirq.Operation', 'cirq.Operation'], bool] = _disjoint_qubits,
-    ) -> 'CircuitDag':
+        circuit: cirq.Circuit,
+        can_reorder: Callable[[cirq.Operation, cirq.Operation], bool] = _disjoint_qubits,
+    ) -> CircuitDag:
         return CircuitDag.from_ops(circuit.all_operations(), can_reorder=can_reorder)
 
     @staticmethod
     def from_ops(
-        *operations: 'cirq.OP_TREE',
-        can_reorder: Callable[['cirq.Operation', 'cirq.Operation'], bool] = _disjoint_qubits,
-    ) -> 'CircuitDag':
+        *operations: cirq.OP_TREE,
+        can_reorder: Callable[[cirq.Operation, cirq.Operation], bool] = _disjoint_qubits,
+    ) -> CircuitDag:
         dag = CircuitDag(can_reorder=can_reorder)
         for op in ops.flatten_op_tree(operations):
             dag.append(cast(ops.Operation, op))
         return dag
 
-    def append(self, op: 'cirq.Operation') -> None:
+    def append(self, op: cirq.Operation) -> None:
         new_node = self.make_node(op)
         for node in list(self.nodes()):
             if not self.can_reorder(node.val, op):
@@ -142,21 +142,21 @@ class CircuitDag(networkx.DiGraph):
 
     __hash__ = None  # type: ignore
 
-    def ordered_nodes(self) -> Iterator[Unique['cirq.Operation']]:
+    def ordered_nodes(self) -> Iterator[Unique[cirq.Operation]]:
         if not self.nodes():
             return
         g = self.copy()
 
-        def get_root_node(some_node: Unique['cirq.Operation']) -> Unique['cirq.Operation']:
+        def get_root_node(some_node: Unique[cirq.Operation]) -> Unique[cirq.Operation]:
             pred = g.pred
             while pred[some_node]:
                 some_node = next(iter(pred[some_node]))
             return some_node
 
-        def get_first_node() -> Unique['cirq.Operation']:
+        def get_first_node() -> Unique[cirq.Operation]:
             return get_root_node(next(iter(g.nodes())))
 
-        def get_next_node(succ: networkx.classes.coreviews.AtlasView) -> Unique['cirq.Operation']:
+        def get_next_node(succ: networkx.classes.coreviews.AtlasView) -> Unique[cirq.Operation]:
             if succ:
                 return get_root_node(next(iter(succ)))
 
@@ -173,18 +173,18 @@ class CircuitDag(networkx.DiGraph):
 
             node = get_next_node(succ)
 
-    def all_operations(self) -> Iterator['cirq.Operation']:
+    def all_operations(self) -> Iterator[cirq.Operation]:
         return (node.val for node in self.ordered_nodes())
 
     def all_qubits(self):
         return frozenset(q for node in self.nodes for q in node.val.qubits)
 
-    def to_circuit(self) -> circuit.Circuit:
-        return circuit.Circuit(self.all_operations(), strategy=circuit.InsertStrategy.EARLIEST)
+    def to_circuit(self) -> cirq.Circuit:
+        return cirq.Circuit(self.all_operations(), strategy=cirq.InsertStrategy.EARLIEST)
 
     def findall_nodes_until_blocked(
-        self, is_blocker: Callable[['cirq.Operation'], bool]
-    ) -> Iterator[Unique['cirq.Operation']]:
+        self, is_blocker: Callable[[cirq.Operation], bool]
+    ) -> Iterator[Unique[cirq.Operation]]:
         """Finds all nodes before blocking ones.
 
         Args: