cirq-core 1.5.0.dev20250403161251__py3-none-any.whl → 1.5.0.dev20250404021339__py3-none-any.whl

cirq/circuits/moment.py

@@ -14,6 +14,8 @@
 
 """A simplified time-slice of operations within a sequenced circuit."""
 
+from __future__ import annotations
+
 import itertools
 from functools import cached_property
 from types import NotImplementedType
@@ -55,7 +57,7 @@ text_diagram_drawer = LazyLoader(
 )
 
 
-def _default_breakdown(qid: 'cirq.Qid') -> Tuple[Any, Any]:
+def _default_breakdown(qid: cirq.Qid) -> Tuple[Any, Any]:
     # Attempt to convert into a position on the complex plane.
     try:
         plane_pos = complex(qid)  # type: ignore
@@ -82,7 +84,7 @@ class Moment:
             are no such operations, returns an empty Moment.
     """
 
-    def __init__(self, *contents: 'cirq.OP_TREE', _flatten_contents: bool = True) -> None:
+    def __init__(self, *contents: cirq.OP_TREE, _flatten_contents: bool = True) -> None:
         """Constructs a moment with the given operations.
 
         Args:
@@ -102,10 +104,10 @@ class Moment:
             if _flatten_contents
             else cast(Tuple['cirq.Operation'], contents)
         )
-        self._sorted_operations: Optional[Tuple['cirq.Operation', ...]] = None
+        self._sorted_operations: Optional[Tuple[cirq.Operation, ...]] = None
 
         # An internal dictionary to support efficient operation access by qubit.
-        self._qubit_to_op: Dict['cirq.Qid', 'cirq.Operation'] = {}
+        self._qubit_to_op: Dict[cirq.Qid, cirq.Operation] = {}
         for op in self.operations:
             for q in op.qubits:
                 # Check that operations don't overlap.
@@ -113,11 +115,11 @@ class Moment:
                     raise ValueError(f'Overlapping operations: {self.operations}')
                 self._qubit_to_op[q] = op
 
-        self._measurement_key_objs: Optional[FrozenSet['cirq.MeasurementKey']] = None
-        self._control_keys: Optional[FrozenSet['cirq.MeasurementKey']] = None
+        self._measurement_key_objs: Optional[FrozenSet[cirq.MeasurementKey]] = None
+        self._control_keys: Optional[FrozenSet[cirq.MeasurementKey]] = None
 
     @classmethod
-    def from_ops(cls, *ops: 'cirq.Operation') -> 'cirq.Moment':
+    def from_ops(cls, *ops: cirq.Operation) -> cirq.Moment:
         """Construct a Moment from the given operations.
 
         This avoids calling `flatten_to_ops` in the moment constructor, which
@@ -131,14 +133,14 @@ class Moment:
         return cls(*ops, _flatten_contents=False)
 
     @property
-    def operations(self) -> Tuple['cirq.Operation', ...]:
+    def operations(self) -> Tuple[cirq.Operation, ...]:
         return self._operations
 
     @cached_property
-    def qubits(self) -> FrozenSet['cirq.Qid']:
+    def qubits(self) -> FrozenSet[cirq.Qid]:
         return frozenset(self._qubit_to_op)
 
-    def operates_on_single_qubit(self, qubit: 'cirq.Qid') -> bool:
+    def operates_on_single_qubit(self, qubit: cirq.Qid) -> bool:
         """Determines if the moment has operations touching the given qubit.
         Args:
             qubit: The qubit that may or may not be touched by operations.
@@ -147,7 +149,7 @@ class Moment:
         """
         return qubit in self._qubit_to_op
 
-    def operates_on(self, qubits: Iterable['cirq.Qid']) -> bool:
+    def operates_on(self, qubits: Iterable[cirq.Qid]) -> bool:
         """Determines if the moment has operations touching the given qubits.
 
         Args:
@@ -158,7 +160,7 @@ class Moment:
         """
         return not self._qubit_to_op.keys().isdisjoint(qubits)
 
-    def operation_at(self, qubit: raw_types.Qid) -> Optional['cirq.Operation']:
+    def operation_at(self, qubit: raw_types.Qid) -> Optional[cirq.Operation]:
         """Returns the operation on a certain qubit for the moment.
 
         Args:
