cirq-core 1.6.0.dev20250529194600__py3-none-any.whl → 1.6.0.dev20250530203656__py3-none-any.whl

cirq/ops/projector_test.py

@@ -8,7 +8,7 @@ import pytest
 import cirq
 
 
-def test_projector_matrix():
+def test_projector_matrix() -> None:
     q0 = cirq.NamedQubit('q0')
 
     zero_projector = cirq.ProjectorString({q0: 0})
@@ -18,11 +18,11 @@ def test_projector_matrix():
     np.testing.assert_allclose(zero_projector.matrix().toarray(), [[1.0, 0.0], [0.0, 0.0]])
     np.testing.assert_allclose(one_projector.matrix().toarray(), [[0.0, 0.0], [0.0, 1.0]])
     np.testing.assert_allclose(
-        coeff_projector.matrix().toarray(), [[1.23 + 4.56j, 0.0], [0.0, 0.0]]
+        coeff_projector.matrix().toarray(), np.asarray([[1.23 + 4.56j, 0.0], [0.0, 0.0]])
     )
 
 
-def test_projector_repr():
+def test_projector_repr() -> None:
     q0 = cirq.NamedQubit('q0')
 
     assert (
@@ -31,14 +31,14 @@ def test_projector_repr():
     )
 
 
-def test_projector_from_np_array():
+def test_projector_from_np_array() -> None:
     q0 = cirq.NamedQubit('q0')
 
     zero_projector = cirq.ProjectorString({q0: 0})
     np.testing.assert_allclose(zero_projector.matrix().toarray(), [[1.0, 0.0], [0.0, 0.0]])
 
 
-def test_projector_matrix_missing_qid():
+def test_projector_matrix_missing_qid() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     proj = cirq.ProjectorString({q0: 0})
     proj_with_coefficient = cirq.ProjectorString({q0: 0}, 1.23 + 4.56j)
@@ -56,7 +56,7 @@ def test_projector_matrix_missing_qid():
     )
 
 
-def test_equality():
+def test_equality() -> None:
     q0 = cirq.NamedQubit('q0')
 
     obj1a = cirq.ProjectorString({q0: 0})
@@ -70,7 +70,7 @@ def test_equality():
     eq.add_equality_group(obj3)
 
 
-def test_get_values():
+def test_get_values() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0}, 1.23 + 4.56j)
 
@@ -79,14 +79,14 @@ def test_get_values():
     assert d.coefficient == 1.23 + 4.56j
 
 
-def test_expectation_from_state_vector_basis_states_empty():
+def test_expectation_from_state_vector_basis_states_empty() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({})
 
     np.testing.assert_allclose(d.expectation_from_state_vector(np.array([1.0, 0.0]), {q0: 0}), 1.0)
 
 
-def test_expectation_from_state_vector_basis_states_single_qubits():
+def test_expectation_from_state_vector_basis_states_single_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0})
 
@@ -94,7 +94,7 @@ def test_expectation_from_state_vector_basis_states_single_qubits():
     np.testing.assert_allclose(d.expectation_from_state_vector(np.array([0.0, 1.0]), {q0: 0}), 0.0)
 
 
-def test_expectation_from_state_vector_basis_states_three_qubits():
+def test_expectation_from_state_vector_basis_states_three_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
@@ -144,7 +144,7 @@ def test_expectation_from_state_vector_basis_states_three_qubits():
     )
 
 
-def test_expectation_from_density_matrix_three_qubits():
+def test_expectation_from_density_matrix_three_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
@@ -194,7 +194,7 @@ def test_expectation_from_density_matrix_three_qubits():
     )
 
 
-def test_consistency_state_vector_and_density_matrix():
+def test_consistency_state_vector_and_density_matrix() -> None:
     q0 = cirq.NamedQubit('q0')
     q1 = cirq.NamedQubit('q1')
     q2 = cirq.NamedQubit('q2')
@@ -212,7 +212,7 @@ def test_consistency_state_vector_and_density_matrix():
             )
 
 
