cirq-core 1.7.0.dev20250911180440__py3-none-any.whl → 1.7.0.dev20250917002151__py3-none-any.whl

cirq/study/sweepable_test.py

@@ -24,66 +24,66 @@ import sympy
 import cirq
 
 
-def test_to_resolvers_none():
+def test_to_resolvers_none() -> None:
     assert list(cirq.to_resolvers(None)) == [cirq.ParamResolver({})]
 
 
-def test_to_resolvers_single():
+def test_to_resolvers_single() -> None:
     resolver = cirq.ParamResolver({})
     assert list(cirq.to_resolvers(resolver)) == [resolver]
     assert list(cirq.to_resolvers({})) == [resolver]
 
 
-def test_to_resolvers_sweep():
+def test_to_resolvers_sweep() -> None:
     sweep = cirq.Linspace('a', 0, 1, 10)
     assert list(cirq.to_resolvers(sweep)) == list(sweep)
 
 
-def test_to_resolvers_iterable():
+def test_to_resolvers_iterable() -> None:
     resolvers = [cirq.ParamResolver({'a': 2}), cirq.ParamResolver({'a': 1})]
     assert list(cirq.to_resolvers(resolvers)) == resolvers
     assert list(cirq.to_resolvers([{'a': 2}, {'a': 1}])) == resolvers
 
 
-def test_to_resolvers_iterable_sweeps():
+def test_to_resolvers_iterable_sweeps() -> None:
     sweeps = [cirq.Linspace('a', 0, 1, 10), cirq.Linspace('b', 0, 1, 10)]
     assert list(cirq.to_resolvers(sweeps)) == list(itertools.chain(*sweeps))
 
 
-def test_to_resolvers_bad():
+def test_to_resolvers_bad() -> None:
     with pytest.raises(TypeError, match='Unrecognized sweepable'):
         for _ in cirq.study.to_resolvers('nope'):
             pass
 
 
-def test_to_sweeps_none():
+def test_to_sweeps_none() -> None:
     assert cirq.study.to_sweeps(None) == [cirq.UnitSweep]
 
 
-def test_to_sweeps_single():
+def test_to_sweeps_single() -> None:
     resolver = cirq.ParamResolver({})
     assert cirq.study.to_sweeps(resolver) == [cirq.UnitSweep]
     assert cirq.study.to_sweeps({}) == [cirq.UnitSweep]
 
 
-def test_to_sweeps_sweep():
+def test_to_sweeps_sweep() -> None:
     sweep = cirq.Linspace('a', 0, 1, 10)
     assert cirq.study.to_sweeps(sweep) == [sweep]
 
 
-def test_to_sweeps_iterable():
+def test_to_sweeps_iterable() -> None:
     resolvers = [cirq.ParamResolver({'a': 2}), cirq.ParamResolver({'a': 1})]
     sweeps = [cirq.study.Zip(cirq.Points('a', [2])), cirq.study.Zip(cirq.Points('a', [1]))]
     assert cirq.study.to_sweeps(resolvers) == sweeps
     assert cirq.study.to_sweeps([{'a': 2}, {'a': 1}]) == sweeps
 
 
-def test_to_sweeps_iterable_sweeps():
+def test_to_sweeps_iterable_sweeps() -> None:
     sweeps = [cirq.Linspace('a', 0, 1, 10), cirq.Linspace('b', 0, 1, 10)]
     assert cirq.study.to_sweeps(sweeps) == sweeps
 
 
-def test_to_sweeps_dictionary_of_list():
+def test_to_sweeps_dictionary_of_list() -> None:
     with pytest.warns(DeprecationWarning, match='dict_to_product_sweep'):
         assert cirq.study.to_sweeps({'t': [0, 2, 3]}) == cirq.study.to_sweeps(
             [{'t': 0}, {'t': 2}, {'t': 3}]
@@ -98,12 +98,12 @@ def test_to_sweeps_dictionary_of_list():
         )
 
 
-def test_to_sweeps_invalid():
+def test_to_sweeps_invalid() -> None:
     with pytest.raises(TypeError, match='Unrecognized sweepable'):
         cirq.study.to_sweeps('nope')
 
 
-def test_to_sweep_sweep():
+def test_to_sweep_sweep() -> None:
     sweep = cirq.Linspace('a', 0, 1, 10)
     assert cirq.to_sweep(sweep) is sweep
 
@@ -117,7 +117,7 @@ def test_to_sweep_sweep():
         lambda: cirq.ParamResolver({sympy.Symbol('a'): 1}),
     ],
 )
-def test_to_sweep_single_resolver(r_gen):
+def test_to_sweep_single_resolver(r_gen) -> None:
     sweep = cirq.to_sweep(r_gen())
     assert isinstance(sweep, cirq.Sweep)
     assert list(sweep) == [cirq.ParamResolver({'a': 1})]
@@ -141,18 +141,18 @@ def test_to_sweep_single_resolver(r_gen):
         lambda: {object(): r for r in [{'a': 1}, {'a': 1.5}]}.values(),
     ],
 )
-def test_to_sweep_resolver_list(r_list_gen):
+def test_to_sweep_resolver_list(r_list_gen) -> None:
     sweep = cirq.to_sweep(r_list_gen())
     assert isinstance(sweep, cirq.Sweep)
     assert list(sweep) == [cirq.ParamResolver({'a': 1}), cirq.ParamResolver({'a': 1.5})]
 
 
-def test_to_sweep_type_error():
+def test_to_sweep_type_error() -> None:
     with pytest.raises(TypeError, match='Unexpected sweep'):
-        cirq.to_sweep(5)
+        cirq.to_sweep(5)  # type: ignore[arg-type]
 
 
-def test_to_sweeps_with_param_dict_appends_metadata():
+def test_to_sweeps_with_param_dict_appends_metadata() -> None:
     params = {'a': 1, 'b': 2, 'c': 3}
     unit_map = {'a': 'ns', 'b': 'ns'}
 
@@ -167,7 +167,7 @@ def test_to_sweeps_with_param_dict_appends_metadata():
     ]
 
 
-def test_to_sweeps_with_param_list_appends_metadata():
+def test_to_sweeps_with_param_list_appends_metadata() -> None:
     resolvers = [cirq.ParamResolver({'a': 2}), cirq.ParamResolver({'a': 1})]
     unit_map = {'a': 'ns'}
 

cirq/study/sweeps_test.py

@@ -20,27 +20,27 @@ import sympy
 import cirq
 
 
-def test_product_duplicate_keys():
+def test_product_duplicate_keys() -> None:
     with pytest.raises(ValueError):
         _ = cirq.Linspace('a', 0, 9, 10) * cirq.Linspace('a', 0, 10, 11)
 
 
-def test_zip_duplicate_keys():
+def test_zip_duplicate_keys() -> None:
     with pytest.raises(ValueError):
         _ = cirq.Linspace('a', 0, 9, 10) + cirq.Linspace('a', 0, 10, 11)
 
 
-def test_product_wrong_type():
+def test_product_wrong_type() -> None:
     with pytest.raises(TypeError):
-        _ = cirq.Linspace('a', 0, 9, 10) * 2
+        _ = cirq.Linspace('a', 0, 9, 10) * 2  # type: ignore[operator]
 
 
-def test_zip_wrong_type():
+def test_zip_wrong_type() -> None:
     with pytest.raises(TypeError):
-        _ = cirq.Linspace('a', 0, 9, 10) + 2
+        _ = cirq.Linspace('a', 0, 9, 10) + 2  # type: ignore[operator]
 
 
-def test_linspace():
+def test_linspace() -> None:
     sweep = cirq.Linspace('a', 0.34, 9.16, 7)
     assert len(sweep) == 7
     params = list(sweep.param_tuples())
@@ -49,7 +49,7 @@ def test_linspace():
     assert params[-1] == (('a', 9.16),)
 
 
-def test_linspace_one_point():
+def test_linspace_one_point() -> None:
     sweep = cirq.Linspace('a', 0.34, 9.16, 1)
     assert len(sweep) == 1
     params = list(sweep.param_tuples())
@@ -57,7 +57,7 @@ def test_linspace_one_point():
     assert params[0] == (('a', 0.34),)
 
 
-def test_linspace_sympy_symbol():
+def test_linspace_sympy_symbol() -> None:
     a = sympy.Symbol('a')
     sweep = cirq.Linspace(a, 0.34, 9.16, 7)
     assert len(sweep) == 7
@@ -67,14 +67,14 @@ def test_linspace_sympy_symbol():
     assert params[-1] == (('a', 9.16),)
 
 
-def test_points():
+def test_points() -> None:
     sweep = cirq.Points('a', [1, 2, 3, 4])
     assert len(sweep) == 4
     params = list(sweep)
     assert len(params) == 4
 
 
-def test_zip():
+def test_zip() -> None:
     sweep = cirq.Points('a', [1, 2, 3]) + cirq.Points('b', [4, 5, 6, 7])
     assert len(sweep) == 3
     assert _values(sweep, 'a') == [1, 2, 3]
@@ -86,7 +86,7 @@ def test_zip():
     ]
 
 
-def test_zip_longest():
+def test_zip_longest() -> None:
     sweep = cirq.ZipLongest(cirq.Points('a', [1, 2, 3]), cirq.Points('b', [4, 5, 6, 7]))
     assert tuple(sweep.param_tuples()) == (
         (('a', 1), ('b', 4)),
@@ -104,7 +104,7 @@ def test_zip_longest():
     )
 
 
-def test_zip_longest_compatibility():
+def test_zip_longest_compatibility() -> None:
     sweep = cirq.Zip(cirq.Points('a', [1, 2, 3]), cirq.Points('b', [4, 5, 6]))
     sweep_longest = cirq.ZipLongest(cirq.Points('a', [1, 2, 3]), cirq.Points('b', [4, 5, 6]))
     assert tuple(sweep.param_tuples()) == tuple(sweep_longest.param_tuples())
@@ -118,7 +118,7 @@ def test_zip_longest_compatibility():
     assert tuple(sweep.param_tuples()) == tuple(sweep_longest.param_tuples())
 
 
-def test_empty_zip():
+def test_empty_zip() -> None:
     assert len(cirq.Zip()) == 0
     assert len(cirq.ZipLongest()) == 0
     assert str(cirq.Zip()) == 'Zip()'
@@ -126,7 +126,7 @@ def test_empty_zip():
         _ = cirq.ZipLongest(cirq.Points('e', []), cirq.Points('a', [1, 2, 3]))
 
 
-def test_zip_eq():
+def test_zip_eq() -> None:
     et = cirq.testing.EqualsTester()
     point_sweep1 = cirq.Points('a', [1, 2, 3])
     point_sweep2 = cirq.Points('b', [4, 5, 6, 7])
@@ -146,7 +146,7 @@ def test_zip_eq():
     et.add_equality_group(cirq.Zip(point_sweep1, point_sweep2))
 
 
-def test_product():
+def test_product() -> None:
     sweep = cirq.Points('a', [1, 2, 3]) * cirq.Points('b', [4, 5, 6, 7])
     assert len(sweep) == 12
     assert _values(sweep, 'a') == [1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3]
@@ -172,7 +172,7 @@ def test_product():
     assert list(map(list, sweep.param_tuples())) == [[(str(i), 0) for i in range(1025)]]
 
 
-def test_nested_product_zip():
+def test_nested_product_zip() -> None:
     sweep = cirq.Product(
         cirq.Product(cirq.Points('a', [0]), cirq.Points('b', [0])),
         cirq.Zip(cirq.Points('c', [0, 1]), cirq.Points('d', [0, 1])),
@@ -183,7 +183,7 @@ def test_nested_product_zip():
     ]
 
 
-def test_zip_addition():
+def test_zip_addition() -> None:
     zip_sweep = cirq.Zip(cirq.Points('a', [1, 2]), cirq.Points('b', [3, 4]))
     zip_sweep2 = cirq.Points('c', [5, 6]) + zip_sweep
     assert len(zip_sweep2) == 2
@@ -192,17 +192,17 @@ def test_zip_addition():
     assert _values(zip_sweep2, 'c') == [5, 6]
 
 
-def test_empty_product():
+def test_empty_product() -> None:
     sweep = cirq.Product()
     assert len(sweep) == len(list(sweep)) == 1
     assert str(sweep) == 'Product()'
     assert list(map(list, sweep.param_tuples())) == [[]]
 
 
-def test_slice_access_error():
+def test_slice_access_error() -> None:
     sweep = cirq.Points('a', [1, 2, 3])
     with pytest.raises(TypeError, match='<class \'str\'>'):
-        _ = sweep['junk']
+        _ = sweep['junk']  # type: ignore[call-overload]
 
     with pytest.raises(IndexError):
         _ = sweep[4]
@@ -211,7 +211,7 @@ def test_slice_access_error():
         _ = sweep[-4]
 
 
-def test_slice_sweep():
+def test_slice_sweep() -> None:
     sweep = cirq.Points('a', [1, 2, 3]) * cirq.Points('b', [4, 5, 6, 7])
 
     first_two = sweep[:2]
@@ -239,7 +239,7 @@ def test_slice_sweep():
     assert len(list(single_sweep.param_tuples())) == 1
 
 
-def test_access_sweep():
+def test_access_sweep() -> None:
     sweep = cirq.Points('a', [1, 2, 3]) * cirq.Points('b', [4, 5, 6, 7])
 
     first_elem = sweep[-12]
@@ -259,7 +259,7 @@ def test_access_sweep():
         lambda: ({sympy.Symbol('a'): a, 'b': a + 1} for a in (0, 0.5, 1, -10)),
     ],
 )
-def test_list_sweep(r_list_factory):
+def test_list_sweep(r_list_factory) -> None:
     sweep = cirq.ListSweep(r_list_factory())
     assert sweep.keys == ['a', 'b']
     assert len(sweep) == 4
@@ -270,13 +270,13 @@ def test_list_sweep(r_list_factory):
     assert params[3] == (('a', -10), ('b', -9))
 
 
-def test_list_sweep_empty():
+def test_list_sweep_empty() -> None:
     assert cirq.ListSweep([]).keys == []
 
 
-def test_list_sweep_type_error():
+def test_list_sweep_type_error() -> None:
     with pytest.raises(TypeError, match='Not a ParamResolver'):
-        _ = cirq.ListSweep([cirq.ParamResolver(), 'bad'])
+        _ = cirq.ListSweep([cirq.ParamResolver(), 'bad'])  # type: ignore[list-item]
 
 
 def _values(sweep, key):
@@ -284,7 +284,7 @@ def _values(sweep, key):
     return [resolver.value_of(p) for resolver in sweep]
 
 
-def test_equality():
+def test_equality() -> None:
     et = cirq.testing.EqualsTester()
 
     et.add_equality_group(cirq.UnitSweep, cirq.UnitSweep)
@@ -320,7 +320,7 @@ def test_equality():
     et.make_equality_group(lambda: cirq.ListSweep([{'x': 1}, {'x': -1}]))
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(
         cirq.study.sweeps.Product(cirq.UnitSweep),
         setup_code='import cirq\nfrom collections import OrderedDict',
@@ -343,7 +343,7 @@ def test_repr():
     )
 
 