@@ -172,7 +174,7 @@ class Moment:
             return self.__getitem__(qubit)
         return None
 
-    def with_operation(self, operation: 'cirq.Operation') -> 'cirq.Moment':
+    def with_operation(self, operation: cirq.Operation) -> cirq.Moment:
         """Returns an equal moment, but with the given op added.
 
         Args:
@@ -200,7 +202,7 @@ class Moment:
 
         return m
 
-    def with_operations(self, *contents: 'cirq.OP_TREE') -> 'cirq.Moment':
+    def with_operations(self, *contents: cirq.OP_TREE) -> cirq.Moment:
         """Returns a new moment with the given contents added.
 
         Args:
@@ -237,7 +239,7 @@ class Moment:
 
         return m
 
-    def without_operations_touching(self, qubits: Iterable['cirq.Qid']) -> 'cirq.Moment':
+    def without_operations_touching(self, qubits: Iterable[cirq.Qid]) -> cirq.Moment:
         """Returns an equal moment, but without ops on the given qubits.
 
         Args:
@@ -263,11 +265,9 @@ class Moment:
     def _parameter_names_(self) -> AbstractSet[str]:
         return {name for op in self for name in protocols.parameter_names(op)}
 
-    def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'cirq.Moment':
+    def _resolve_parameters_(self, resolver: cirq.ParamResolver, recursive: bool) -> cirq.Moment:
         changed = False
-        resolved_ops: List['cirq.Operation'] = []
+        resolved_ops: List[cirq.Operation] = []
         for op in self:
             resolved_op = protocols.resolve_parameters(op, resolver, recursive)
             changed = (
@@ -294,21 +294,21 @@ class Moment:
     def _measurement_key_names_(self) -> FrozenSet[str]:
         return frozenset(str(key) for key in self._measurement_key_objs_())
 
-    def _measurement_key_objs_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _measurement_key_objs_(self) -> FrozenSet[cirq.MeasurementKey]:
         if self._measurement_key_objs is None:
             self._measurement_key_objs = frozenset(
                 key for op in self.operations for key in protocols.measurement_key_objs(op)
             )
         return self._measurement_key_objs
 
-    def _control_keys_(self) -> FrozenSet['cirq.MeasurementKey']:
+    def _control_keys_(self) -> FrozenSet[cirq.MeasurementKey]:
         if self._control_keys is None:
             self._control_keys = frozenset(
                 k for op in self.operations for k in protocols.control_keys(op)
             )
         return self._control_keys
 
-    def _sorted_operations_(self) -> Tuple['cirq.Operation', ...]:
+    def _sorted_operations_(self) -> Tuple[cirq.Operation, ...]:
         if self._sorted_operations is None:
             self._sorted_operations = tuple(sorted(self._operations, key=lambda op: op.qubits))
         return self._sorted_operations
@@ -330,7 +330,7 @@ class Moment:
         )
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
+        self, path: Tuple[str, ...], bindable_keys: FrozenSet[cirq.MeasurementKey]
     ):
         return Moment(
             protocols.with_rescoped_keys(op, path, bindable_keys) for op in self.operations
@@ -373,7 +373,7 @@ class Moment:
             del state[hash_attr]
         return state
 
-    def __iter__(self) -> Iterator['cirq.Operation']:
+    def __iter__(self) -> Iterator[cirq.Operation]:
         return iter(self.operations)
 
     def __pow__(self, power):
@@ -402,12 +402,12 @@ class Moment:
     def __str__(self) -> str:
         return self.to_text_diagram()
 
-    def _decompose_(self) -> 'cirq.OP_TREE':
+    def _decompose_(self) -> cirq.OP_TREE:
         """See `cirq.SupportsDecompose`."""
         return self._operations
 
     def transform_qubits(
-        self, qubit_map: Union[Dict['cirq.Qid', 'cirq.Qid'], Callable[['cirq.Qid'], 'cirq.Qid']]
+        self, qubit_map: Union[Dict[cirq.Qid, cirq.Qid], Callable[[cirq.Qid], cirq.Qid]]
     ) -> Self:
         """Returns the same moment, but with different qubits.
 