-def test_expectation_higher_dims():
+def test_expectation_higher_dims() -> None:
     qubit = cirq.NamedQid('q0', dimension=2)
     qutrit = cirq.NamedQid('q1', dimension=3)
 
@@ -224,7 +224,7 @@ def test_expectation_higher_dims():
         _ = (d.expectation_from_state_vector(np.zeros(2 * 3), {qubit: 0, qutrit: 0}),)
 
 
-def test_expectation_with_coefficient():
+def test_expectation_with_coefficient() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0}, coefficient=(0.6 + 0.4j))
 
@@ -237,7 +237,7 @@ def test_expectation_with_coefficient():
     )
 
 
-def test_expectation_from_density_matrix_basis_states_empty():
+def test_expectation_from_density_matrix_basis_states_empty() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({})
 
@@ -246,7 +246,7 @@ def test_expectation_from_density_matrix_basis_states_empty():
     )
 
 
-def test_expectation_from_density_matrix_basis_states_single_qubits():
+def test_expectation_from_density_matrix_basis_states_single_qubits() -> None:
     q0 = cirq.NamedQubit('q0')
     d = cirq.ProjectorString({q0: 0})
 

cirq/ops/qubit_order_test.py

@@ -19,7 +19,7 @@ import pytest
 import cirq
 
 
-def test_default():
+def test_default() -> None:
     a2 = cirq.NamedQubit('a2')
     a10 = cirq.NamedQubit('a10')
     b = cirq.NamedQubit('b')
@@ -32,7 +32,7 @@ def test_default():
     assert sorted([q5, a10, a2, b, q4]) == [q4, q5, a2, a10, b]
 
 
