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

cirq/interop/quirk/cells/parse.py

@@ -12,28 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cmath
 import re
 from typing import (
     Any,
     Callable,
     cast,
-    Dict,
     Iterable,
     Iterator,
-    List,
     Mapping,
-    Optional,
     SupportsFloat,
+    TypeAlias,
     TypeVar,
-    Union,
 )
 
 import numpy as np
 import sympy
 
 
-def _merge_scientific_float_tokens(tokens: Iterable[str]) -> List[str]:
+def _merge_scientific_float_tokens(tokens: Iterable[str]) -> list[str]:
     tokens = list(tokens)
     i = 0
     while 'e' in tokens[i + 1 :]:
@@ -54,8 +53,8 @@ def _merge_scientific_float_tokens(tokens: Iterable[str]) -> List[str]:
 T = TypeVar('T')
 
 
-def _segment_by(seq: Iterable[T], *, key: Callable[[T], Any]) -> Iterator[List[T]]:
-    group: List[T] = []
+def _segment_by(seq: Iterable[T], *, key: Callable[[T], Any]) -> Iterator[list[T]]:
+    group: list[T] = []
     last_key = None
     for item in seq:
         item_key = key(item)
@@ -68,8 +67,8 @@ def _segment_by(seq: Iterable[T], *, key: Callable[[T], Any]) -> Iterator[List[T
         yield group
 
 
-def _tokenize(text: str) -> List[str]:
-    def classify(e: str) -> Union[str, float]:
+def _tokenize(text: str) -> list[str]:
+    def classify(e: str) -> str | float:
         assert e.strip() != ''  # Because _segment_by drops empty entries.
         if re.match(r'[.0-9]', e):
             return "#"
@@ -85,14 +84,14 @@ def _tokenize(text: str) -> List[str]:
     return _merge_scientific_float_tokens(g for g in result if g.strip())
 
 
-_ResolvedToken = Union[sympy.Expr, complex]
+_ResolvedToken: TypeAlias = sympy.Expr | complex
 
 
 class _CustomQuirkOperationToken:
     def __init__(
         self,
-        unary_action: Optional[Callable[[_ResolvedToken], _ResolvedToken]],
-        binary_action: Optional[Callable[[_ResolvedToken, _ResolvedToken], _ResolvedToken]],
+        unary_action: Callable[[_ResolvedToken], _ResolvedToken] | None,
+        binary_action: Callable[[_ResolvedToken, _ResolvedToken], _ResolvedToken] | None,
         priority: float,
     ):
         self.unary_action = unary_action
@@ -108,7 +107,7 @@ class _HangingNode:
         self.weight = weight
 
 
-_HangingToken = Union[_ResolvedToken, str, _CustomQuirkOperationToken]
+_HangingToken: TypeAlias = _ResolvedToken | str | _CustomQuirkOperationToken
 
 
 def _translate_token(token_id: str, token_map: Mapping[str, _HangingToken]) -> _HangingToken:
@@ -122,10 +121,10 @@ def _translate_token(token_id: str, token_map: Mapping[str, _HangingToken]) -> _
 
 
 def _parse_formula_using_token_map(
-    text: str, token_map: Dict[str, _HangingToken]
+    text: str, token_map: dict[str, _HangingToken]
 ) -> _ResolvedToken:
     """Parses a value from an infix arithmetic expression."""
-    tokens: List[_HangingToken] = [_translate_token(e, token_map) for e in _tokenize(text)]
+    tokens: list[_HangingToken] = [_translate_token(e, token_map) for e in _tokenize(text)]
 
     # Cut off trailing operation, so parse fails less often as users are typing.
     if (
@@ -135,8 +134,8 @@ def _parse_formula_using_token_map(
     ):
         tokens = tokens[:-1]
 
-    ops: List[Union[str, _HangingNode]] = []
-    vals: List[Optional[_HangingToken]] = []
+    ops: list[str | _HangingNode] = []
+    vals: list[_HangingToken | None] = []
 
     # Hack: use the 'priority' field as a signal of 'is an operation'
     def is_valid_end_token(tok: _HangingToken) -> bool:
@@ -145,7 +144,7 @@ def _parse_formula_using_token_map(
     def is_valid_end_state() -> bool:
         return len(vals) == 1 and len(ops) == 0
 
-    def apply(op: Union[str, _HangingNode]) -> None:
+    def apply(op: str | _HangingNode) -> None:
         assert isinstance(op, _HangingNode)
         if len(vals) < 2:
             raise ValueError("Bad expression: operated on nothing.\ntext={text!r}")
@@ -237,7 +236,7 @@ UNICODE_FRACTIONS = {
     "⅒": 1 / 10,
 }
 
-PARSE_COMPLEX_TOKEN_MAP_ALL: Dict[str, _HangingToken] = {
+PARSE_COMPLEX_TOKEN_MAP_ALL: dict[str, _HangingToken] = {
     **UNICODE_FRACTIONS,
     'i': 1j,
     'e': sympy.E,
@@ -265,7 +264,7 @@ PARSE_COMPLEX_TOKEN_MAP_ALL: Dict[str, _HangingToken] = {
 }
 PARSE_COMPLEX_TOKEN_MAP_ALL["√"] = PARSE_COMPLEX_TOKEN_MAP_ALL["sqrt"]
 
-PARSE_COMPLEX_TOKEN_MAP_DEG: Dict[str, _HangingToken] = {
+PARSE_COMPLEX_TOKEN_MAP_DEG: dict[str, _HangingToken] = {
     **PARSE_COMPLEX_TOKEN_MAP_ALL,
     "cos": _CustomQuirkOperationToken(
         unary_action=lambda e: sympy.cos(e * sympy.pi / 180), binary_action=None, priority=4
@@ -283,7 +282,7 @@ PARSE_COMPLEX_TOKEN_MAP_DEG: Dict[str, _HangingToken] = {
 PARSE_COMPLEX_TOKEN_MAP_DEG["arccos"] = PARSE_COMPLEX_TOKEN_MAP_DEG["acos"]
 PARSE_COMPLEX_TOKEN_MAP_DEG["arcsin"] = PARSE_COMPLEX_TOKEN_MAP_DEG["asin"]
 
-PARSE_COMPLEX_TOKEN_MAP_RAD: Dict[str, _HangingToken] = {
+PARSE_COMPLEX_TOKEN_MAP_RAD: dict[str, _HangingToken] = {
     **PARSE_COMPLEX_TOKEN_MAP_ALL,
     "cos": _CustomQuirkOperationToken(
         unary_action=lambda e: sympy.cos(e) if isinstance(e, sympy.Basic) else cmath.cos(e),
@@ -337,12 +336,12 @@ def parse_complex(text: str) -> complex:
         raise ValueError(f'Failed to parse complex from {text!r}') from ex
 
 
-def parse_formula(formula: str) -> Union[float, sympy.Expr]:
+def parse_formula(formula: str) -> float | sympy.Expr:
     """Attempts to parse formula text in exactly the same way as Quirk."""
     if not isinstance(formula, str):
         raise TypeError('formula must be a string')
 
-    token_map: Dict[str, _HangingToken] = {**PARSE_COMPLEX_TOKEN_MAP_RAD, 't': sympy.Symbol('t')}
+    token_map: dict[str, _HangingToken] = {**PARSE_COMPLEX_TOKEN_MAP_RAD, 't': sympy.Symbol('t')}
     result = _parse_formula_using_token_map(formula, token_map)
 
     if isinstance(result, sympy.Basic):

cirq/interop/quirk/cells/parse_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 pytest
 import sympy
@@ -19,7 +21,7 @@ import sympy
 from cirq.interop.quirk.cells.parse import parse_complex, parse_formula, parse_matrix
 
 
-def test_parse_matrix():
+def test_parse_matrix() -> None:
     s = np.sqrt(0.5)
     np.testing.assert_allclose(
         parse_matrix('{{√½,√½},{-√½,√½}}'), np.array([[s, s], [-s, s]]), atol=1e-8
@@ -32,7 +34,7 @@ def test_parse_matrix():
     )
 
 
-def test_parse_matrix_failures():
+def test_parse_matrix_failures() -> None:
     with pytest.raises(ValueError, match='Not surrounded by {{}}'):
         _ = parse_matrix('1')
     with pytest.raises(ValueError, match='Not surrounded by {{}}'):
@@ -45,7 +47,7 @@ def test_parse_matrix_failures():
         _ = parse_matrix('{{x}}')
 
 
-def test_parse_real_formula():
+def test_parse_real_formula() -> None:
     t = sympy.Symbol('t')
     assert parse_formula('1/2') == 0.5
     assert parse_formula('t*t + ln(t)') == t * t + sympy.ln(t)
@@ -58,12 +60,12 @@ def test_parse_real_formula():
         _ = parse_formula('i')
 
 
-def test_parse_formula_failures():
+def test_parse_formula_failures() -> None:
     with pytest.raises(TypeError, match='formula must be a string'):
-        _ = parse_formula(2)
+        _ = parse_formula(2)  # type: ignore[arg-type]
 
     with pytest.raises(TypeError, match='formula must be a string'):
-        _ = parse_formula([])
+        _ = parse_formula([])  # type: ignore[arg-type]
 
     with pytest.raises(ValueError, match='Unrecognized token'):
         _ = parse_formula('5*__**DSA **)SADD')
@@ -72,7 +74,7 @@ def test_parse_formula_failures():
         _ = parse_formula('5*x')
 
 
-def test_parse_complex():
+def test_parse_complex() -> None:
     assert parse_complex('0') == 0
     assert parse_complex('1') == 1
     assert parse_complex('i') == 1j
@@ -84,7 +86,7 @@ def test_parse_complex():
     np.testing.assert_allclose(parse_complex('exp 2'), np.e**2, atol=1e-8)
 
 
-def test_parse_complex_raw_cases_from_quirk():
+def test_parse_complex_raw_cases_from_quirk() -> None:
     assert parse_complex("0") == 0
     assert parse_complex("1") == 1
     assert parse_complex("-1") == -1
@@ -116,7 +118,7 @@ def test_parse_complex_raw_cases_from_quirk():
     np.testing.assert_allclose(parse_complex("2       pi"), 2 * np.pi)
 
 
-def test_parse_complex_expression_cases_from_quirk():
+def test_parse_complex_expression_cases_from_quirk() -> None:
     np.testing.assert_allclose(parse_complex("1/3"), 1 / 3)
     np.testing.assert_allclose(parse_complex("2/3/5"), (2 / 3) / 5)
     np.testing.assert_allclose(parse_complex("2/3/5*7/13"), ((((2 / 3) / 5)) * 7) / 13)
@@ -152,7 +154,7 @@ def test_parse_complex_expression_cases_from_quirk():
     np.testing.assert_allclose(parse_complex("cos(acos(0.5))"), 0.5, atol=1e-8)
 
 
-def test_parse_complex_expression_failures():
+def test_parse_complex_expression_failures() -> None:
     with pytest.raises(ValueError, match='Incomplete expression'):
         _ = parse_formula('(')
     with pytest.raises(ValueError, match=r"unmatched '\)'"):

cirq/interop/quirk/cells/qubit_permutation_cells.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable, Iterator, Sequence, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Callable, Iterator, Sequence, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.interop.quirk.cells.cell import CELL_SIZES, CellMaker
@@ -42,7 +44,7 @@ class QuirkQubitPermutationGate(ops.QubitPermutationGate):
     def _value_equality_values_(self):
         return self.identifier, self.name, self.permutation
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> tuple[str, ...]:
         return tuple(
             f'{self.name}[{i}>{self.permutation[i]}]' for i in range(len(self.permutation))
         )
@@ -72,7 +74,7 @@ def _permutation_family(
         yield _permutation(identifier_prefix + str(n), name, permutation)
 
 
-def _permutation(identifier: str, name: str, permutation: Tuple[int, ...]) -> CellMaker:
+def _permutation(identifier: str, name: str, permutation: tuple[int, ...]) -> CellMaker:
     return CellMaker(
         identifier,
         size=len(permutation),

cirq/interop/quirk/cells/qubit_permutation_cells_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 from cirq.interop.quirk.cells.qubit_permutation_cells import QuirkQubitPermutationGate
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_equality():
+def test_equality() -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: QuirkQubitPermutationGate('a', 'b', [0, 1]))
     eq.add_equality_group(QuirkQubitPermutationGate('x', 'b', [0, 1]))
@@ -25,11 +27,11 @@ def test_equality():
     eq.add_equality_group(QuirkQubitPermutationGate('a', 'b', [1, 0]))
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(QuirkQubitPermutationGate('a', 'b', [0, 1]))
 
 
-def test_right_rotate():
+def test_right_rotate() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["X",">>4",1,1,1,"X"]]}',
         diagram="""
@@ -57,7 +59,7 @@ def test_right_rotate():
     )
 
 
-def test_left_rotate():
+def test_left_rotate() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["<<4"]]}',
         maps={
@@ -72,7 +74,7 @@ def test_left_rotate():
     )
 
 
-def test_reverse():
+def test_reverse() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["rev4"]]}',
         maps={
@@ -98,7 +100,7 @@ def test_reverse():
     )
 
 
-def test_interleave():
+def test_interleave() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["weave5"]]}',
         maps={
@@ -128,7 +130,7 @@ def test_interleave():
     )
 
 
-def test_deinterleave():
+def test_deinterleave() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["split5"]]}',
         maps={

cirq/interop/quirk/cells/scalar_cells.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 Iterator, TYPE_CHECKING
 
 from cirq import ops
@@ -28,5 +31,5 @@ def generate_all_scalar_cell_makers() -> Iterator[CellMaker]:
     yield _scalar("√-i", ops.global_phase_operation((-1j) ** 0.5))
 
 
-def _scalar(identifier: str, operation: 'cirq.Operation') -> CellMaker:
+def _scalar(identifier: str, operation: cirq.Operation) -> CellMaker:
     return CellMaker(identifier, size=1, maker=lambda _: operation)

cirq/interop/quirk/cells/scalar_cells_test.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_scalar_operations():
+def test_scalar_operations() -> None:
     assert_url_to_circuit_returns('{"cols":[["…"]]}', cirq.Circuit())
 
     assert_url_to_circuit_returns(

cirq/interop/quirk/cells/single_qubit_rotation_cells.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 Callable, Iterator, TYPE_CHECKING
 
 import sympy
@@ -91,14 +94,14 @@ def generate_all_single_qubit_rotation_cell_makers() -> Iterator[CellMaker]:
     yield _formula_gate("Rzft", "pi*t*t", ops.rz)
 
 
-def _gate(identifier: str, gate: 'cirq.Gate') -> CellMaker:
+def _gate(identifier: str, gate: cirq.Gate) -> CellMaker:
     return CellMaker(
         identifier=identifier, size=gate.num_qubits(), maker=lambda args: gate.on(*args.qubits)
     )
 
 
 def _formula_gate(
-    identifier: str, default_formula: str, gate_func: Callable[['cirq.TParamVal'], 'cirq.Gate']
+    identifier: str, default_formula: str, gate_func: Callable[[cirq.TParamVal], cirq.Gate]
 ) -> CellMaker:
     return CellMaker(
         identifier=identifier,

cirq/interop/quirk/cells/single_qubit_rotation_cells_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import sympy
 
 import cirq
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_fixed_single_qubit_rotations():
+def test_fixed_single_qubit_rotations() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
 
     assert_url_to_circuit_returns(
@@ -89,7 +91,7 @@ def test_fixed_single_qubit_rotations():
     )
 
 
-def test_dynamic_single_qubit_rotations():
+def test_dynamic_single_qubit_rotations() -> None:
     a, b, c = cirq.LineQubit.range(3)
     t = sympy.Symbol('t')
 
@@ -118,7 +120,7 @@ def test_dynamic_single_qubit_rotations():
     )
 
 
-def test_formulaic_gates():
+def test_formulaic_gates() -> None:
     a, b = cirq.LineQubit.range(2)
     t = sympy.Symbol('t')
 

cirq/interop/quirk/cells/swap_cell.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Iterable, Iterator, List, Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Any, Iterable, Iterator, TYPE_CHECKING
 
 from cirq import ops, value
 from cirq.interop.quirk.cells.cell import Cell, CellMaker
@@ -23,20 +25,20 @@ if TYPE_CHECKING:
 
 @value.value_equality(unhashable=True)
 class SwapCell(Cell):
-    def __init__(self, qubits: Iterable['cirq.Qid'], controls: Iterable['cirq.Qid']):
+    def __init__(self, qubits: Iterable[cirq.Qid], controls: Iterable[cirq.Qid]):
         self._qubits = list(qubits)
         self._controls = list(controls)
 
     def gate_count(self) -> int:
         return 1
 
-    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 SwapCell(
             qubits=Cell._replace_qubits(self._qubits, qubits),
             controls=Cell._replace_qubits(self._controls, qubits),
         )
 
-    def modify_column(self, column: List[Optional['Cell']]):
+    def modify_column(self, column: list[Cell | None]):
         # Swallow other swap cells.
         for i in range(len(column)):
             gate = column[i]
@@ -45,12 +47,12 @@ class SwapCell(Cell):
                 self._qubits += gate._qubits
                 column[i] = None
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         if len(self._qubits) != 2:
             raise ValueError('Wrong number of swap gates in a column.')
         return ops.SWAP(*self._qubits).controlled_by(*self._controls)
 
-    def controlled_by(self, qubit: 'cirq.Qid'):
+    def controlled_by(self, qubit: cirq.Qid):
         return SwapCell(self._qubits, self._controls + [qubit])
 
     def _value_equality_values_(self) -> Any:

cirq/interop/quirk/cells/swap_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
@@ -19,7 +21,7 @@ from cirq import quirk_url_to_circuit
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_swap():
+def test_swap() -> None:
     a, b, c = cirq.LineQubit.range(3)
     assert_url_to_circuit_returns('{"cols":[["Swap","Swap"]]}', cirq.Circuit(cirq.SWAP(a, b)))
     assert_url_to_circuit_returns(
@@ -34,7 +36,7 @@ def test_swap():
         )
 
 
-def test_controlled_swap():
+def test_controlled_swap() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     assert_url_to_circuit_returns(
         '{"cols":[["Swap","•","Swap"]]}', cirq.Circuit(cirq.SWAP(a, c).controlled_by(b))
@@ -44,7 +46,7 @@ def test_controlled_swap():
     )
 
 
-def test_with_line_qubits_mapped_to():
+def test_with_line_qubits_mapped_to() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     a2, b2, c2, d2 = cirq.NamedQubit.range(4, prefix='q')
     cell = cirq.interop.quirk.cells.swap_cell.SwapCell(qubits=[a, b], controls=[c, d])
@@ -53,7 +55,7 @@ def test_with_line_qubits_mapped_to():
     assert cell.with_line_qubits_mapped_to([a2, b2, c2, d2]) == mapped_cell
 
 
-def test_repr():
+def test_repr() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     cirq.testing.assert_equivalent_repr(
         cirq.interop.quirk.cells.swap_cell.SwapCell(qubits=[a, b], controls=[c, d])

cirq/interop/quirk/cells/testing.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, List, Optional
+from __future__ import annotations
 
 import numpy as np
 
@@ -22,12 +22,12 @@ from cirq import quirk_url_to_circuit
 
 def assert_url_to_circuit_returns(
     json_text: str,
-    circuit: Optional['cirq.Circuit'] = None,
+    circuit: cirq.Circuit | None = None,
     *,
-    unitary: Optional[np.ndarray] = None,
-    diagram: Optional[str] = None,
-    output_amplitudes_from_quirk: Optional[List[Dict[str, float]]] = None,
-    maps: Optional[Dict[int, int]] = None,
+    unitary: np.ndarray | None = None,
+    diagram: str | None = None,
+    output_amplitudes_from_quirk: list[dict[str, float]] | None = None,
+    maps: dict[int, int] | None = None,
 ):
     """Assert that `quirk_url_to_circuit` functions correctly.
 

cirq/interop/quirk/cells/testing_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 pytest
 
@@ -19,7 +21,7 @@ import cirq
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
-def test_assert_url_to_circuit_returns_circuit():
+def test_assert_url_to_circuit_returns_circuit() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["X"]]}', circuit=cirq.Circuit(cirq.X(cirq.LineQubit(0)))
     )
@@ -30,21 +32,21 @@ def test_assert_url_to_circuit_returns_circuit():
         )
 
 
-def test_assert_url_to_circuit_returns_unitary():
+def test_assert_url_to_circuit_returns_unitary() -> None:
     assert_url_to_circuit_returns('{"cols":[["X"]]}', unitary=cirq.unitary(cirq.X))
 
     with pytest.raises(AssertionError, match='Not equal to tolerance'):
         assert_url_to_circuit_returns('{"cols":[["X"]]}', unitary=np.eye(2))
 
 
-def test_assert_url_to_circuit_returns_diagram():
+def test_assert_url_to_circuit_returns_diagram() -> None:
     assert_url_to_circuit_returns('{"cols":[["X"]]}', diagram='0: ───X───')
 
     with pytest.raises(AssertionError, match='text diagram differs'):
         assert_url_to_circuit_returns('{"cols":[["X"]]}', diagram='not even close')
 
 
-def test_assert_url_to_circuit_returns_maps():
+def test_assert_url_to_circuit_returns_maps() -> None:
     assert_url_to_circuit_returns('{"cols":[["X"]]}', maps={0: 1})
     assert_url_to_circuit_returns('{"cols":[["X"]]}', maps={0: 1, 1: 0})
 
@@ -55,7 +57,7 @@ def test_assert_url_to_circuit_returns_maps():
         assert_url_to_circuit_returns('{"cols":[["H"]]}', maps={0: 0})
 
 
-def test_assert_url_to_circuit_returns_output_amplitudes_from_quirk():
+def test_assert_url_to_circuit_returns_output_amplitudes_from_quirk() -> None:
     assert_url_to_circuit_returns(
         '{"cols":[["X","Z"]]}',
         output_amplitudes_from_quirk=[
@@ -78,7 +80,7 @@ def test_assert_url_to_circuit_returns_output_amplitudes_from_quirk():
         )
 
 
-def test_assert_url_to_circuit_misc():
+def test_assert_url_to_circuit_misc() -> None:
     a, b = cirq.LineQubit.range(2)
 
     assert_url_to_circuit_returns(

cirq/interop/quirk/cells/unsupported_cells.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 Iterator
 
 from cirq.interop.quirk.cells.cell import CELL_SIZES, CellMaker

cirq/interop/quirk/cells/unsupported_cells_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 from cirq import quirk_url_to_circuit
 
 
-def test_non_physical_operations():
+def test_non_physical_operations() -> None:
     with pytest.raises(NotImplementedError, match="unphysical operation"):
         _ = quirk_url_to_circuit('https://algassert.com/quirk#circuit={"cols":[["__error__"]]}')
     with pytest.raises(NotImplementedError, match="unphysical operation"):
@@ -26,7 +28,7 @@ def test_non_physical_operations():
         )
 
 
-def test_not_implemented_gates():
+def test_not_implemented_gates() -> None:
     # This test mostly exists to ensure the gates are tested if added.
 
     for k in ["X^⌈t⌉", "X^⌈t-¼⌉", "Counting4", "Uncounting4", ">>t3", "<<t3"]: