Add return-type to public functions, mostly tests part 1

benchmarks/bench_linalg_decompositions.py

@@ -29,7 +29,7 @@
 # yapf: enable
 
 
-def time_kak_decomposition(target):
+def time_kak_decomposition(target) -> None:
     """Benchmark kak_decomposition
     kak_decomposition is benchmarked because it was historically slow.
     See https://github.com/quantumlib/Cirq/issues/3840 for status of other benchmarks.

benchmarks/circuit_construction.py

@@ -131,6 +131,6 @@ class XOnAllQubitsCircuit:
     params = [[1, 10, 100, 1000], [1, 10, 100, 1000]]
     param_names = ["Number of Qubits(N)", "Depth(D)"]
 
-    def time_circuit_construction(self, N: int, D: int):
+    def time_circuit_construction(self, N: int, D: int) -> cirq.Circuit:
         q = cirq.LineQubit.range(N)
         return cirq.Circuit(cirq.Moment(cirq.X.on_each(*q)) for _ in range(D))

benchmarks/parameter_resolution.py

@@ -24,15 +24,15 @@ class RabiCalibration:
     params = ([50, 100, 150, 200], [20, 40, 60, 80, 100])
     param_names = ["num_qubits", "num_scan_points"]
 
-    def setup(self, num_qubits: int, _):
+    def setup(self, num_qubits: int, _) -> None:
         qubits = cirq.GridQubit.rect(1, num_qubits)
         self.symbols = {q: sympy.Symbol(f'a_{q}') for q in qubits}
         self.circuit = cirq.Circuit(
             [cirq.X(q) ** self.symbols[q] for q in qubits], cirq.measure_each(*qubits)
         )
         self.qubit_amps = {q: random.uniform(0.48, 0.52) for q in qubits}
 
-    def time_parameter_resolution(self, _, num_scan_points: int):
+    def time_parameter_resolution(self, _, num_scan_points: int) -> None:
         for diff in np.linspace(-0.3, 0.3, num=num_scan_points):
             resolver = {self.symbols[q]: amp + diff for q, amp in self.qubit_amps.items()}
             _ = cirq.resolve_parameters(self.circuit, resolver)

benchmarks/randomized_benchmarking.py

@@ -39,7 +39,7 @@ class SingleQubitRandomizedBenchmarking:
     param_names = ["depth", "num_qubits", "num_circuits"]
     timeout = 600  # Change timeout to 10 minutes instead of default 60 seconds.
 
-    def setup(self, *_):
+    def setup(self, *_) -> None:
         self.sq_xz_matrices = np.array(
             [
                 dot([cirq.unitary(c) for c in reversed(group)])
@@ -60,12 +60,12 @@ def _get_op_grid(self, qubits: list[cirq.Qid], depth: int) -> list[list[cirq.Ope
             op_grid.append(op_sequence)
         return op_grid
 
-    def time_rb_op_grid_generation(self, depth: int, num_qubits: int, num_circuits: int):
+    def time_rb_op_grid_generation(self, depth: int, num_qubits: int, num_circuits: int) -> None:
         qubits = cirq.GridQubit.rect(1, num_qubits)
         for _ in range(num_circuits):
             self._get_op_grid(qubits, depth)
 
-    def time_rb_circuit_construction(self, depth: int, num_qubits: int, num_circuits: int):
+    def time_rb_circuit_construction(self, depth: int, num_qubits: int, num_circuits: int) -> None:
         qubits = cirq.GridQubit.rect(1, num_qubits)
         for _ in range(num_circuits):
             op_grid = self._get_op_grid(qubits, depth)

benchmarks/serialization.py

@@ -29,7 +29,7 @@ class SerializeLargeExpandedCircuits:
     params = ([100, 500, 1000], [100, 1000, 4000])
     timeout = 600  # Change timeout to 2 minutes instead of default 60 seconds.
 
-    def setup(self, num_qubits: int, num_moments: int):
+    def setup(self, num_qubits: int, num_moments: int) -> None:
         qubits = cirq.LineQubit.range(num_qubits)
         one_q_x_moment = cirq.Moment(cirq.X(q) for q in qubits[::2])
         one_q_y_moment = cirq.Moment(cirq.Y(q) for q in qubits[1::2])
@@ -43,11 +43,11 @@ def setup(self, num_qubits: int, num_moments: int):
             * (num_moments // 5)
         )
 
-    def time_json_serialization(self, *_):
+    def time_json_serialization(self, *_) -> None:
         _ = cirq.to_json(self.circuit)
 
-    def time_json_serialization_gzip(self, *_):
+    def time_json_serialization_gzip(self, *_) -> None:
         _ = cirq.to_json_gzip(self.circuit)
 
-    def track_json_serialization_gzip_size(self, *_):
+    def track_json_serialization_gzip_size(self, *_) -> str:
         return _human_size(len(cirq.to_json_gzip(self.circuit)))

benchmarks/transformers/routing.py

@@ -20,20 +20,20 @@ class RouteCQC:
     param_names = ["qubits", "depth", "op_density", "grid_device_size"]
     timeout = 300  # Increase timeout to 5 minutes instead of default 60 seconds.
 
-    def setup(self, qubits: int, depth: int, op_density: float, grid_device_size: int):
+    def setup(self, qubits: int, depth: int, op_density: float, grid_device_size: int) -> None:
         gate_domain = {cirq.CNOT: 2, cirq.X: 1}
         self.circuit = cirq.testing.random_circuit(
             qubits, depth, op_density, gate_domain=gate_domain, random_state=12345
         )
         self.device = cirq.testing.construct_grid_device(grid_device_size, grid_device_size)
         self.router = cirq.RouteCQC(self.device.metadata.nx_graph)
 
-    def time_circuit_routing(self, *_):
+    def time_circuit_routing(self, *_) -> None:
         self.routed_circuit = self.router(self.circuit)
 
     def track_routed_circuit_depth_ratio(self, *_) -> float:
         self.routed_circuit = self.router(self.circuit)
         return len(self.routed_circuit) / len(self.circuit)
 
-    def teardown(self, *_):
+    def teardown(self, *_) -> None:
         self.device.validate_circuit(self.routed_circuit)

benchmarks/transformers/transformer_primitives.py

@@ -20,7 +20,7 @@ class MapLargeExpandedCircuit:
     params = ([100, 500, 1000], [100, 1000, 4000])
     timeout = 600  # Change timeout to 2 minutes instead of default 60 seconds.
 
-    def setup(self, num_qubits: int, num_moments: int):
+    def setup(self, num_qubits: int, num_moments: int) -> None:
         qubits = cirq.LineQubit.range(num_qubits)
         one_q_x_moment = cirq.Moment(cirq.X(q) for q in qubits[::2])
         one_q_y_moment = cirq.Moment(cirq.Y(q) for q in qubits[1::2])
@@ -32,7 +32,7 @@ def setup(self, num_qubits: int, num_moments: int):
             [one_q_x_moment, two_q_cx_moment, one_q_y_moment, two_q_cz_moment] * (num_moments // 4)
         )
 
-    def time_map_moments(self, num_qubits: int, _):
+    def time_map_moments(self, num_qubits: int, _) -> None:
         all_qubits = cirq.LineQubit.range(num_qubits)
 
         def map_func(m: cirq.Moment, _) -> cirq.Moment:
@@ -46,19 +46,19 @@ def map_func(m: cirq.Moment, _) -> cirq.Moment:
 
         _ = cirq.map_moments(circuit=self.circuit, map_func=map_func)
 
-    def time_map_operations_apply_tag(self, *_):
+    def time_map_operations_apply_tag(self, *_) -> None:
         def map_func(op: cirq.Operation, _) -> cirq.Operation:
             return op.with_tags("old op")
 
         _ = cirq.map_operations(circuit=self.circuit, map_func=map_func)
 
-    def time_map_operations_to_optree(self, *_):
+    def time_map_operations_to_optree(self, *_) -> None:
         def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
             return [op, op]
 
         _ = cirq.map_operations(circuit=self.circuit, map_func=map_func)
 
-    def time_map_operations_to_optree_and_unroll(self, *_):
+    def time_map_operations_to_optree_and_unroll(self, *_) -> None:
         def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
             return [op, op]
 

cirq-aqt/cirq_aqt/aqt_device.py

@@ -189,7 +189,7 @@ def __init__(
         self.noise_dict = noise_dict
         self.simulate_ideal = simulate_ideal
 
-    def generate_circuit_from_list(self, json_string: str):
+    def generate_circuit_from_list(self, json_string: str) -> None:
         """Generates a list of cirq operations from a json string.
 
         The default behavior is to add a measurement to any qubit at the end
@@ -288,11 +288,11 @@ def __init__(
     def metadata(self) -> aqt_device_metadata.AQTDeviceMetadata:
         return self._metadata
 
-    def validate_gate(self, gate: cirq.Gate):
+    def validate_gate(self, gate: cirq.Gate) -> None:
         if gate not in self.metadata.gateset:
             raise ValueError(f'Unsupported gate type: {gate!r}')
 
-    def validate_operation(self, operation):
+    def validate_operation(self, operation) -> None:
         if not isinstance(operation, cirq.GateOperation):
             raise ValueError(f'Unsupported operation: {operation!r}')
 
@@ -304,7 +304,7 @@ def validate_operation(self, operation):
             if q not in self.qubits:
                 raise ValueError(f'Qubit not on device: {q!r}')
 
-    def validate_circuit(self, circuit: cirq.AbstractCircuit):
+    def validate_circuit(self, circuit: cirq.AbstractCircuit) -> None:
         super().validate_circuit(circuit)
         _verify_unique_measurement_keys(circuit.all_operations())
 

cirq-aqt/cirq_aqt/aqt_device_metadata_test.py

@@ -38,7 +38,7 @@ def metadata(qubits) -> AQTDeviceMetadata:
     )
 
 
-def test_aqtdevice_metadata(metadata, qubits):
+def test_aqtdevice_metadata(metadata, qubits) -> None:
     assert metadata.qubit_set == frozenset(qubits)
     assert set(qubits) == set(metadata.nx_graph.nodes())
     edges = metadata.nx_graph.edges()
@@ -48,7 +48,7 @@ def test_aqtdevice_metadata(metadata, qubits):
     assert len(metadata.gate_durations) == 4
 
 
-def test_aqtdevice_duration_of(metadata, qubits):
+def test_aqtdevice_duration_of(metadata, qubits) -> None:
     q0, q1 = qubits[:2]
     ms = cirq.Duration(millis=1)
     assert metadata.duration_of(cirq.Z(q0)) == 10 * ms
@@ -59,5 +59,5 @@ def test_aqtdevice_duration_of(metadata, qubits):
         metadata.duration_of(cirq.I(q0))
 
 
-def test_repr(metadata):
+def test_repr(metadata) -> None:
     cirq.testing.assert_equivalent_repr(metadata, setup_code='import cirq\nimport cirq_aqt\n')

cirq-aqt/cirq_aqt/aqt_device_test.py

@@ -43,24 +43,24 @@ def with_qubits(self, *new_qubits) -> NotImplementedOperation:
         raise NotImplementedError()
 
     @property
-    def qubits(self):
+    def qubits(self) -> tuple[cirq.Qid, ...]:
         raise NotImplementedError()
 
 
-def test_init_qubits(device, qubits):
+def test_init_qubits(device, qubits) -> None:
     ms = cirq.Duration(millis=1)
     assert device.qubits == frozenset(qubits)
     with pytest.raises(TypeError, match="NamedQubit"):
         aqt_device.AQTDevice(
             measurement_duration=100 * ms,
             twoq_gates_duration=200 * ms,
             oneq_gates_duration=10 * ms,
-            qubits=[cirq.LineQubit(0), cirq.NamedQubit("a")],
+            qubits=[cirq.LineQubit(0), cirq.NamedQubit("a")],  # type: ignore[list-item]
         )
 
 
 @pytest.mark.parametrize('ms', [cirq.Duration(millis=1), timedelta(milliseconds=1)])
-def test_init_durations(ms, qubits):
+def test_init_durations(ms, qubits) -> None:
     dev = aqt_device.AQTDevice(
         qubits=qubits,
         measurement_duration=100 * ms,
@@ -72,12 +72,12 @@ def test_init_durations(ms, qubits):
     assert dev.metadata.measurement_duration == cirq.Duration(millis=100)
 
 
-def test_metadata(device, qubits):
+def test_metadata(device, qubits) -> None:
     assert isinstance(device.metadata, aqt_device_metadata.AQTDeviceMetadata)
     assert device.metadata.qubit_set == frozenset(qubits)
 
 
-def test_repr(device):
+def test_repr(device) -> None:
     assert repr(device) == (
         "cirq_aqt.aqt_device.AQTDevice("
         "measurement_duration=cirq.Duration(millis=100), "
@@ -89,13 +89,13 @@ def test_repr(device):
     cirq.testing.assert_equivalent_repr(device, setup_code='import cirq\nimport cirq_aqt\n')
 
 
-def test_validate_measurement_non_adjacent_qubits_ok(device):
+def test_validate_measurement_non_adjacent_qubits_ok(device) -> None:
     device.validate_operation(
         cirq.GateOperation(cirq.MeasurementGate(2, 'key'), (cirq.LineQubit(0), cirq.LineQubit(1)))
     )
 
 
-def test_validate_operation_existing_qubits(device):
+def test_validate_operation_existing_qubits(device) -> None:
     device.validate_operation(cirq.GateOperation(cirq.XX, (cirq.LineQubit(0), cirq.LineQubit(1))))
     device.validate_operation(cirq.Z(cirq.LineQubit(0)))
     device.validate_operation(
@@ -114,7 +114,7 @@ def test_validate_operation_existing_qubits(device):
         device.validate_operation(cirq.X(cirq.NamedQubit("q1")))
 
 
-def test_validate_operation_supported_gate(device):
+def test_validate_operation_supported_gate(device) -> None:
     class MyGate(cirq.Gate):
         def num_qubits(self):
             return 1
@@ -128,12 +128,12 @@ def num_qubits(self):
         device.validate_operation(NotImplementedOperation())
 
 
-def test_aqt_device_eq(device):
+def test_aqt_device_eq(device) -> None:
     eq = cirq.testing.EqualsTester()
     eq.make_equality_group(lambda: device)
 
 
-def test_validate_circuit_repeat_measurement_keys(device):
+def test_validate_circuit_repeat_measurement_keys(device) -> None:
     circuit = cirq.Circuit()
     circuit.append(
         [cirq.measure(cirq.LineQubit(0), key='a'), cirq.measure(cirq.LineQubit(1), key='a')]
@@ -143,16 +143,16 @@ def test_validate_circuit_repeat_measurement_keys(device):
         device.validate_circuit(circuit)
 
 
-def test_aqt_device_str(device):
+def test_aqt_device_str(device) -> None:
     assert str(device) == "q(0)───q(1)───q(2)"
 
 
-def test_aqt_device_pretty_repr(device):
+def test_aqt_device_pretty_repr(device) -> None:
     cirq.testing.assert_repr_pretty(device, "q(0)───q(1)───q(2)")
     cirq.testing.assert_repr_pretty(device, "AQTDevice(...)", cycle=True)
 
 
-def test_at(device):
+def test_at(device) -> None:
     assert device.at(-1) is None
     assert device.at(0) == cirq.LineQubit(0)
     assert device.at(2) == cirq.LineQubit(2)