-def test_default_grouping():
+def test_default_grouping() -> None:
     presorted = (
         cirq.GridQubit(0, 1),
         cirq.GridQubit(1, 0),
@@ -50,7 +50,7 @@ def test_default_grouping():
     assert cirq.QubitOrder.DEFAULT.order_for(reversed(presorted)) == presorted
 
 
-def test_explicit():
+def test_explicit() -> None:
     a2 = cirq.NamedQubit('a2')
     a10 = cirq.NamedQubit('a10')
     b = cirq.NamedQubit('b')
@@ -64,7 +64,7 @@ def test_explicit():
         _ = q.order_for([cirq.NamedQubit('c')])
 
 
-def test_explicit_with_fallback():
+def test_explicit_with_fallback() -> None:
     a2 = cirq.NamedQubit('a2')
     a10 = cirq.NamedQubit('a10')
     b = cirq.NamedQubit('b')
@@ -76,7 +76,7 @@ def test_explicit_with_fallback():
     assert q.order_for([a10, a2]) == (b, a2, a10)
 
 
-def test_sorted_by():
+def test_sorted_by() -> None:
     a = cirq.NamedQubit('2')
     b = cirq.NamedQubit('10')
     c = cirq.NamedQubit('-5')
@@ -88,7 +88,7 @@ def test_sorted_by():
     assert q.order_for([a, b, c]) == (b, a, c)
 
 
-def test_map():
+def test_map() -> None:
     b = cirq.NamedQubit('b!')
     q = cirq.QubitOrder.explicit([cirq.NamedQubit('b')]).map(
         internalize=lambda e: cirq.NamedQubit(e.name[:-1]),
@@ -99,7 +99,7 @@ def test_map():
     assert q.order_for([b]) == (b,)
 
 
-def test_qubit_order_or_list():
+def test_qubit_order_or_list() -> None:
     b = cirq.NamedQubit('b')
 
     implied_by_list = cirq.QubitOrder.as_qubit_order([b])
@@ -116,7 +116,7 @@ def test_qubit_order_or_list():
     assert ordered is passed_through
 
 
-def test_qubit_order_iterator():
+def test_qubit_order_iterator() -> None:
     generator = (q for q in cirq.LineQubit.range(5))
     assert cirq.QubitOrder.explicit(generator).order_for((cirq.LineQubit(3),)) == tuple(
         cirq.LineQubit.range(5)
@@ -128,6 +128,6 @@ def test_qubit_order_iterator():
     )
 
 
-def test_qubit_order_invalid():
+def test_qubit_order_invalid() -> None:
     with pytest.raises(ValueError, match="Don't know how to interpret <5> as a Basis."):
-        _ = cirq.QubitOrder.as_qubit_order(5)
+        _ = cirq.QubitOrder.as_qubit_order(5)  # type: ignore[arg-type]

cirq/ops/raw_types.py

@@ -227,7 +227,7 @@ class Gate(metaclass=value.ABCMetaImplementAnyOneOf):
         if __cirq_debug__.get():
             _validate_qid_shape(self, qubits)
 
-    def on(self, *qubits: Qid) -> Operation:
+    def on(self, *qubits: Qid) -> cirq.Operation:
         """Returns an application of this gate to the given qubits.
 
         Args:
@@ -654,7 +654,7 @@ class Operation(metaclass=abc.ABCMeta):
             *self.qubits
         )
 
-    def validate_args(self, qubits: Sequence[cirq.Qid]):
+    def validate_args(self, qubits: Sequence[cirq.Qid]) -> None:
         """Raises an exception if the `qubits` don't match this operation's qid
         shape.
 

cirq/ops/raw_types_test.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-from typing import AbstractSet, Any, Iterator
+from typing import AbstractSet, Any, cast, Iterator
 
 import numpy as np
 import pytest
@@ -28,7 +28,7 @@ class ValidQubit(cirq.Qid):
         self._name = name
 
     @property
-    def dimension(self):
+    def dimension(self) -> int:
         return 2
 
     def _comparison_key(self):
@@ -51,19 +51,19 @@ class ValidQid(cirq.Qid):
     def dimension(self):
         return self._dimension
 
-    def with_dimension(self, dimension):
+    def with_dimension(self, dimension) -> ValidQid:
         return ValidQid(self._name, dimension)
 
     def _comparison_key(self):
         return self._name
 
 
-def test_wrapped_qid():
+def test_wrapped_qid() -> None:
     assert type(ValidQubit('a').with_dimension(3)) is not ValidQubit
     assert type(ValidQubit('a').with_dimension(2)) is ValidQubit
     assert type(ValidQubit('a').with_dimension(5).with_dimension(2)) is ValidQubit
     assert ValidQubit('a').with_dimension(3).with_dimension(4) == ValidQubit('a').with_dimension(4)
-    assert ValidQubit('a').with_dimension(3).qubit == ValidQubit('a')
+    assert ValidQubit('a').with_dimension(3).qubit == ValidQubit('a')  # type: ignore[attr-defined]
     assert ValidQubit('a').with_dimension(3) == ValidQubit('a').with_dimension(3)
     assert ValidQubit('a').with_dimension(3) < ValidQubit('a').with_dimension(4)
     assert ValidQubit('a').with_dimension(3) < ValidQubit('b').with_dimension(3)
@@ -74,7 +74,7 @@ def test_wrapped_qid():
     )
     assert str(ValidQubit('a').with_dimension(3)) == 'TQ_a (d=3)'
 
-    assert ValidQubit('zz').with_dimension(3)._json_dict_() == {
+    assert ValidQubit('zz').with_dimension(3)._json_dict_() == {  # type: ignore[attr-defined]
         'qubit': ValidQubit('zz'),
         'dimension': 3,
     }
@@ -88,7 +88,7 @@ def test_wrapped_qid():
     assert ValidQubit('zz') >= ValidQubit('aa')
 
 
-def test_qid_dimension():
+def test_qid_dimension() -> None:
     assert ValidQubit('a').dimension == 2
     assert ValidQubit('a').with_dimension(3).dimension == 3
     with pytest.raises(ValueError, match='Wrong qid dimension'):
@@ -109,7 +109,7 @@ class ValiGate(cirq.Gate):
     def _num_qubits_(self):
         return 2
 
-    def validate_args(self, qubits):
+    def validate_args(self, qubits) -> None:
         if len(qubits) == 1:
             return  # Bypass check for some tests
         super().validate_args(qubits)
@@ -118,7 +118,7 @@ class ValiGate(cirq.Gate):
         return True
 
 
-def test_gate():
+def test_gate() -> None:
     a, b, c = cirq.LineQubit.range(3)
 
     g = ValiGate()
@@ -138,7 +138,7 @@ def test_gate():
     assert g.controlled(0) is g
 
 
-def test_op():
+def test_op() -> None:
     a, b, c, d = cirq.LineQubit.range(4)
     g = ValiGate()
     op = g(a, b)
@@ -148,7 +148,7 @@ def test_op():
     assert controlled_op.controls == (c, d)
 
 
-def test_op_validate():
+def test_op_validate() -> None:
     op = cirq.X(cirq.LineQid(0, 2))
     op2 = cirq.CNOT(*cirq.LineQid.range(2, dimension=2))
     op.validate_args([cirq.LineQid(1, 2)])  # Valid
@@ -161,7 +161,7 @@ def test_op_validate():
         op2.validate_args([cirq.LineQid(1, 2), cirq.LineQid(1, 2)])
 
 
-def test_disable_op_validation():
+def test_disable_op_validation() -> None:
     q0, q1 = cirq.LineQubit.range(2)
     h_op = cirq.H(q0)
 
@@ -184,7 +184,7 @@ def test_disable_op_validation():
         h_op.validate_args([q0, q1])
 
 
-def test_default_validation_and_inverse():
+def test_default_validation_and_inverse() -> None:
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
             return 2
@@ -206,13 +206,15 @@ def test_default_validation_and_inverse():
     with pytest.raises(ValueError, match='number of qubits'):
         TestGate().on(a)
 
-    t = TestGate().on(a, b)
-    i = t**-1
+    t = cast(cirq.GateOperation, TestGate().on(a, b))
+    i = cast(cirq.GateOperation, t**-1)
     assert i**-1 == t
     assert t**-1 == i
     assert cirq.decompose(i) == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]
-    assert [*i._decompose_()] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]
-    assert [*i.gate._decompose_([a, b])] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]
+    assert [*i._decompose_()] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]  # type: ignore[misc]
+    gate = i.gate
+    assert gate is not None
+    assert [*gate._decompose_([a, b])] == [cirq.X(a), cirq.S(b) ** -1, cirq.Z(a)]  # type: ignore
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.unitary(i), cirq.unitary(t).conj().T, atol=1e-8
     )
