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

cirq/experiments/z_phase_calibration_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 numpy as np
 import pandas as pd
 import pytest
@@ -72,10 +74,7 @@ class _TestSimulator(cirq.Simulator):
         self.replacement = replacement
 
     def _core_iterator(
-        self,
-        circuit: 'cirq.AbstractCircuit',
-        sim_state,
-        all_measurements_are_terminal: bool = False,
+        self, circuit: cirq.AbstractCircuit, sim_state, all_measurements_are_terminal: bool = False
     ):
         new_circuit = cirq.Circuit(
             [

cirq/interop/quirk/cells/__init__.py

@@ -37,4 +37,4 @@ from cirq.interop.quirk.cells.input_rotation_cells import (
 )
 
 import cirq.interop.quirk.cells.swap_cell
-import cirq.interop.quirk.cells.control_cells
+import cirq.interop.quirk.cells.control_cells  # noqa: F401

cirq/interop/quirk/cells/all_cells.py

@@ -11,10 +11,12 @@
 # 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 Iterator
+
+from __future__ import annotations
+
+from typing import Iterator, TYPE_CHECKING
 
 from cirq.interop.quirk.cells.arithmetic_cells import generate_all_arithmetic_cell_makers
-from cirq.interop.quirk.cells.cell import CellMaker
 from cirq.interop.quirk.cells.control_cells import generate_all_control_cell_makers
 from cirq.interop.quirk.cells.frequency_space_cells import generate_all_frequency_space_cell_makers
 from cirq.interop.quirk.cells.ignored_cells import generate_all_ignored_cell_makers
@@ -31,6 +33,9 @@ from cirq.interop.quirk.cells.single_qubit_rotation_cells import (
 from cirq.interop.quirk.cells.swap_cell import generate_all_swap_cell_makers
 from cirq.interop.quirk.cells.unsupported_cells import generate_all_unsupported_cell_makers
 
+if TYPE_CHECKING:
+    from cirq.interop.quirk.cells.cell import CellMaker
+
 
 def generate_all_quirk_cell_makers() -> Iterator[CellMaker]:
     """Yields a `CellMaker` for every known Quirk gate, display, etc."""

cirq/interop/quirk/cells/arithmetic_cells.py

@@ -11,21 +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.
+
+from __future__ import annotations
+
 import inspect
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, cast, Iterable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.interop.quirk.cells.cell import Cell, CELL_SIZES, CellMaker
@@ -49,7 +39,7 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
     """
 
     def __init__(
-        self, identifier: str, target: Sequence[int], inputs: Sequence[Union[Sequence[int], int]]
+        self, identifier: str, target: Sequence[int], inputs: Sequence[Sequence[int] | int]
     ):
         """Inits QuirkArithmeticGate.
 
@@ -65,8 +55,8 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
                 too small modulus.
         """
         self.identifier = identifier
-        self.target: Tuple[int, ...] = tuple(target)
-        self.inputs: Tuple[Union[Sequence[int], int], ...] = tuple(
+        self.target: tuple[int, ...] = tuple(target)
+        self.inputs: tuple[Sequence[int] | int, ...] = tuple(
             e if isinstance(e, int) else tuple(e) for e in inputs
         )
 
@@ -80,16 +70,16 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
                 raise ValueError(f'Target too small for modulus.\nTarget: {target}\nModulus: {r}')
 
     @property
-    def operation(self) -> '_QuirkArithmeticCallable':
+    def operation(self) -> _QuirkArithmeticCallable:
         return ARITHMETIC_OP_TABLE[self.identifier]
 
     def _value_equality_values_(self) -> Any:
         return self.identifier, self.target, self.inputs
 
-    def registers(self) -> Sequence[Union[int, Sequence[int]]]:
+    def registers(self) -> Sequence[int | Sequence[int]]:
         return [self.target, *self.inputs]
 
-    def with_registers(self, *new_registers: Union[int, Sequence[int]]) -> 'QuirkArithmeticGate':
+    def with_registers(self, *new_registers: int | Sequence[int]) -> QuirkArithmeticGate:
         if len(new_registers) != len(self.inputs) + 1:
             raise ValueError(
                 'Wrong number of registers.\n'
@@ -106,13 +96,13 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
 
         return QuirkArithmeticGate(self.identifier, new_registers[0], new_registers[1:])
 
-    def apply(self, *registers: int) -> Union[int, Iterable[int]]:
+    def apply(self, *registers: int) -> int | Iterable[int]:
         return self.operation(*registers)
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> List[str]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> list[str]:
         lettered_args = list(zip(self.operation.letters, self.inputs))
 
-        result: List[str] = []
+        result: list[str] = []
 
         # Target register labels.
         consts = ''.join(
@@ -138,12 +128,12 @@ class QuirkArithmeticGate(ops.ArithmeticGate):
         )
 
 
-_IntsToIntCallable = Union[
-    Callable[[int], int],
-    Callable[[int, int], int],
-    Callable[[int, int, int], int],
-    Callable[[int, int, int, int], int],
-]
+_IntsToIntCallable = (
+    Callable[[int], int]
+    | Callable[[int, int], int]
+    | Callable[[int, int, int], int]
+    | Callable[[int, int, int, int], int]
+)
 
 
 class _QuirkArithmeticCallable:
@@ -158,7 +148,7 @@ class _QuirkArithmeticCallable:
         self.func = func
 
         # The lambda parameter names indicate the input letter to match.
-        letters: List[str] = list(inspect.signature(self.func).parameters)
+        letters: list[str] = list(inspect.signature(self.func).parameters)
         # The target is always first, and should be ignored.
         assert letters and letters[0] == 'x'
         self.letters = tuple(letters[1:])
@@ -183,8 +173,8 @@ class ArithmeticCell(Cell):
     def __init__(
         self,
         identifier: str,
-        target: Sequence['cirq.Qid'],
-        inputs: Sequence[Union[None, Sequence['cirq.Qid'], int]],
+        target: Sequence[cirq.Qid],
+        inputs: Sequence[None | Sequence[cirq.Qid] | int],
     ):
         self.identifier = identifier
         self.target = tuple(target)
@@ -204,7 +194,7 @@ class ArithmeticCell(Cell):
             f'\n    {self.inputs!r})'
         )
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return ArithmeticCell(
             identifier=self.identifier,
             target=Cell._replace_qubits(self.target, qubits),
@@ -218,23 +208,21 @@ class ArithmeticCell(Cell):
     def operation(self):
         return ARITHMETIC_OP_TABLE[self.identifier]
 
-    def with_input(
-        self, letter: str, register: Union[Sequence['cirq.Qid'], int]
-    ) -> 'ArithmeticCell':
+    def with_input(self, letter: str, register: Sequence[cirq.Qid] | int) -> ArithmeticCell:
         new_inputs = [
             reg if letter != reg_letter else register
             for reg, reg_letter in zip(self.inputs, self.operation.letters)
         ]
         return ArithmeticCell(self.identifier, self.target, new_inputs)
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         missing_inputs = [
             letter for reg, letter in zip(self.inputs, self.operation.letters) if reg is None
         ]
         if missing_inputs:
             raise ValueError(f'Missing input: {sorted(missing_inputs)}')
 
-        inputs = cast(Sequence[Union[Sequence['cirq.Qid'], int]], self.inputs)
+        inputs = cast(Sequence[Sequence['cirq.Qid'] | int], self.inputs)
         qubits = self.target + tuple(q for i in self.inputs if isinstance(i, Sequence) for q in i)
         return QuirkArithmeticGate(
             self.identifier,
@@ -303,7 +291,7 @@ def _generate_helper() -> Iterator[CellMaker]:
     )
 
 
-def _extended_gcd(a: int, b: int) -> Tuple[int, int, int]:
+def _extended_gcd(a: int, b: int) -> tuple[int, int, int]:
     if a == 0:
         return b, 0, 1
     gcd, y, x = _extended_gcd(b % a, a)
@@ -359,9 +347,9 @@ def _arithmetic_gate(identifier: str, size: int, func: _IntsToIntCallable) -> Ce
     )
 
 
-ARITHMETIC_OP_TABLE: Dict[str, _QuirkArithmeticCallable] = {}
+ARITHMETIC_OP_TABLE: dict[str, _QuirkArithmeticCallable] = {}
 # Caching is necessary in order to avoid overwriting entries in the table.
-_cached_cells: Optional[Tuple[CellMaker, ...]] = None
+_cached_cells: tuple[CellMaker, ...] | None = None
 
 
 def generate_all_arithmetic_cell_makers() -> Iterable[CellMaker]:

cirq/interop/quirk/cells/arithmetic_cells_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
+
 from typing import cast
 
 import numpy as np
@@ -22,7 +25,7 @@ from cirq.interop.quirk.cells import arithmetic_cells
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_arithmetic_comparison_gates():
+def test_arithmetic_comparison_gates() -> None:
     with pytest.raises(ValueError, match='Missing input'):
         _ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={"cols":[["^A<B"]]}')
     assert_url_to_circuit_returns(
@@ -73,7 +76,7 @@ def test_arithmetic_comparison_gates():
     )
 
 
-def test_arithmetic_unlisted_misc_gates():
+def test_arithmetic_unlisted_misc_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["^=A3",1,1,"inputA2"]]}',
         maps={
@@ -141,7 +144,7 @@ def test_arithmetic_unlisted_misc_gates():
     )
 
 
-def test_arithmetic_addition_gates():
+def test_arithmetic_addition_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["inc3"]]}',
         diagram="""
@@ -164,7 +167,7 @@ def test_arithmetic_addition_gates():
     )
 
 
-def test_arithmetic_multiply_accumulate_gates():
+def test_arithmetic_multiply_accumulate_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["+=AA4",1,1,1,"inputA2"]]}',
         maps={0b_0000_00: 0b_0000_00, 0b_0100_10: 0b_1000_10, 0b_1000_11: 0b_0001_11},