-def test_zip_product_str():
+def test_zip_product_str() -> None:
     assert (
         str(cirq.UnitSweep + cirq.UnitSweep + cirq.UnitSweep)
         == 'cirq.UnitSweep + cirq.UnitSweep + cirq.UnitSweep'
@@ -362,7 +362,7 @@ def test_zip_product_str():
     )
 
 
-def test_list_sweep_str():
+def test_list_sweep_str() -> None:
     assert (
         str(cirq.UnitSweep)
         == '''Sweep:
@@ -411,7 +411,7 @@ def test_list_sweep_str():
     )
 
 
-def test_dict_to_product_sweep():
+def test_dict_to_product_sweep() -> None:
     assert cirq.dict_to_product_sweep({'t': [0, 2, 3]}) == (
         cirq.Product(cirq.Points('t', [0, 2, 3]))
     )
@@ -421,7 +421,7 @@ def test_dict_to_product_sweep():
     )
 
 
-def test_dict_to_zip_sweep():
+def test_dict_to_zip_sweep() -> None:
     assert cirq.dict_to_zip_sweep({'t': [0, 2, 3]}) == (cirq.Zip(cirq.Points('t', [0, 2, 3])))
 
     assert cirq.dict_to_zip_sweep({'t': [0, 1], 's': [2, 3], 'r': 4}) == (
@@ -429,7 +429,7 @@ def test_dict_to_zip_sweep():
     )
 
 
-def test_concat_linspace():
+def test_concat_linspace() -> None:
     sweep1 = cirq.Linspace('a', 0.34, 9.16, 4)
     sweep2 = cirq.Linspace('a', 10, 20, 4)
     concat_sweep = cirq.Concat(sweep1, sweep2)
@@ -444,7 +444,7 @@ def test_concat_linspace():
     assert params[7] == (('a', 20.0),)
 
 
-def test_concat_points():
+def test_concat_points() -> None:
     sweep1 = cirq.Points('a', [1, 2])
     sweep2 = cirq.Points('a', [3, 4, 5])
     concat_sweep = cirq.Concat(sweep1, sweep2)
@@ -456,7 +456,7 @@ def test_concat_points():
     assert _values(concat_sweep, 'a') == [1, 2, 3, 4, 5]
 
 
-def test_concat_many_points():
+def test_concat_many_points() -> None:
     sweep1 = cirq.Points('a', [1, 2])
     sweep2 = cirq.Points('a', [3, 4, 5])
     sweep3 = cirq.Points('a', [6, 7, 8])
@@ -468,7 +468,7 @@ def test_concat_many_points():
     assert _values(concat_sweep, 'a') == [1, 2, 3, 4, 5, 6, 7, 8]
 
 
-def test_concat_mixed():
+def test_concat_mixed() -> None:
     sweep1 = cirq.Linspace('a', 0, 1, 3)
     sweep2 = cirq.Points('a', [2, 3])
     concat_sweep = cirq.Concat(sweep1, sweep2)
@@ -477,7 +477,7 @@ def test_concat_mixed():
     assert _values(concat_sweep, 'a') == [0.0, 0.5, 1.0, 2, 3]
 
 
-def test_concat_inconsistent_keys():
+def test_concat_inconsistent_keys() -> None:
     sweep1 = cirq.Linspace('a', 0, 1, 3)
     sweep2 = cirq.Points('b', [2, 3])
 
@@ -485,7 +485,7 @@ def test_concat_inconsistent_keys():
         cirq.Concat(sweep1, sweep2)
 
 
-def test_concat_sympy_symbol():
+def test_concat_sympy_symbol() -> None:
     a = sympy.Symbol('a')
     sweep1 = cirq.Linspace(a, 0, 1, 3)
     sweep2 = cirq.Points(a, [2, 3])
@@ -495,7 +495,7 @@ def test_concat_sympy_symbol():
     assert _values(concat_sweep, 'a') == [0.0, 0.5, 1.0, 2, 3]
 
 
-def test_concat_repr_and_str():
+def test_concat_repr_and_str() -> None:
     sweep1 = cirq.Linspace('a', 0, 1, 3)
     sweep2 = cirq.Points('a', [2, 3])
     concat_sweep = cirq.Concat(sweep1, sweep2)
@@ -509,7 +509,7 @@ def test_concat_repr_and_str():
     assert str(concat_sweep) == expected_str
 
 
-def test_concat_large_sweep():
+def test_concat_large_sweep() -> None:
     sweep1 = cirq.Points('a', list(range(101)))
     sweep2 = cirq.Points('a', list(range(101, 202)))
     concat_sweep = cirq.Concat(sweep1, sweep2)
@@ -518,7 +518,7 @@ def test_concat_large_sweep():
     assert _values(concat_sweep, 'a') == list(range(101)) + list(range(101, 202))
 
 
-def test_concat_different_keys_raises():
+def test_concat_different_keys_raises() -> None:
     sweep1 = cirq.Linspace('a', 0, 1, 3)
     sweep2 = cirq.Points('b', [2, 3])
 
@@ -526,6 +526,6 @@ def test_concat_different_keys_raises():
         _ = cirq.Concat(sweep1, sweep2)
 
 
-def test_concat_empty_sweep_raises():
+def test_concat_empty_sweep_raises() -> None:
     with pytest.raises(ValueError, match="Concat requires at least one sweep."):
         _ = cirq.Concat()

cirq/testing/circuit_compare_test.py

@@ -21,7 +21,7 @@ import cirq
 from cirq.testing.circuit_compare import _assert_apply_unitary_works_when_axes_transposed
 
 
-def test_sensitive_to_phase():
+def test_sensitive_to_phase() -> None:
     q = cirq.NamedQubit('q')
 
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
@@ -38,7 +38,7 @@ def test_sensitive_to_phase():
     )
 
 
-def test_sensitive_to_measurement_but_not_measured_phase():
+def test_sensitive_to_measurement_but_not_measured_phase() -> None:
     q = cirq.NamedQubit('q')
 
     with pytest.raises(AssertionError):
@@ -80,7 +80,7 @@ def test_sensitive_to_measurement_but_not_measured_phase():
     )
 
 
-def test_sensitive_to_measurement_toggle():
+def test_sensitive_to_measurement_toggle() -> None:
     q = cirq.NamedQubit('q')
 
     with pytest.raises(AssertionError):
@@ -103,7 +103,7 @@ def test_sensitive_to_measurement_toggle():
     )
 
 
-def test_measuring_qubits():
+def test_measuring_qubits() -> None:
     a, b = cirq.LineQubit.range(2)
 
     with pytest.raises(AssertionError):
@@ -126,7 +126,7 @@ def test_measuring_qubits():
 @pytest.mark.parametrize(
     'circuit', [cirq.testing.random_circuit(cirq.LineQubit.range(2), 4, 0.5) for _ in range(5)]
 )
-def test_random_same_matrix(circuit):
+def test_random_same_matrix(circuit) -> None:
     a, b = cirq.LineQubit.range(2)
     same = cirq.Circuit(
         cirq.MatrixGate(circuit.unitary(qubits_that_should_be_present=[a, b])).on(a, b)
@@ -140,7 +140,7 @@ def test_random_same_matrix(circuit):
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(mutable_circuit, same)
 
 
-def test_correct_qubit_ordering():
+def test_correct_qubit_ordering() -> None:
     a, b = cirq.LineQubit.range(2)
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
         cirq.Circuit(cirq.Z(a), cirq.Z(b), cirq.measure(b)),
@@ -154,7 +154,7 @@ def test_correct_qubit_ordering():
         )
 
 
-def test_known_old_failure():
+def test_known_old_failure() -> None:
     a, b = cirq.LineQubit.range(2)
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
         actual=cirq.Circuit(
@@ -170,7 +170,7 @@ def test_known_old_failure():
     )
 
 
-def test_assert_same_circuits():
+def test_assert_same_circuits() -> None:
     a, b = cirq.LineQubit.range(2)
 
     cirq.testing.assert_same_circuits(cirq.Circuit(cirq.H(a)), cirq.Circuit(cirq.H(a)))
@@ -191,7 +191,7 @@ def test_assert_same_circuits():
         )
 
 
-def test_assert_circuits_have_same_unitary_given_final_permutation():
+def test_assert_circuits_have_same_unitary_given_final_permutation() -> None:
     q = cirq.LineQubit.range(5)
     expected = cirq.Circuit([cirq.Moment(cirq.CNOT(q[2], q[1]), cirq.CNOT(q[3], q[0]))])
     actual = cirq.Circuit(
@@ -202,6 +202,7 @@ def test_assert_circuits_have_same_unitary_given_final_permutation():
             cirq.Moment(cirq.CNOT(q[3], q[2])),
         ]
     )
+    qubit_map: dict[cirq.Qid, cirq.Qid]
     qubit_map = {q[0]: q[2], q[2]: q[1], q[1]: q[0]}
     cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
         actual, expected, qubit_map
@@ -213,6 +214,7 @@ def test_assert_circuits_have_same_unitary_given_final_permutation():
             actual, expected, qubit_map=qubit_map
         )
 
+    bad_qubit_map: dict[cirq.Qid, cirq.Qid]
     bad_qubit_map = {q[0]: q[2], q[2]: q[4], q[4]: q[0]}
     with pytest.raises(ValueError, match="'qubit_map' must be a mapping"):
         cirq.testing.assert_circuits_have_same_unitary_given_final_permutation(
@@ -220,7 +222,7 @@ def test_assert_circuits_have_same_unitary_given_final_permutation():
         )
 
 
-def test_assert_has_diagram():
+def test_assert_has_diagram() -> None:
     a, b = cirq.LineQubit.range(2)
     circuit = cirq.Circuit(cirq.CNOT(a, b))
     cirq.testing.assert_has_diagram(
@@ -263,7 +265,7 @@ Highlighted differences:
     assert expected_error in ex_info.value.args[0]
 
 
-def test_assert_has_consistent_apply_channel():
+def test_assert_has_consistent_apply_channel() -> None:
     class Correct:
         def _apply_channel_(self, args: cirq.ApplyChannelArgs):
             args.target_tensor[...] = 0
@@ -329,7 +331,7 @@ def test_assert_has_consistent_apply_channel():
     cirq.testing.assert_has_consistent_apply_channel(NoApply())
 
 
-def test_assert_has_consistent_apply_unitary():
+def test_assert_has_consistent_apply_unitary() -> None:
     class IdentityReturningUnalteredWorkspace:
         def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs) -> np.ndarray:
             return args.available_buffer
@@ -461,7 +463,7 @@ def test_assert_has_consistent_apply_unitary():
     cirq.testing.assert_has_consistent_apply_unitary(cirq.X.on(cirq.NamedQubit('q')))
 
 
-def test_assert_has_consistent_qid_shape():
+def test_assert_has_consistent_qid_shape() -> None:
     class ConsistentGate(cirq.Gate):
         def _num_qubits_(self):
             return 4
@@ -560,7 +562,7 @@ def test_assert_has_consistent_qid_shape():
     cirq.testing.assert_has_consistent_qid_shape(NoProtocol())
 
 
-def test_assert_apply_unitary_works_when_axes_transposed_failure():
+def test_assert_apply_unitary_works_when_axes_transposed_failure() -> None:
     class BadOp:
         def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs):
             # Get a more convenient view of the data.

cirq/testing/consistent_channels.py

@@ -21,7 +21,7 @@ import numpy as np
 import cirq
 
 
-def assert_consistent_channel(gate: Any, rtol: float = 1e-5, atol: float = 1e-8):
+def assert_consistent_channel(gate: Any, rtol: float = 1e-5, atol: float = 1e-8) -> None:
     """Asserts that a given gate has Kraus operators and that they are properly normalized."""
     assert cirq.has_kraus(gate), f"Given gate {gate!r} does not return True for cirq.has_kraus."
     kraus_ops = cirq.kraus(gate)
@@ -31,7 +31,7 @@ def assert_consistent_channel(gate: Any, rtol: float = 1e-5, atol: float = 1e-8)
     )
 
 
-def assert_consistent_mixture(gate: Any, rtol: float = 1e-5, atol: float = 1e-8):
+def assert_consistent_mixture(gate: Any, rtol: float = 1e-5, atol: float = 1e-8) -> None:
     """Asserts that a given gate is a mixture and the mixture probabilities sum to one."""
     assert cirq.has_mixture(gate), f"Give gate {gate!r} does not return for cirq.has_mixture."
     mixture = cirq.mixture(gate)

cirq/testing/consistent_controlled_gate_op.py

@@ -38,7 +38,7 @@ def assert_controlled_and_controlled_by_identical(
         _assert_gate_consistent(gate, num_control, control_value)
 
 
-def assert_controlled_unitary_consistent(gate: ops.Gate):
+def assert_controlled_unitary_consistent(gate: ops.Gate) -> None:
     """Checks that unitary of ControlledGate(gate) is consistent with gate.controlled()."""
 
     u_orig = protocols.unitary(ops.ControlledGate(gate))

cirq/testing/consistent_decomposition.py

@@ -22,7 +22,9 @@ from cirq import circuits, devices, ops, protocols
 from cirq.testing import lin_alg_utils
 
 
-def assert_decompose_is_consistent_with_unitary(val: Any, ignoring_global_phase: bool = False):
+def assert_decompose_is_consistent_with_unitary(
+    val: Any, ignoring_global_phase: bool = False
+) -> None:
     """Uses `val._unitary_` to check `val._phase_by_`'s behavior."""
     __tracebackhide__ = True
 
@@ -76,7 +78,7 @@ def _known_gate_with_no_decomposition(val: Any):
     return False
 
 
-def assert_decompose_ends_at_default_gateset(val: Any, ignore_known_gates: bool = True):
+def assert_decompose_ends_at_default_gateset(val: Any, ignore_known_gates: bool = True) -> None:
     """Asserts that cirq.decompose(val) ends at default cirq gateset or a known gate."""
     args = () if isinstance(val, ops.Operation) else (tuple(devices.LineQid.for_gate(val)),)
     dec_once = protocols.decompose_once(val, [val(*args[0]) if args else val], *args)

cirq/testing/consistent_phase_by.py

@@ -23,7 +23,7 @@ from cirq import linalg, protocols
 from cirq.testing import lin_alg_utils
 
 
-def assert_phase_by_is_consistent_with_unitary(val: Any):
+def assert_phase_by_is_consistent_with_unitary(val: Any) -> None:
     """Uses `val._unitary_` to check `val._phase_by_`'s behavior."""
 
     original = protocols.unitary(val, None)

cirq/testing/consistent_qasm.py

@@ -23,7 +23,7 @@ from cirq import devices, linalg, ops, protocols
 from cirq.testing import lin_alg_utils
 
 
-def assert_qasm_is_consistent_with_unitary(val: Any):
+def assert_qasm_is_consistent_with_unitary(val: Any) -> None:
     """Uses `val._unitary_` to check `val._qasm_`'s behavior."""
 
     # Only test if qiskit is installed.
@@ -106,7 +106,7 @@ qreg q[{num_qubits}];
         )
 
 
-def assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, unitary):  # pragma: no cover
+def assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, unitary) -> None:  # pragma: no cover
     try:
         # We don't want to require qiskit as a dependency but
         # if Qiskit is installed, test QASM output against it.