@@ -220,7 +222,7 @@ def test_default_validation_and_inverse():
     cirq.testing.assert_implements_consistent_protocols(i, local_vals={'TestGate': TestGate})
 
 
-def test_default_no_qubits():
+def test_default_no_qubits() -> None:
     class TestOp(cirq.Operation):
         def with_qubits(self, *new_qubits):
             raise NotImplementedError()
@@ -231,11 +233,11 @@ def test_default_no_qubits():
 
     op = TestOp()
     assert op.controlled_by(*[]) is op
-    op = TestOp().with_tags("abc")
-    assert op.classical_controls == frozenset()
+    tagged_op = TestOp().with_tags("abc")
+    assert tagged_op.classical_controls == frozenset()
 
 
-def test_default_inverse():
+def test_default_inverse() -> None:
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
             return 3
@@ -250,7 +252,7 @@ def test_default_inverse():
     )
 
 
-def test_no_inverse_if_not_unitary():
+def test_no_inverse_if_not_unitary() -> None:
     class TestGate(cirq.Gate):
         def _num_qubits_(self):
             return 1
@@ -261,7 +263,7 @@ def test_no_inverse_if_not_unitary():
     assert cirq.inverse(TestGate(), None) is None
 
 
-def test_default_qudit_inverse():
+def test_default_qudit_inverse() -> None:
     class TestGate(cirq.Gate):
         def _qid_shape_(self):
             return (1, 2, 3)
@@ -286,11 +288,11 @@ def test_default_qudit_inverse():
         (-cirq.X * sympy.Symbol('s'), -sympy.Symbol('s') * cirq.X),
     ),
 )
-def test_gate_algebra(expression, expected_result):
+def test_gate_algebra(expression, expected_result) -> None:
     assert expression == expected_result
 
 
-def test_gate_shape():
+def test_gate_shape() -> None:
     class ShapeGate(cirq.Gate):
         def _qid_shape_(self):
             return (1, 2, 3, 4)
@@ -319,7 +321,7 @@ def test_gate_shape():
     assert dep_gate.num_qubits() == 3
 
 
-def test_gate_shape_protocol():
+def test_gate_shape_protocol() -> None:
     """This test is only needed while the `_num_qubits_` and `_qid_shape_`
     methods are implemented as alternatives.  This can be removed once the
     deprecated `num_qubits` method is removed."""
@@ -379,7 +381,7 @@ def test_gate_shape_protocol():
     assert QubitGate().num_qubits() == 2  # Deprecated
 
 
-def test_operation_shape():
+def test_operation_shape() -> None:
     class FixedQids(cirq.Operation):
         def with_qubits(self, *new_qids):
             raise NotImplementedError
@@ -421,12 +423,12 @@ def test_operation_shape():
     assert cirq.num_qubits(shape_op) == 4
 
 
-def test_gate_json_dict():
+def test_gate_json_dict() -> None:
     g = cirq.CSWAP  # not an eigen gate (which has its own _json_dict_)
     assert g._json_dict_() == {}
 
 
-def test_inverse_composite_diagram_info():
+def test_inverse_composite_diagram_info() -> None:
     class Gate(cirq.Gate):
         def _decompose_(self, qubits):
             return cirq.S.on(qubits[0])
@@ -453,7 +455,7 @@ def test_inverse_composite_diagram_info():
     )
 
 
-def test_tagged_operation_equality():
+def test_tagged_operation_equality() -> None:
     eq = cirq.testing.EqualsTester()
     q1 = cirq.GridQubit(1, 1)
     op = cirq.X(q1)
@@ -470,7 +472,7 @@ def test_tagged_operation_equality():
     )
 
 
-def test_tagged_operation():
+def test_tagged_operation() -> None:
     q1 = cirq.GridQubit(1, 1)
     q2 = cirq.GridQubit(2, 2)
     op = cirq.X(q1).with_tags('tag1')
@@ -491,7 +493,7 @@ def test_tagged_operation():
         _ = cirq.X(q1).with_tags(cirq.Circuit)
 
 
-def test_with_tags_returns_same_instance_if_possible():
+def test_with_tags_returns_same_instance_if_possible() -> None:
     untagged = cirq.X(cirq.GridQubit(1, 1))
     assert untagged.with_tags() is untagged
 
@@ -499,7 +501,7 @@ def test_with_tags_returns_same_instance_if_possible():
     assert tagged.with_tags() is tagged
 
 
-def test_tagged_measurement():
+def test_tagged_measurement() -> None:
     assert not cirq.is_measurement(cirq.global_phase_operation(coefficient=-1.0).with_tags('tag0'))
 
     a = cirq.LineQubit(0)
@@ -513,14 +515,14 @@ def test_tagged_measurement():
     assert cirq.with_measurement_key_mapping(op, {'x': 'k'}) == op
 
 
-def test_cannot_remap_non_measurement_gate():
+def test_cannot_remap_non_measurement_gate() -> None:
     a = cirq.LineQubit(0)
     op = cirq.X(a).with_tags('tag')
 
     assert cirq.with_measurement_key_mapping(op, {'m': 'k'}) is NotImplemented
 
 
-def test_circuit_diagram():
+def test_circuit_diagram() -> None:
     class TaggyTag:
         """Tag with a custom str function to test circuit diagrams."""
 
@@ -538,7 +540,7 @@ def test_circuit_diagram():
         exponent_qubit_index=None,
         auto_exponent_parens=True,
     )
-    args = cirq.CircuitDiagramInfoArgs(None, None, None, None, None, False)
+    args = cirq.CircuitDiagramInfoArgs(None, None, False, None, None, False)
     assert cirq.circuit_diagram_info(tagged_h) == expected
     assert cirq.circuit_diagram_info(tagged_h, args) == cirq.circuit_diagram_info(h)
 
@@ -555,7 +557,7 @@ def test_circuit_diagram():
     assert c.to_text_diagram(include_tags=False) == diagram_without_tags
 
 
-def test_circuit_diagram_tagged_global_phase():
+def test_circuit_diagram_tagged_global_phase() -> None:
     # Tests global phase operation
     q = cirq.NamedQubit('a')
     global_phase = cirq.global_phase_operation(coefficient=-1.0).with_tags('tag0')
@@ -622,7 +624,7 @@ global phase:   0.5π[tag1]   0.5π[tag2]
     )
 
 
-def test_circuit_diagram_no_circuit_diagram():
+def test_circuit_diagram_no_circuit_diagram() -> None:
     class NoCircuitDiagram(cirq.Gate):
         def num_qubits(self) -> int:
             return 1
@@ -637,7 +639,7 @@ def test_circuit_diagram_no_circuit_diagram():
     assert cirq.Circuit(NoCircuitDiagram()(q).with_tags('taggy')).to_text_diagram() == expected
 
 
-def test_tagged_operation_forwards_protocols():
+def test_tagged_operation_forwards_protocols() -> None:
     """The results of all protocols applied to an operation with a tag should
     be equivalent to the result without tags.
     """
@@ -719,7 +721,7 @@ def test_tagged_operation_forwards_protocols():
     assert tagged_mixture[1][0] == flip_mixture[1][0]
     assert np.isclose(tagged_mixture[1][1], flip_mixture[1][1]).all()
 
-    qubit_map = {q1: 'q1'}
+    qubit_map: dict[cirq.Qid, str] = {q1: 'q1'}
     qasm_args = cirq.QasmArgs(qubit_id_map=qubit_map)
     assert cirq.qasm(h, args=qasm_args) == cirq.qasm(tagged_h, args=qasm_args)
 
@@ -746,7 +748,7 @@ class ParameterizableTag:
 
 
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_tagged_operation_resolves_parameterized_tags(resolve_fn):
+def test_tagged_operation_resolves_parameterized_tags(resolve_fn) -> None:
     q = cirq.GridQubit(0, 0)
     tag = ParameterizableTag(sympy.Symbol('t'))
     assert cirq.is_parameterized(tag)
@@ -760,7 +762,7 @@ def test_tagged_operation_resolves_parameterized_tags(resolve_fn):
     assert cirq.parameter_names(resolved_op) == set()
 
 
-def test_inverse_composite_standards():
+def test_inverse_composite_standards() -> None:
     @cirq.value_equality
     class Gate(cirq.Gate):
         def __init__(self, param: cirq.TParamVal):
@@ -801,7 +803,7 @@ def test_inverse_composite_standards():
     assert str(g) == 'C(a)†'
 
 
-def test_tagged_act_on():
+def test_tagged_act_on() -> None:
     class YesActOn(cirq.Gate):
         def _num_qubits_(self) -> int:
             return 1
@@ -835,7 +837,7 @@ def test_tagged_act_on():
         cirq.act_on(MissingActOn().with_tags("test"), args)
 
 
-def test_single_qubit_gate_validates_on_each():
+def test_single_qubit_gate_validates_on_each() -> None:
     class Example(cirq.testing.SingleQubitGate):
         def matrix(self):
             pass
@@ -859,7 +861,7 @@ def test_single_qubit_gate_validates_on_each():
         _ = g.on_each(*test_non_qubits)
 
 
-def test_on_each():
+def test_on_each() -> None:
     class CustomGate(cirq.testing.SingleQubitGate):
         pass
 