@@ -186,7 +189,7 @@ def test_arithmetic_multiply_accumulate_gates():
     )
 
 
-def test_modular_arithmetic_modulus_size():
+def test_modular_arithmetic_modulus_size() -> None:
     with pytest.raises(ValueError, match='too small for modulus'):
         _ = quirk_url_to_circuit(
             'https://algassert.com/quirk#circuit={"cols":['
@@ -208,7 +211,7 @@ def test_modular_arithmetic_modulus_size():
     assert_url_to_circuit_returns('{"cols":[["incmodR2",1,"inputR2"]]}')
 
 
-def test_arithmetic_modular_addition_gates():
+def test_arithmetic_modular_addition_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[[{"id":"setR","arg":16}],["incmodR4"]]}',
         diagram="""
@@ -242,7 +245,7 @@ def test_arithmetic_modular_addition_gates():
     )
 
 
-def test_arithmetic_modular_multiply_accumulate_gates():
+def test_arithmetic_modular_multiply_accumulate_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[[{"id":"setR","arg":5},{"id":"setA","arg":3},'
         '{"id":"setB","arg":4}],["+ABmodR4"]]}',
@@ -256,7 +259,7 @@ def test_arithmetic_modular_multiply_accumulate_gates():
     )
 
 
-def test_arithmetic_multiply_gates():
+def test_arithmetic_multiply_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[[{"id":"setA","arg":3}],["*A4"]]}', maps={0: 0, 1: 3, 3: 9, 9: 11, 11: 1}
     )
@@ -273,7 +276,7 @@ def test_arithmetic_multiply_gates():
     )
 
 
-def test_arithmetic_modular_multiply_gates():
+def test_arithmetic_modular_multiply_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[[{"id":"setA","arg":3},{"id":"setR","arg":7}],["*AmodR4"]]}',
         maps={0: 0, 1: 3, 3: 2, 2: 6, 6: 4, 4: 5, 5: 1, 7: 7, 15: 15},
@@ -294,7 +297,7 @@ def test_arithmetic_modular_multiply_gates():
     )
 
 
-def test_arithmetic_modular_exponentiation_gates():
+def test_arithmetic_modular_exponentiation_gates() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[[{"id":"setA","arg":5},{"id":"setB","arg":3},'
         '{"id":"setR","arg":7}],["*BToAmodR4"]]}',
@@ -318,7 +321,7 @@ def test_arithmetic_modular_exponentiation_gates():
     )
 
 
-def test_repr():
+def test_repr() -> None:
     circuit = quirk_url_to_circuit(
         'https://algassert.com/quirk#circuit={"cols":'
         '['
@@ -336,7 +339,7 @@ def test_repr():
     )
 
 
-def test_with_registers():
+def test_with_registers() -> None:
     circuit = quirk_url_to_circuit(
         'https://algassert.com/quirk#circuit={"cols":'
         '['
@@ -363,7 +366,7 @@ def test_with_registers():
     )
 
 
-def test_helpers():
+def test_helpers() -> None:
     f = arithmetic_cells._popcnt
     assert f(0) == 0
     assert f(1) == 1
@@ -414,7 +417,7 @@ def test_helpers():
     assert h(7, 16) == 7
 
 
-def test_with_line_qubits_mapped_to():
+def test_with_line_qubits_mapped_to() -> None:
     a, b, c, d, e = cirq.LineQubit.range(5)
     a2, b2, c2, d2, e2 = cirq.NamedQubit.range(5, prefix='p')
 

cirq/interop/quirk/cells/cell.py

@@ -11,20 +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.
+
+from __future__ import annotations
+
 import abc
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    NamedTuple,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+from typing import Any, Callable, Iterable, NamedTuple, Sequence, TYPE_CHECKING, Union
 
 from cirq import devices, ops, value
 
@@ -41,7 +32,7 @@ class Cell(metaclass=abc.ABCMeta):
     """
 
     @classmethod
-    def _replace_qubit(cls, old_qubit: 'cirq.Qid', qubits: List['cirq.Qid']) -> 'cirq.Qid':
+    def _replace_qubit(cls, old_qubit: cirq.Qid, qubits: list[cirq.Qid]) -> cirq.Qid:
         if not isinstance(old_qubit, devices.LineQubit):
             raise ValueError(f'Can only map from line qubits, but got {old_qubit!r}.')
         if not 0 <= old_qubit.x < len(qubits):
@@ -50,12 +41,12 @@ class Cell(metaclass=abc.ABCMeta):
 
     @classmethod
     def _replace_qubits(
-        cls, old_qubits: Iterable['cirq.Qid'], qubits: List['cirq.Qid']
-    ) -> Tuple['cirq.Qid', ...]:
+        cls, old_qubits: Iterable[cirq.Qid], qubits: list[cirq.Qid]
+    ) -> tuple[cirq.Qid, ...]:
         return tuple(Cell._replace_qubit(e, qubits) for e in old_qubits)
 
     @abc.abstractmethod
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         """Returns the same cell, but targeting different qubits.
 
         It is assumed that the cell is currently targeting `LineQubit`
@@ -84,7 +75,7 @@ class Cell(metaclass=abc.ABCMeta):
         extremely adversarial conditions.
         """
 
