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

cirq/testing/lin_alg_utils.py

@@ -11,9 +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.
+
 """A testing class with utilities for checking linear algebra."""
 
-from typing import Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -24,7 +27,7 @@ if TYPE_CHECKING:
 
 
 def random_superposition(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random unit-length vector from the uniform distribution.
 
@@ -46,7 +49,7 @@ def random_superposition(
 
 
 def random_density_matrix(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random density matrix distributed with Hilbert-Schmidt measure.
 
@@ -68,9 +71,7 @@ def random_density_matrix(
     return mat / np.trace(mat)
 
 
-def random_unitary(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-) -> np.ndarray:
+def random_unitary(dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None) -> np.ndarray:
     """Returns a random unitary matrix distributed with Haar measure.
 
     Args:
@@ -93,7 +94,7 @@ def random_unitary(
 
 
 def random_orthogonal(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random orthogonal matrix distributed with Haar measure.
 
@@ -119,7 +120,7 @@ def random_orthogonal(
 
 
 def random_special_unitary(
-    dim: int, *, random_state: Optional[np.random.RandomState] = None
+    dim: int, *, random_state: np.random.RandomState | None = None
 ) -> np.ndarray:
     """Returns a random special unitary distributed with Haar measure.
 
@@ -139,7 +140,7 @@ def random_special_unitary(
 
 
 def random_special_orthogonal(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random special orthogonal matrix distributed with Haar measure.
 
@@ -185,9 +186,7 @@ def assert_allclose_up_to_global_phase(
     Raises:
         AssertionError: The matrices aren't nearly equal up to global phase.
     """
-    # pylint: disable=unused-variable
     __tracebackhide__ = True
-    # pylint: enable=unused-variable
 
     actual, desired = linalg.match_global_phase(actual, desired)
     np.testing.assert_allclose(

cirq/testing/lin_alg_utils_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
 
@@ -28,14 +30,14 @@ from cirq.testing import (
 
 
 @pytest.mark.parametrize('dim', range(1, 10))
-def test_random_superposition(dim):
+def test_random_superposition(dim) -> None:
     state = random_superposition(dim)
 
     assert dim == len(state)
     assert np.isclose(np.linalg.norm(state), 1.0)
 
 
-def test_random_superposition_deterministic_given_seed():
+def test_random_superposition_deterministic_given_seed() -> None:
     state1 = random_superposition(10, random_state=1234)
     state2 = random_superposition(10, random_state=1234)
 
@@ -43,7 +45,7 @@ def test_random_superposition_deterministic_given_seed():
 
 
 @pytest.mark.parametrize('dim', range(1, 10))
-def test_random_density_matrix(dim):
+def test_random_density_matrix(dim) -> None:
     state = random_density_matrix(dim)
 
     assert state.shape == (dim, dim)
@@ -53,14 +55,14 @@ def test_random_density_matrix(dim):
     assert np.all(eigs >= 0)
 
 
-def test_random_density_matrix_deterministic_given_seed():
+def test_random_density_matrix_deterministic_given_seed() -> None:
     state1 = random_density_matrix(10, random_state=1234)
     state2 = random_density_matrix(10, random_state=1234)
 
     np.testing.assert_equal(state1, state2)
 
 
-def test_random_unitary():
+def test_random_unitary() -> None:
     u1 = random_unitary(2)
     u2 = random_unitary(2)
     assert is_unitary(u1)
@@ -68,7 +70,7 @@ def test_random_unitary():
     assert not np.allclose(u1, u2)
 
 
-def test_random_orthogonal():
+def test_random_orthogonal() -> None:
     o1 = random_orthogonal(2)
     o2 = random_orthogonal(2)
     assert is_orthogonal(o1)
@@ -76,14 +78,14 @@ def test_random_orthogonal():
     assert not np.allclose(o1, o2)
 
 
-def test_random_orthogonal_deterministic_given_seed():
+def test_random_orthogonal_deterministic_given_seed() -> None:
     o1 = random_orthogonal(2, random_state=1234)
     o2 = random_orthogonal(2, random_state=1234)
 
     np.testing.assert_equal(o1, o2)
 
 
-def test_random_special_unitary():
+def test_random_special_unitary() -> None:
     u1 = random_special_unitary(2)
     u2 = random_special_unitary(2)
     assert is_special_unitary(u1)
@@ -91,7 +93,7 @@ def test_random_special_unitary():
     assert not np.allclose(u1, u2)
 
 
-def test_seeded_special_unitary():
+def test_seeded_special_unitary() -> None:
     u1 = random_special_unitary(2, random_state=np.random.RandomState(1))
     u2 = random_special_unitary(2, random_state=np.random.RandomState(1))
     u3 = random_special_unitary(2, random_state=np.random.RandomState(2))
@@ -99,7 +101,7 @@ def test_seeded_special_unitary():
     assert not np.allclose(u1, u3)
 
 
-def test_random_special_orthogonal():
+def test_random_special_orthogonal() -> None:
     o1 = random_special_orthogonal(2)
     o2 = random_special_orthogonal(2)
     assert is_special_orthogonal(o1)
@@ -107,14 +109,14 @@ def test_random_special_orthogonal():
     assert not np.allclose(o1, o2)
 
 
-def test_random_special_orthogonal_deterministic_given_seed():
+def test_random_special_orthogonal_deterministic_given_seed() -> None:
     o1 = random_special_orthogonal(2, random_state=1234)
     o2 = random_special_orthogonal(2, random_state=1234)
 
     np.testing.assert_equal(o1, o2)
 
 
-def test_assert_allclose_up_to_global_phase():
+def test_assert_allclose_up_to_global_phase() -> None:
     assert_allclose_up_to_global_phase(np.array([[1]]), np.array([[1j]]), atol=0)
 
     with pytest.raises(AssertionError):

cirq/testing/logs.py

@@ -11,20 +11,24 @@
 # 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.
+
 """Helper for testing python logging statements."""
+
+from __future__ import annotations
+
 import contextlib
 import logging
-from typing import Iterator, List, Optional
+from typing import Iterator
 
 
 @contextlib.contextmanager
 def assert_logs(
     *matches: str,
-    count: Optional[int] = 1,
+    count: int | None = 1,
     min_level: int = logging.WARNING,
     max_level: int = logging.CRITICAL,
     capture_warnings: bool = True,
-) -> Iterator[List[logging.LogRecord]]:
+) -> Iterator[list[logging.LogRecord]]:
     """A context manager for testing logging and warning events.
 
     To use this one wraps the code that is to be tested for log events within
@@ -92,6 +96,3 @@ def assert_logs(
                 f'{match} expected to appear in log messages but it was '
                 f'not found. Log messages: {msgs}.'
             )
-
-
-# pylint: enable=missing-raises-doc

cirq/testing/logs_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 logging
 import warnings
 
@@ -20,7 +22,7 @@ import pytest
 import cirq.testing
 
 
-def test_assert_logs_valid_single_logs():
+def test_assert_logs_valid_single_logs() -> None:
     with cirq.testing.assert_logs('apple'):
         logging.error('orange apple fruit')
 
@@ -43,7 +45,7 @@ def test_assert_logs_valid_single_logs():
         warnings.warn('orange apple fruit')
 
 
-def test_assert_logs_invalid_single_logs():
+def test_assert_logs_invalid_single_logs() -> None:
     match = (
         '^dog expected to appear in log messages but it was not found. '
         'Log messages: \\[\'orange apple fruit\'\\].$'
@@ -57,7 +59,7 @@ def test_assert_logs_invalid_single_logs():
             logging.error('orange apple fruit')
 
 
-def test_assert_logs_valid_multiple_logs():
+def test_assert_logs_valid_multiple_logs() -> None:
     with cirq.testing.assert_logs('apple', count=2):
         logging.error('orange apple fruit')
         logging.error('other')
@@ -84,7 +86,7 @@ def test_assert_logs_valid_multiple_logs():
         logging.warning('other two')
 
 
-def test_assert_logs_invalid_multiple_logs():
+def test_assert_logs_invalid_multiple_logs() -> None:
     with pytest.raises(AssertionError, match='^Expected 1 log message but got 2. Log messages.*$'):
         with cirq.testing.assert_logs('dog'):
             logging.error('orange apple fruit')
@@ -107,7 +109,7 @@ def test_assert_logs_invalid_multiple_logs():
             logging.error('whatever')
 
 
-def test_assert_logs_log_level():
+def test_assert_logs_log_level() -> None:
     # Default minlevel is WARNING, max level CRITICAL
     with cirq.testing.assert_logs('apple'):
         logging.error('orange apple fruit')
@@ -131,7 +133,7 @@ def test_assert_logs_log_level():
             logging.warning("info warning 1")
 
 
-def test_invalid_levels():
+def test_invalid_levels() -> None:
     with pytest.raises(ValueError, match="min_level.*max_level"):
         with cirq.testing.assert_logs(
             "test", min_level=logging.CRITICAL, max_level=logging.WARNING
@@ -139,7 +141,7 @@ def test_invalid_levels():
             pass
 
 
-def test_assert_logs_warnings():
+def test_assert_logs_warnings() -> None:
     # Capture all warnings in one context, so that test cases that will
     # display a warning do not do so when the test is run.
     with warnings.catch_warnings(record=True):

cirq/testing/no_identifier_qubit.py

@@ -11,7 +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 typing import Any, Dict
+from __future__ import annotations
+
+from typing import Any
 
 from cirq import protocols
 from cirq.ops import raw_types
@@ -35,5 +37,5 @@ class NoIdentifierQubit(raw_types.Qid):
     def __repr__(self) -> str:
         return 'cirq.testing.NoIdentifierQubit()'
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return protocols.obj_to_dict_helper(self, [])

cirq/testing/no_identifier_qubit_test.py

@@ -12,19 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 
-def test_named_qubit_repr():
+def test_named_qubit_repr() -> None:
     q = cirq.testing.NoIdentifierQubit()
     assert repr(q) == "cirq.testing.NoIdentifierQubit()"
 
 
-def test_comparsion_key():
+def test_comparsion_key() -> None:
     q = cirq.testing.NoIdentifierQubit()
     p = cirq.testing.NoIdentifierQubit()
     assert p == q
 
 
-def test_to_json():
+def test_to_json() -> None:
     assert cirq.testing.NoIdentifierQubit()._json_dict_() == {}

cirq/testing/op_tree.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from cirq import ops
 
 

cirq/testing/op_tree_test.py

@@ -11,13 +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 __future__ import annotations
+
 import pytest
 
 import cirq
 from cirq.testing import assert_equivalent_op_tree
 
 
-def test_assert_equivalent_op_tree():
+def test_assert_equivalent_op_tree() -> None:
     assert_equivalent_op_tree([], [])
     a = cirq.NamedQubit("a")
     assert_equivalent_op_tree([cirq.X(a)], [cirq.X(a)])

cirq/testing/order_tester.py

@@ -23,6 +23,8 @@ added items or groups.
 It will also check that a==b implies hash(a)==hash(b).
 """
 
+from __future__ import annotations
+
 from typing import Any
 
 from cirq.testing.equals_tester import EqualsTester

cirq/testing/order_tester_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 fractions
 
 import pytest
@@ -62,7 +64,7 @@ class MockValue:
         return f'MockValue(val={self.val!r}, ...)'
 
 
-def test_add_ordering_group_correct():
+def test_add_ordering_group_correct() -> None:
     ot = cirq.testing.OrderTester()
     ot.add_ascending(-4, 0)
     ot.add_ascending(1, 2)
@@ -70,7 +72,7 @@ def test_add_ordering_group_correct():
     ot.add_ascending_equivalence_group(float('inf'), float('inf'))
 
 
-def test_add_ordering_group_incorrect():
+def test_add_ordering_group_incorrect() -> None:
     ot = cirq.testing.OrderTester()
     ot.add_ascending(0)
     with pytest.raises(AssertionError):
@@ -88,7 +90,7 @@ def test_add_ordering_group_incorrect():
         ot.add_ascending(0)
 
 
-def test_propagates_internal_errors():
+def test_propagates_internal_errors() -> None:
     class UnorderableClass:  # pragma: no cover
         def __eq__(self, other):
             return NotImplemented
@@ -113,7 +115,7 @@ def test_propagates_internal_errors():
         ot.add_ascending(UnorderableClass())
 
 
-def test_add_ascending_equivalence_group():
+def test_add_ascending_equivalence_group() -> None:
     ot = cirq.testing.OrderTester()
     with pytest.raises(AssertionError, match='Expected X=1 to equal Y=3'):
         ot.add_ascending_equivalence_group(1, 3)
@@ -127,7 +129,7 @@ def test_add_ascending_equivalence_group():
     ot.add_ascending_equivalence_group(5)
 
 
-def test_fails_to_return_not_implemented_vs_unknown():
+def test_fails_to_return_not_implemented_vs_unknown() -> None:
     def make_impls(bad_index: int, bad_result: bool):
         def make_impl(i, op):
             def impl(x, y):
@@ -153,7 +155,7 @@ def test_fails_to_return_not_implemented_vs_unknown():
     ot.add_ascending(MockValue(1, *good_impls))
 
 
-def test_fails_on_inconsistent_hashes():
+def test_fails_on_inconsistent_hashes() -> None:
     class ModifiedHash(tuple):
         def __hash__(self):
             return super().__hash__() ^ 1

cirq/testing/pytest_utils.py

@@ -14,6 +14,8 @@
 
 """Support one retry of tests that fail for a specific seed from pytest-randomly."""
 
+from __future__ import annotations
+
 import functools
 import warnings
 from typing import Any, Callable

cirq/testing/pytest_utils_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from unittest.mock import Mock
 
 import pytest
@@ -19,7 +21,7 @@ import pytest
 import cirq
 
 
-def test_retry_once_after_timeout():
+def test_retry_once_after_timeout() -> None:
     testfunc = Mock(side_effect=[TimeoutError("first call fails"), None])
     decoratedfunc = cirq.testing.retry_once_after_timeout(testfunc)
     with pytest.warns(UserWarning, match="Retrying.*transitive TimeoutError"):
@@ -27,7 +29,7 @@ def test_retry_once_after_timeout():
     assert testfunc.call_count == 2
 
 
-def test_retry_once_with_later_random_values():
+def test_retry_once_with_later_random_values() -> None:
     testfunc = Mock(side_effect=[AssertionError("first call fails"), None])
     decoratedfunc = cirq.testing.retry_once_with_later_random_values(testfunc)
     with pytest.warns(UserWarning, match="Retrying.*failing seed.*pytest-randomly"):

cirq/testing/random_circuit.py

@@ -12,27 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, List, Optional, Sequence, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import Sequence, TYPE_CHECKING
 
 from cirq import circuits, ops, value
 from cirq._doc import document
-from cirq.ops import Qid
 
 if TYPE_CHECKING:
     import cirq
 
-DEFAULT_GATE_DOMAIN: Dict[ops.Gate, int] = {
-    ops.CNOT: 2,
-    ops.CZ: 2,
-    ops.H: 1,
-    ops.ISWAP: 2,
+DEFAULT_GATE_DOMAIN: dict[ops.Gate, int] = {
+    ops.CNOT: 2,  # type: ignore[has-type]
+    ops.CZ: 2,  # type: ignore[has-type]
+    ops.H: 1,  # type: ignore[has-type]
+    ops.ISWAP: 2,  # type: ignore[has-type]
     ops.CZPowGate(): 2,
-    ops.S: 1,
-    ops.SWAP: 2,
-    ops.T: 1,
-    ops.X: 1,
-    ops.Y: 1,
-    ops.Z: 1,
+    ops.S: 1,  # type: ignore[has-type]
+    ops.SWAP: 2,  # type: ignore[has-type]
+    ops.T: 1,  # type: ignore[has-type]
+    ops.X: 1,  # type: ignore[has-type]
+    ops.Y: 1,  # type: ignore[has-type]
+    ops.Z: 1,  # type: ignore[has-type]
 }
 document(
     DEFAULT_GATE_DOMAIN,
@@ -45,11 +46,11 @@ and Z gates.
 
 
 def random_circuit(
-    qubits: Union[Sequence[ops.Qid], int],
+    qubits: Sequence[cirq.Qid] | int,
     n_moments: int,
     op_density: float,
-    gate_domain: Optional[Dict[ops.Gate, int]] = None,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    gate_domain: dict[ops.Gate, int] | None = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> circuits.Circuit:
     """Generates a random circuit.
 
@@ -106,7 +107,7 @@ def random_circuit(
 
     prng = value.parse_random_state(random_state)
 
-    moments: List[circuits.Moment] = []
+    moments: list[circuits.Moment] = []
     gate_arity_pairs = sorted(gate_domain.items(), key=repr)
     num_gates = len(gate_domain)
     for _ in range(n_moments):
@@ -125,9 +126,9 @@ def random_circuit(
 
 def random_two_qubit_circuit_with_czs(
     num_czs: int = 3,
-    q0: Optional[Qid] = None,
-    q1: Optional[Qid] = None,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    q0: cirq.Qid | None = None,
+    q1: cirq.Qid | None = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> circuits.Circuit:
     """Creates a random two qubit circuit with the given number of CNOTs.
 

cirq/testing/random_circuit_test.py

@@ -11,8 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import random
-from typing import cast, Dict, Optional, Sequence, Union
+from typing import cast, Sequence
 
 import numpy as np
 import pytest
@@ -21,7 +24,7 @@ import cirq
 import cirq.testing
 
 
-def test_random_circuit_errors():
+def test_random_circuit_errors() -> None:
     with pytest.raises(ValueError, match='but was -1'):
         _ = cirq.testing.random_circuit(qubits=5, n_moments=5, op_density=-1)
 
@@ -72,12 +75,12 @@ def _cases_for_random_circuit():
     'n_qubits,n_moments,op_density,gate_domain,pass_qubits', _cases_for_random_circuit()
 )
 def test_random_circuit(
-    n_qubits: Union[int, Sequence[cirq.Qid]],
+    n_qubits: int | Sequence[cirq.Qid],
     n_moments: int,
     op_density: float,
-    gate_domain: Optional[Dict[cirq.Gate, int]],
+    gate_domain: dict[cirq.Gate, int] | None,
     pass_qubits: bool,
-):
+) -> None:
     qubit_set = cirq.LineQubit.range(n_qubits)
     qubit_arg = qubit_set if pass_qubits else n_qubits
     circuit = cirq.testing.random_circuit(qubit_arg, n_moments, op_density, gate_domain)
@@ -92,7 +95,7 @@ def test_random_circuit(
 
 
 @pytest.mark.parametrize('seed', [random.randint(0, 2**32) for _ in range(10)])
-def test_random_circuit_reproducible_with_seed(seed):
+def test_random_circuit_reproducible_with_seed(seed) -> None:
     wrappers = (lambda s: s, np.random.RandomState)
     circuits = [
         cirq.testing.random_circuit(
@@ -105,7 +108,7 @@ def test_random_circuit_reproducible_with_seed(seed):
     eq.add_equality_group(*circuits)
 
 
-def test_random_circuit_not_expected_number_of_qubits():
+def test_random_circuit_not_expected_number_of_qubits() -> None:
     circuit = cirq.testing.random_circuit(
         qubits=3, n_moments=1, op_density=1.0, gate_domain={cirq.CNOT: 2}
     )
@@ -114,7 +117,7 @@ def test_random_circuit_not_expected_number_of_qubits():
     assert len(circuit.all_qubits()) == 2
 
 
-def test_random_circuit_reproducible_between_runs():
+def test_random_circuit_reproducible_between_runs() -> None:
     circuit = cirq.testing.random_circuit(5, 8, 0.5, random_state=77)
     expected_diagram = """
                   ┌──┐
@@ -132,7 +135,7 @@ def test_random_circuit_reproducible_between_runs():
     cirq.testing.assert_has_diagram(circuit, expected_diagram)
 
 
-def test_random_two_qubit_circuit_with_czs():
+def test_random_two_qubit_circuit_with_czs() -> None:
     num_czs = lambda circuit: len(
         [o for o in circuit.all_operations() if isinstance(o.gate, cirq.CZPowGate)]
     )

cirq/testing/repr_pretty_tester.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 from typing import Any
 

cirq/testing/repr_pretty_tester_test.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq.testing
 
 
-def test_fake_printer():
+def test_fake_printer() -> None:
     p = cirq.testing.FakePrinter()
     assert p.text_pretty == ""
     p.text("stuff")
@@ -24,7 +26,7 @@ def test_fake_printer():
     assert p.text_pretty == "stuff more"
 
 
-def test_assert_repr_pretty():
+def test_assert_repr_pretty() -> None:
     class TestClass:
         def _repr_pretty_(self, p, cycle):
             p.text("TestClass" if cycle else "I'm so pretty")
@@ -44,7 +46,7 @@ def test_assert_repr_pretty():
     cirq.testing.assert_repr_pretty(TestClassMultipleTexts(), "TestClass", cycle=True)
 
 
-def test_assert_repr_pretty_contains():
+def test_assert_repr_pretty_contains() -> None:
     class TestClass:
         def _repr_pretty_(self, p, cycle):
             p.text("TestClass" if cycle else "I'm so pretty")