@@ -421,7 +421,7 @@ class Moment:
         """
         return self.__class__(op.transform_qubits(qubit_map) for op in self.operations)
 
-    def expand_to(self, qubits: Iterable['cirq.Qid']) -> 'cirq.Moment':
+    def expand_to(self, qubits: Iterable[cirq.Qid]) -> cirq.Moment:
         """Returns self expanded to given superset of qubits by making identities explicit.
 
         Args:
@@ -480,13 +480,13 @@ class Moment:
         qubit_to_row_subscript = dict(zip(qubits, 'abcdefghij'))
         qubit_to_col_subscript = dict(zip(qubits, 'ABCDEFGHIJ'))
 
-        def row_subscripts(qs: Sequence['cirq.Qid']) -> str:
+        def row_subscripts(qs: Sequence[cirq.Qid]) -> str:
             return ''.join(qubit_to_row_subscript[q] for q in qs)
 
-        def col_subscripts(qs: Sequence['cirq.Qid']) -> str:
+        def col_subscripts(qs: Sequence[cirq.Qid]) -> str:
             return ''.join(qubit_to_col_subscript[q] for q in qs)
 
-        def kraus_tensors(op: 'cirq.Operation') -> Sequence[np.ndarray]:
+        def kraus_tensors(op: cirq.Operation) -> Sequence[np.ndarray]:
             return tuple(np.reshape(k, (2, 2) * len(op.qubits)) for k in protocols.kraus(op))
 
         input_subscripts = ','.join(
@@ -523,12 +523,12 @@ class Moment:
     def _from_json_dict_(cls, operations, **kwargs):
         return cls.from_ops(*operations)
 
-    def __add__(self, other: 'cirq.OP_TREE') -> 'cirq.Moment':
+    def __add__(self, other: cirq.OP_TREE) -> cirq.Moment:
         if isinstance(other, circuit.AbstractCircuit):
             return NotImplemented  # Delegate to Circuit.__radd__.
         return self.with_operations(other)
 
-    def __sub__(self, other: 'cirq.OP_TREE') -> 'cirq.Moment':
+    def __sub__(self, other: cirq.OP_TREE) -> cirq.Moment:
         must_remove = set(op_tree.flatten_to_ops(other))
         new_ops = []
         for op in self.operations:
@@ -546,11 +546,11 @@ class Moment:
 
     # pylint: disable=function-redefined
     @overload
-    def __getitem__(self, key: raw_types.Qid) -> 'cirq.Operation':
+    def __getitem__(self, key: raw_types.Qid) -> cirq.Operation:
         pass
 
     @overload
-    def __getitem__(self, key: Iterable[raw_types.Qid]) -> 'cirq.Moment':
+    def __getitem__(self, key: Iterable[raw_types.Qid]) -> cirq.Moment:
         pass
 
     def __getitem__(self, key):
@@ -567,10 +567,10 @@ class Moment:
             return Moment(frozenset(ops_to_keep))
 
     def to_text_diagram(
-        self: 'cirq.Moment',
+        self: cirq.Moment,
         *,
-        xy_breakdown_func: Callable[['cirq.Qid'], Tuple[Any, Any]] = _default_breakdown,
-        extra_qubits: Iterable['cirq.Qid'] = (),
+        xy_breakdown_func: Callable[[cirq.Qid], Tuple[Any, Any]] = _default_breakdown,
+        extra_qubits: Iterable[cirq.Qid] = (),
         use_unicode_characters: bool = True,
         precision: Optional[int] = None,
         include_tags: bool = True,

cirq/circuits/optimization_pass.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Defines the OptimizationPass type."""
+
+from __future__ import annotations
+
 import abc
 from collections import defaultdict
 from typing import Callable, cast, Dict, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING
@@ -21,7 +24,6 @@ from cirq import ops
 
 if TYPE_CHECKING:
     import cirq
-    from cirq.ops import Qid
 
 
 class PointOptimizationSummary:
@@ -30,8 +32,8 @@ class PointOptimizationSummary:
     def __init__(
         self,
         clear_span: int,
-        clear_qubits: Iterable['cirq.Qid'],
-        new_operations: 'cirq.OP_TREE',
+        clear_qubits: Iterable[cirq.Qid],
+        new_operations: cirq.OP_TREE,
         preserve_moments: bool = False,
     ) -> None:
         """Inits PointOptimizationSummary.
@@ -87,9 +89,7 @@ class PointOptimizer:
 
     def __init__(
         self,
-        post_clean_up: Callable[
-            [Sequence['cirq.Operation']], 'cirq.OP_TREE'
-        ] = lambda op_list: op_list,
+        post_clean_up: Callable[[Sequence[cirq.Operation]], cirq.OP_TREE] = lambda op_list: op_list,
     ) -> None:
         """Inits PointOptimizer.
 
@@ -100,13 +100,13 @@ class PointOptimizer:
         """
         self.post_clean_up = post_clean_up
 
-    def __call__(self, circuit: 'cirq.Circuit'):
+    def __call__(self, circuit: cirq.Circuit):
         return self.optimize_circuit(circuit)
 
     @abc.abstractmethod
     def optimization_at(
-        self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-    ) -> Optional['cirq.PointOptimizationSummary']:
+        self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+    ) -> Optional[cirq.PointOptimizationSummary]:
         """Describes how to change operations near the given location.
 
         For example, this method could realize that the given operation is an
@@ -126,8 +126,8 @@ class PointOptimizer:
             change should be made.
         """
 
-    def optimize_circuit(self, circuit: 'cirq.Circuit'):
-        frontier: Dict['Qid', int] = defaultdict(lambda: 0)
+    def optimize_circuit(self, circuit: cirq.Circuit):
+        frontier: Dict[cirq.Qid, int] = defaultdict(lambda: 0)
         i = 0
         while i < len(circuit):  # Note: circuit may mutate as we go.
             for op in circuit[i].operations:

cirq/circuits/optimization_pass_test.py

@@ -11,7 +11,8 @@
 # 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 List, Optional, Set, TYPE_CHECKING
+
+from typing import List, Optional, Set
 
 import pytest
 
@@ -19,9 +20,6 @@ import cirq
 from cirq import Operation, PointOptimizationSummary, PointOptimizer
 from cirq.testing import EqualsTester
 
-if TYPE_CHECKING:
-    import cirq
-
 
 def test_equality():
     a = cirq.NamedQubit('a')
@@ -63,8 +61,8 @@ class ReplaceWithXGates(PointOptimizer):
     """
 
     def optimization_at(
-        self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-    ) -> Optional['cirq.PointOptimizationSummary']:
+        self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+    ) -> Optional[cirq.PointOptimizationSummary]:
         end = index + 1
         new_ops = [cirq.X(q) for q in op.qubits]
         done = False
@@ -157,8 +155,8 @@ def test_point_optimizer_raises_on_gates_changing_qubits():
         """Changes all single qubit operations to act on LineQubit(42)"""
 
         def optimization_at(
-            self, circuit: 'cirq.Circuit', index: int, op: 'cirq.Operation'
-        ) -> Optional['cirq.PointOptimizationSummary']:
+            self, circuit: cirq.Circuit, index: int, op: cirq.Operation
+        ) -> Optional[cirq.PointOptimizationSummary]:
             new_op = op
             if len(op.qubits) == 1 and isinstance(op, cirq.GateOperation):
                 new_op = op.gate(cirq.LineQubit(42))

cirq/circuits/qasm_output.py

@@ -14,6 +14,8 @@
 
 """Utility classes for representing QASM."""
 
+from __future__ import annotations
+
 import re
 from typing import Callable, Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
@@ -46,14 +48,14 @@ class QasmUGate(ops.Gate):
         return 1
 
     @staticmethod
-    def from_matrix(mat: np.ndarray) -> 'QasmUGate':
+    def from_matrix(mat: np.ndarray) -> QasmUGate:
         pre_phase, rotation, post_phase = linalg.deconstruct_single_qubit_matrix_into_angles(mat)
         return QasmUGate(rotation / np.pi, post_phase / np.pi, pre_phase / np.pi)
 
     def _has_unitary_(self):
         return True
 
-    def _qasm_(self, qubits: Tuple['cirq.Qid', ...], args: 'cirq.QasmArgs') -> str:
+    def _qasm_(self, qubits: Tuple[cirq.Qid, ...], args: cirq.QasmArgs) -> str:
         args.validate_version('2.0', '3.0')
         return args.format(
             'u3({0:half_turns},{1:half_turns},{2:half_turns}) {3};\n',
@@ -86,13 +88,13 @@ class QasmUGate(ops.Gate):
         return {'theta': self.theta, 'phi': self.phi, 'lmda': self.lmda}
 
     @classmethod
-    def _from_json_dict_(cls, theta: float, phi: float, lmda: float, **kwargs) -> 'QasmUGate':
+    def _from_json_dict_(cls, theta: float, phi: float, lmda: float, **kwargs) -> QasmUGate:
         return cls(theta, phi, lmda)
 
 
 @value.value_equality
 class QasmTwoQubitGate(ops.Gate):
-    def __init__(self, kak: 'cirq.KakDecomposition') -> None:
+    def __init__(self, kak: cirq.KakDecomposition) -> None:
         """A two qubit gate represented in QASM by the KAK decomposition.
 
         All angles are in half turns.  Assumes a canonicalized KAK
@@ -110,7 +112,7 @@ class QasmTwoQubitGate(ops.Gate):
         return self.kak
 
     @staticmethod
-    def from_matrix(mat: np.ndarray, atol=1e-8) -> 'QasmTwoQubitGate':
+    def from_matrix(mat: np.ndarray, atol=1e-8) -> QasmTwoQubitGate:
         """Creates a QasmTwoQubitGate from the given matrix.
 
         Args:
@@ -126,7 +128,7 @@ class QasmTwoQubitGate(ops.Gate):
     def _unitary_(self):
         return protocols.unitary(self.kak)
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         q0, q1 = qubits
         x, y, z = self.kak.interaction_coefficients
         a = x * -2 / np.pi + 0.5
@@ -170,8 +172,8 @@ class QasmOutput:
 
     def __init__(
         self,
-        operations: 'cirq.OP_TREE',
-        qubits: Tuple['cirq.Qid', ...],
+        operations: cirq.OP_TREE,
+        qubits: Tuple[cirq.Qid, ...],
         header: str = '',
         precision: int = 10,
         version: str = '2.0',
@@ -225,7 +227,7 @@ class QasmOutput:
             meas_key_id_map[key] = meas_id
         return meas_key_id_map, meas_comments
 
-    def _generate_qubit_ids(self) -> Dict['cirq.Qid', str]:
+    def _generate_qubit_ids(self) -> Dict[cirq.Qid, str]:
         return {qubit: f'q[{i}]' for i, qubit in enumerate(self.qubits)}
 
     def _generate_cregs(self, meas_key_id_map: Dict[str, str]) -> Dict[str, tuple[int, str]]:
@@ -333,11 +335,11 @@ class QasmOutput:
 
     def _write_operations(
         self,
-        op_tree: 'cirq.OP_TREE',
+        op_tree: cirq.OP_TREE,
         output: Callable[[str], None],
         output_line_gap: Callable[[int], None],
     ) -> None:
-        def keep(op: 'cirq.Operation') -> bool:
+        def keep(op: cirq.Operation) -> bool:
             return protocols.qasm(op, args=self.args, default=None) is not None
 
         def fallback(op):

cirq/circuits/text_diagram_drawer.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import (
     Any,
     Callable,
@@ -171,7 +173,7 @@ class TextDiagramDrawer:
         x1, x2 = sorted([x1, x2])
         self.horizontal_lines.append(_HorizontalLine(y, x1, x2, emphasize, doubled))
 
-    def transpose(self) -> 'cirq.TextDiagramDrawer':
+    def transpose(self) -> cirq.TextDiagramDrawer:
         """Returns the same diagram, but mirrored across its diagonal."""
         out = TextDiagramDrawer()
         out.entries = {
@@ -333,14 +335,14 @@ class TextDiagramDrawer:
             horizontal_padding=self.horizontal_padding,
         )
 
-    def shift(self, dx: int = 0, dy: int = 0) -> 'cirq.TextDiagramDrawer':
+    def shift(self, dx: int = 0, dy: int = 0) -> cirq.TextDiagramDrawer:
         self._transform_coordinates(lambda x, y: (x + dx, y + dy))
         return self
 
-    def shifted(self, dx: int = 0, dy: int = 0) -> 'cirq.TextDiagramDrawer':
+    def shifted(self, dx: int = 0, dy: int = 0) -> cirq.TextDiagramDrawer:
         return self.copy().shift(dx, dy)
 
-    def superimpose(self, other: 'cirq.TextDiagramDrawer') -> 'cirq.TextDiagramDrawer':
+    def superimpose(self, other: cirq.TextDiagramDrawer) -> cirq.TextDiagramDrawer:
         self.entries.update(other.entries)
         self.horizontal_lines += other.horizontal_lines
         self.vertical_lines += other.vertical_lines
@@ -348,13 +350,13 @@ class TextDiagramDrawer:
         self.vertical_padding.update(other.vertical_padding)
         return self
 
-    def superimposed(self, other: 'cirq.TextDiagramDrawer') -> 'cirq.TextDiagramDrawer':
+    def superimposed(self, other: cirq.TextDiagramDrawer) -> cirq.TextDiagramDrawer:
         return self.copy().superimpose(other)
 
     @classmethod
     def vstack(
         cls,
-        diagrams: Sequence['cirq.TextDiagramDrawer'],
+        diagrams: Sequence[cirq.TextDiagramDrawer],
         padding_resolver: Optional[Callable[[Sequence[Optional[int]]], int]] = None,
     ):
         """Vertically stack text diagrams.
@@ -395,7 +397,7 @@ class TextDiagramDrawer:
     @classmethod
     def hstack(
         cls,
-        diagrams: Sequence['cirq.TextDiagramDrawer'],
+        diagrams: Sequence[cirq.TextDiagramDrawer],
         padding_resolver: Optional[Callable[[Sequence[Optional[int]]], int]] = None,
     ):
         """Horizontally stack text diagrams.

cirq/contrib/acquaintance/bipartite.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import enum
 import itertools
 from typing import Dict, Iterator, Sequence, Tuple, TYPE_CHECKING, Union
@@ -62,7 +64,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
         self,
         subgraph: Union[str, BipartiteGraphType],
         part_size: int,
-        swap_gate: 'cirq.Gate' = ops.SWAP,
+        swap_gate: cirq.Gate = ops.SWAP,
     ) -> None:
         super().__init__(2 * part_size, swap_gate)
         self.part_size = part_size
@@ -71,7 +73,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
         )
         self.swap_gate = swap_gate
 
-    def decompose_complete(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def decompose_complete(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         swap_gate = SwapPermutationGate(self.swap_gate)
         if self.part_size == 1:
             yield acquaint(*qubits)
@@ -86,7 +88,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
                 yield acquaint(*qubits[x : x + 2])
                 yield swap_gate(*qubits[x : x + 2])
 
-    def decompose_matching(self, qubits: Sequence['cirq.Qid']) -> Iterator['cirq.OP_TREE']:
+    def decompose_matching(self, qubits: Sequence[cirq.Qid]) -> Iterator[cirq.OP_TREE]:
         swap_gate = SwapPermutationGate(self.swap_gate)
         for k in range(-self.part_size + 1, self.part_size):
             for x in range(abs(k), 2 * self.part_size - abs(k), 2):
@@ -95,7 +97,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
                 else:
                     yield acquaint(*qubits[x : x + 2])
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         if len(qubits) != 2 * self.part_size:
             raise ValueError('len(qubits) != 2 * self.part_size')
         if self.subgraph == BipartiteGraphType.COMPLETE:
@@ -122,7 +124,7 @@ class BipartiteSwapNetworkGate(PermutationGate):
             return dict(enumerate(range(2 * self.part_size)))
         raise NotImplementedError(str(self.subgraph) + 'not implemented')
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         qubit_count = 2 * self.part_size
         if args.known_qubit_count not in (None, qubit_count):
             raise ValueError('args.known_qubit_count not in (None, 2 * self.part_size)')

cirq/contrib/acquaintance/devices.py

@@ -12,6 +12,8 @@
 # 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, Union
 
@@ -30,7 +32,7 @@ class AcquaintanceDevice(devices.Device, metaclass=abc.ABCMeta):
 
     gate_types = (AcquaintanceOpportunityGate, PermutationGate)
 
-    def validate_operation(self, operation: 'cirq.Operation') -> None:
+    def validate_operation(self, operation: cirq.Operation) -> None:
         if not (
             isinstance(operation, ops.GateOperation) and isinstance(operation.gate, self.gate_types)
         ):