-    def with_input(self, letter: str, register: Union[Sequence['cirq.Qid'], int]) -> 'Cell':
+    def with_input(self, letter: str, register: Sequence[cirq.Qid] | int) -> Cell:
         """The same cell, but linked to an explicit input register or constant.
 
         If the cell doesn't need the input, it is returned unchanged.
@@ -99,7 +90,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return self
 
-    def controlled_by(self, qubit: 'cirq.Qid') -> 'Cell':
+    def controlled_by(self, qubit: cirq.Qid) -> Cell:
         """The same cell, but with an explicit control on its main operations.
 
         Cells with effects that do not need to be controlled are permitted to
@@ -113,7 +104,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return self
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         """Returns operations that implement the cell's main action.
 
         Returns:
@@ -126,7 +117,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return ()
 
-    def basis_change(self) -> 'cirq.OP_TREE':
+    def basis_change(self) -> cirq.OP_TREE:
         """Operations to conjugate a column with.
 
         The main distinctions between operations performed during the body of a
@@ -143,7 +134,7 @@ class Cell(metaclass=abc.ABCMeta):
         """
         return ()
 
-    def modify_column(self, column: List[Optional['Cell']]) -> None:
+    def modify_column(self, column: list[Cell | None]) -> None:
         """Applies this cell's modification to its column.
 
         For example, a control cell will add a control qubit to other operations
@@ -159,7 +150,7 @@ class Cell(metaclass=abc.ABCMeta):
             Nothing. The `column` argument is mutated in place.
         """
 
-    def persistent_modifiers(self) -> Dict[str, Callable[['Cell'], 'Cell']]:
+    def persistent_modifiers(self) -> dict[str, Callable[[Cell], Cell]]:
         """Overridable modifications to apply to the rest of the circuit.
 
         Persistent modifiers apply to all cells in the same column and also to