@@ -890,7 +892,7 @@ def test_on_each():
     assert c.on_each(qubit_iterator) == [c(a), c(b), c(a), c(b)]
 
 
-def test_on_each_two_qubits():
+def test_on_each_two_qubits() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     g = cirq.testing.TwoQubitGate()
@@ -945,7 +947,7 @@ def test_on_each_two_qubits():
     assert g.on_each(qubit_iterator) == [g(a, b), g(a, b)]
 
 
-def test_on_each_three_qubits():
+def test_on_each_three_qubits() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.NamedQubit('c')
@@ -995,7 +997,7 @@ def test_on_each_three_qubits():
     assert g.on_each(qubit_iterator) == [g(a, b, c), g(a, b, c)]
 
 
-def test_on_each_iterable_qid():
+def test_on_each_iterable_qid() -> None:
     class QidIter(cirq.Qid):
         @property
         def dimension(self) -> int:
@@ -1013,7 +1015,7 @@ def test_on_each_iterable_qid():
 @pytest.mark.parametrize(
     'op', [cirq.X(cirq.NamedQubit("q")), cirq.X(cirq.NamedQubit("q")).with_tags("tagged_op")]
 )
-def test_with_methods_return_self_on_empty_conditions(op):
+def test_with_methods_return_self_on_empty_conditions(op) -> None:
     assert op is op.with_tags(*[])
     assert op is op.with_classical_controls(*[])
     assert op is op.controlled_by(*[])

cirq/ops/wait_gate.py

@@ -33,7 +33,7 @@ class WaitGate(raw_types.Gate):
 
     def __init__(
         self,
-        duration: cirq.DURATION_LIKE,
+        duration: cirq.DURATION_LIKE | int,
         num_qubits: int | None = None,
         qid_shape: tuple[int, ...] | None = None,
     ) -> None:

cirq/ops/wait_gate_test.py

@@ -22,7 +22,7 @@ import sympy
 import cirq
 
 
-def test_init():
+def test_init() -> None:
     g = cirq.WaitGate(datetime.timedelta(0, 0, 5))
     assert g.duration == cirq.Duration(micros=5)
 
@@ -39,13 +39,13 @@ def test_init():
         _ = cirq.WaitGate(2)
 
 
-def test_eq():
+def test_eq() -> None:
     eq = cirq.testing.EqualsTester()
     eq.add_equality_group(cirq.WaitGate(0), cirq.WaitGate(cirq.Duration()))
     eq.make_equality_group(lambda: cirq.WaitGate(cirq.Duration(nanos=4)))
 
 
-def test_protocols():
+def test_protocols() -> None:
     t = sympy.Symbol('t')
     p = cirq.WaitGate(cirq.Duration(millis=5 * t))
     c = cirq.WaitGate(cirq.Duration(millis=2))
@@ -70,7 +70,7 @@ def test_protocols():
     assert cirq.decompose(p.on(q)) == []
 
 
-def test_qid_shape():
+def test_qid_shape() -> None:
     assert cirq.qid_shape(cirq.WaitGate(0, qid_shape=(2, 3))) == (2, 3)
     assert cirq.qid_shape(cirq.WaitGate(0, num_qubits=3)) == (2, 2, 2)
     with pytest.raises(ValueError, match='empty set of qubits'):
@@ -87,7 +87,7 @@ def test_resolve_parameters(num_qubits: int) -> None:
     assert cirq.num_qubits(resolved) == num_qubits
 
 
-def test_json():
+def test_json() -> None:
     q0, q1 = cirq.GridQubit.rect(1, 2)
     qtrit = cirq.GridQid(1, 2, dimension=3)
     cirq.testing.assert_json_roundtrip_works(cirq.wait(q0, nanos=10))
@@ -96,5 +96,5 @@ def test_json():
     cirq.testing.assert_json_roundtrip_works(cirq.wait(qtrit, q1, nanos=10))
 
 
-def test_str():
+def test_str() -> None:
     assert str(cirq.WaitGate(cirq.Duration(nanos=5))) == 'WaitGate(5 ns)'