@@ -186,7 +177,7 @@ class ExplicitOperationsCell(Cell):
     def gate_count(self) -> int:
         return len(self._operations) + 2 * len(self._basis_change)
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return ExplicitOperationsCell(
             operations=tuple(
                 op.with_qubits(*Cell._replace_qubits(op.qubits, qubits)) for op in self._operations
@@ -200,13 +191,13 @@ class ExplicitOperationsCell(Cell):
     def _value_equality_values_(self):
         return self._operations, self._basis_change
 
-    def basis_change(self) -> 'cirq.OP_TREE':
+    def basis_change(self) -> cirq.OP_TREE:
         return self._basis_change
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         return self._operations
 
-    def controlled_by(self, qubit: 'cirq.Qid') -> 'ExplicitOperationsCell':
+    def controlled_by(self, qubit: cirq.Qid) -> ExplicitOperationsCell:
         return ExplicitOperationsCell(
             [op.controlled_by(qubit) for op in self._operations], self._basis_change
         )
@@ -223,7 +214,7 @@ CellMaker = NamedTuple(
     [
         ('identifier', str),
         ('size', int),
-        ('maker', Callable[[CellMakerArgs], Union[None, 'Cell', 'cirq.Operation']]),
+        ('maker', Callable[[CellMakerArgs], Union[None, Cell, 'cirq.Operation']]),
     ],
 )
 CellMaker.__doc__ = """Turns Quirk identifiers into Cirq operations.

cirq/interop/quirk/cells/cell_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 pytest
 
 import cirq

cirq/interop/quirk/cells/composite_cell.py

@@ -12,18 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import (
-    Callable,
-    cast,
-    Iterable,
-    Iterator,
-    List,
-    Optional,
-    Sequence,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from __future__ import annotations
+
+from typing import Callable, cast, Iterable, Iterator, Sequence, TYPE_CHECKING, TypeVar
 
 from cirq import circuits
 from cirq.interop.quirk.cells.cell import Cell
@@ -39,11 +30,7 @@ class CompositeCell(Cell):
     """
 
     def __init__(
-        self,
-        height: int,
-        sub_cell_cols_generator: Iterable[List[Optional[Cell]]],
-        *,
-        gate_count: int,
+        self, height: int, sub_cell_cols_generator: Iterable[list[Cell | None]], *, gate_count: int
     ):
         """Inits CompositeCell.
 
@@ -79,7 +66,7 @@ class CompositeCell(Cell):
     def gate_count(self) -> int:
         return self._gate_count
 
-    def _transform_cells(self, func: Callable[[Cell], Cell]) -> 'CompositeCell':
+    def _transform_cells(self, func: Callable[[Cell], Cell]) -> CompositeCell:
         return CompositeCell(
             height=self.height,
             # It is important that this is a generator instead of a list!
@@ -91,23 +78,21 @@ class CompositeCell(Cell):
             gate_count=self._gate_count,
         )
 
-    def _sub_cell_cols_sealed(self) -> List[List[Optional[Cell]]]:
+    def _sub_cell_cols_sealed(self) -> list[list[Cell | None]]:
         if not isinstance(self._sub_cell_cols_generator, list):
             self._sub_cell_cols_generator = list(self._sub_cell_cols_generator)
-        return cast(List[List[Optional[Cell]]], self._sub_cell_cols_generator)
+        return cast(list[list[Cell | None]], self._sub_cell_cols_generator)
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: list[cirq.Qid]) -> Cell:
         return self._transform_cells(lambda cell: cell.with_line_qubits_mapped_to(qubits))
 
-    def with_input(
-        self, letter: str, register: Union[Sequence['cirq.Qid'], int]
-    ) -> 'CompositeCell':
+    def with_input(self, letter: str, register: Sequence[cirq.Qid] | int) -> CompositeCell:
         return self._transform_cells(lambda cell: cell.with_input(letter, register))
 
-    def controlled_by(self, qubit: 'cirq.Qid') -> 'CompositeCell':
+    def controlled_by(self, qubit: cirq.Qid) -> CompositeCell:
         return self._transform_cells(lambda cell: cell.controlled_by(qubit))
 
-    def circuit(self) -> 'cirq.Circuit':
+    def circuit(self) -> cirq.Circuit:
         result = circuits.Circuit()
         for col in self._sub_cell_cols_sealed():
             body = circuits.Circuit(cell.operations() for cell in col if cell is not None)
@@ -120,7 +105,7 @@ class CompositeCell(Cell):
                 result += basis_change**-1
         return result
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         return self.circuit()
 
 
@@ -129,7 +114,7 @@ T = TypeVar('T')
 
 def _iterator_to_iterable(iterator: Iterator[T]) -> Iterable[T]:
     done = False
-    items: List[T] = []
+    items: list[T] = []
 
     class IterIntoItems:
         def __iter__(self):

cirq/interop/quirk/cells/composite_cell_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 pytest
 
 import cirq