From e7ef9d4aea2fe6270c3d85e292106a9c38fbec7f Mon Sep 17 00:00:00 2001 From: Matthew Neeley Date: Wed, 12 Apr 2023 21:42:19 -0700 Subject: [PATCH] Update to mypy 1.2 (#6059) Review: @viathor --- cirq-core/cirq/_compat_test.py | 6 +- cirq-core/cirq/circuits/circuit.py | 16 ++- .../cirq/circuits/circuit_operation_test.py | 8 +- .../cirq/circuits/text_diagram_drawer.py | 2 +- .../cirq/contrib/acquaintance/executor.py | 5 +- .../cirq/contrib/acquaintance/permutation.py | 15 ++- cirq-core/cirq/contrib/qasm_import/_parser.py | 2 +- .../contrib/quantum_volume/quantum_volume.py | 6 +- cirq-core/cirq/contrib/quimb/mps_simulator.py | 2 +- cirq-core/cirq/contrib/svg/svg_test.py | 2 +- cirq-core/cirq/devices/grid_qubit.py | 2 +- cirq-core/cirq/devices/line_qubit.py | 2 +- cirq-core/cirq/devices/named_topologies.py | 2 +- cirq-core/cirq/devices/noise_model.py | 3 + ...superconducting_qubits_noise_properties.py | 4 +- .../cirq/experiments/n_qubit_tomography.py | 2 +- .../experiments/qubit_characterizations.py | 4 +- .../single_qubit_readout_calibration.py | 2 +- .../cirq/experiments/t2_decay_experiment.py | 2 +- cirq-core/cirq/interop/quirk/cells/testing.py | 2 +- cirq-core/cirq/linalg/transformations.py | 2 +- cirq-core/cirq/ops/clifford_gate.py | 6 - cirq-core/cirq/ops/common_gates.py | 8 +- cirq-core/cirq/ops/controlled_gate.py | 27 +++-- cirq-core/cirq/ops/matrix_gates.py | 2 +- cirq-core/cirq/ops/measurement_gate.py | 2 +- cirq-core/cirq/ops/named_qubit.py | 2 +- cirq-core/cirq/ops/pauli_string.py | 6 +- cirq-core/cirq/ops/raw_types.py | 5 +- cirq-core/cirq/ops/three_qubit_gates.py | 6 +- cirq-core/cirq/ops/wait_gate.py | 2 +- cirq-core/cirq/protocols/act_on_protocol.py | 4 +- .../cirq/protocols/act_on_protocol_test.py | 8 +- .../protocols/apply_mixture_protocol_test.py | 2 +- .../cirq/protocols/json_serialization_test.py | 2 +- .../protocols/measurement_key_protocol.py | 4 +- cirq-core/cirq/protocols/qasm.py | 4 +- cirq-core/cirq/qis/channels.py | 2 +- cirq-core/cirq/sim/simulation_state_base.py | 3 + cirq-core/cirq/sim/simulator.py | 1 + cirq-core/cirq/sim/sparse_simulator_test.py | 6 +- cirq-core/cirq/sim/state_vector.py | 2 +- cirq-core/cirq/study/flatten_expressions.py | 2 +- cirq-core/cirq/study/sweeps.py | 2 +- .../consistent_controlled_gate_op_test.py | 2 +- cirq-core/cirq/testing/json.py | 6 +- cirq-core/cirq/testing/random_circuit.py | 8 +- .../two_qubit_to_fsim.py | 2 +- .../transformers/measurement_transformers.py | 8 +- cirq-core/cirq/transformers/stratify.py | 1 + .../cirq/transformers/transformer_api.py | 2 +- cirq-core/cirq/value/abc_alt_test.py | 1 + cirq-core/cirq/value/classical_data.py | 12 +- cirq-core/cirq/value/linear_dict.py | 6 +- cirq-core/cirq/value/product_state.py | 6 +- cirq-core/cirq/value/value_equality_attr.py | 4 +- .../cirq/work/observable_measurement_data.py | 10 +- .../work/observable_readout_calibration.py | 4 +- cirq-core/cirq/work/sampler.py | 2 + cirq-core/cirq/work/zeros_sampler.py | 4 +- cirq-core/requirements.txt | 4 +- cirq-google/cirq_google/api/v2/results.py | 4 +- .../cirq_google/calibration/phased_fsim.py | 6 +- .../quantum_engine_service/async_client.py | 114 +++++++++--------- .../services/quantum_engine_service/client.py | 114 +++++++++--------- .../quantum_engine_service/transports/grpc.py | 20 +-- .../transports/grpc_asyncio.py | 10 +- .../cirq_google/engine/abstract_job_test.py | 23 ++-- .../cirq_google/engine/abstract_processor.py | 10 +- cirq-google/cirq_google/engine/engine.py | 4 +- .../cirq_google/engine/engine_processor.py | 8 +- .../cirq_google/engine/engine_program.py | 2 +- .../cirq_google/engine/simulated_local_job.py | 4 +- .../engine/simulated_local_processor.py | 12 +- .../engine/virtual_engine_factory.py | 2 +- .../experimental/noise_models/noise_models.py | 8 +- .../cirq_google/line/placement/anneal.py | 11 +- .../line/placement/optimization.py | 4 +- .../serialization/circuit_serializer.py | 4 +- .../serialization/op_deserializer.py | 13 +- .../serialization/op_deserializer_test.py | 10 -- .../serialization/op_serializer.py | 14 +-- .../serialization/op_serializer_test.py | 9 -- .../cirq_google/serialization/serializer.py | 1 + cirq-google/cirq_google/workflow/io_test.py | 2 +- .../workflow/quantum_runtime_test.py | 4 +- .../cirq_google/workflow/qubit_placement.py | 2 +- cirq-ionq/cirq_ionq/ionq_client.py | 4 +- cirq-ionq/cirq_ionq/ionq_exceptions.py | 4 +- cirq-ionq/cirq_ionq/results.py | 2 +- cirq-ionq/cirq_ionq/service.py | 6 +- cirq-pasqal/cirq_pasqal/pasqal_sampler.py | 7 +- cirq-rigetti/cirq_rigetti/conftest.py | 2 +- .../cirq_web/bloch_sphere/bloch_sphere.py | 7 +- dev_tools/env_tools.py | 2 +- dev_tools/modules_test.py | 4 +- dev_tools/pr_monitor.py | 2 +- dev_tools/requirements/deps/mypy.txt | 2 +- dev_tools/snippets_test.py | 8 +- 99 files changed, 386 insertions(+), 360 deletions(-) diff --git a/cirq-core/cirq/_compat_test.py b/cirq-core/cirq/_compat_test.py index b12934d06d8..3c6e8fd273d 100644 --- a/cirq-core/cirq/_compat_test.py +++ b/cirq-core/cirq/_compat_test.py @@ -98,7 +98,7 @@ def test_proper_repr_data_frame(): pd.testing.assert_frame_equal(df2, df) -def test_dataclass_repr_simple(): +def test_dataclass_repr_simple() -> None: @dataclasses.dataclass class TestClass1: x: int @@ -111,7 +111,7 @@ def __repr__(self): assert repr(TestClass1(5, 'hi')) == "cirq.TestClass1(x=5, y='hi')" -def test_dataclass_repr_numpy(): +def test_dataclass_repr_numpy() -> None: @dataclasses.dataclass class TestClass2: x: np.ndarray @@ -1003,7 +1003,7 @@ def bar(self): class Bar: - def __init__(self): + def __init__(self) -> None: self.foo_calls: Dict[int, int] = collections.Counter() self.bar_calls: Dict[int, int] = collections.Counter() diff --git a/cirq-core/cirq/circuits/circuit.py b/cirq-core/cirq/circuits/circuit.py index 21b5a7abf1f..bd81e60d26d 100644 --- a/cirq-core/cirq/circuits/circuit.py +++ b/cirq-core/cirq/circuits/circuit.py @@ -305,7 +305,10 @@ def _first_moment_operating_on( return None def next_moment_operating_on( - self, qubits: Iterable['cirq.Qid'], start_moment_index: int = 0, max_distance: int = None + self, + qubits: Iterable['cirq.Qid'], + start_moment_index: int = 0, + max_distance: Optional[int] = None, ) -> Optional[int]: """Finds the index of the next moment that touches the given qubits. @@ -2128,7 +2131,7 @@ def _push_frontier( self, early_frontier: Dict['cirq.Qid', int], late_frontier: Dict['cirq.Qid', int], - update_qubits: Iterable['cirq.Qid'] = None, + update_qubits: Optional[Iterable['cirq.Qid']] = None, ) -> Tuple[int, int]: """Inserts moments to separate two frontiers. @@ -2198,7 +2201,10 @@ def _insert_operations( ) def insert_at_frontier( - self, operations: 'cirq.OP_TREE', start: int, frontier: Dict['cirq.Qid', int] = None + self, + operations: 'cirq.OP_TREE', + start: int, + frontier: Optional[Dict['cirq.Qid', int]] = None, ) -> Dict['cirq.Qid', int]: """Inserts operations inline at frontier. @@ -2389,7 +2395,9 @@ def with_noise(self, noise: 'cirq.NOISE_MODEL_LIKE') -> 'cirq.Circuit': def _pick_inserted_ops_moment_indices( - operations: Sequence['cirq.Operation'], start: int = 0, frontier: Dict['cirq.Qid', int] = None + operations: Sequence['cirq.Operation'], + start: int = 0, + frontier: Optional[Dict['cirq.Qid', int]] = None, ) -> Tuple[Sequence[int], Dict['cirq.Qid', int]]: """Greedily assigns operations to moments. diff --git a/cirq-core/cirq/circuits/circuit_operation_test.py b/cirq-core/cirq/circuits/circuit_operation_test.py index e1710546e98..28e0c2fdd4f 100644 --- a/cirq-core/cirq/circuits/circuit_operation_test.py +++ b/cirq-core/cirq/circuits/circuit_operation_test.py @@ -274,7 +274,7 @@ def test_recursive_params(): @pytest.mark.parametrize('add_measurements', [True, False]) @pytest.mark.parametrize('use_default_ids_for_initial_rep', [True, False]) -def test_repeat(add_measurements, use_default_ids_for_initial_rep): +def test_repeat(add_measurements: bool, use_default_ids_for_initial_rep: bool) -> None: a, b = cirq.LineQubit.range(2) circuit = cirq.Circuit(cirq.H(a), cirq.CX(a, b)) if add_measurements: @@ -327,9 +327,9 @@ def test_repeat(add_measurements, use_default_ids_for_initial_rep): _ = op_base.repeat() with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'): - _ = op_base.repeat(1.3) - assert op_base.repeat(3.00000000001).repetitions == 3 - assert op_base.repeat(2.99999999999).repetitions == 3 + _ = op_base.repeat(1.3) # type: ignore[arg-type] + assert op_base.repeat(3.00000000001).repetitions == 3 # type: ignore[arg-type] + assert op_base.repeat(2.99999999999).repetitions == 3 # type: ignore[arg-type] @pytest.mark.parametrize('add_measurements', [True, False]) diff --git a/cirq-core/cirq/circuits/text_diagram_drawer.py b/cirq-core/cirq/circuits/text_diagram_drawer.py index f3ab40cdffd..7f5bca60e9e 100644 --- a/cirq-core/cirq/circuits/text_diagram_drawer.py +++ b/cirq-core/cirq/circuits/text_diagram_drawer.py @@ -292,7 +292,7 @@ def render( self, horizontal_spacing: int = 1, vertical_spacing: int = 1, - crossing_char: str = None, + crossing_char: Optional[str] = None, use_unicode_characters: bool = True, ) -> str: """Outputs text containing the diagram.""" diff --git a/cirq-core/cirq/contrib/acquaintance/executor.py b/cirq-core/cirq/contrib/acquaintance/executor.py index 2e5a0070762..b618135284b 100644 --- a/cirq-core/cirq/contrib/acquaintance/executor.py +++ b/cirq-core/cirq/contrib/acquaintance/executor.py @@ -174,7 +174,10 @@ class GreedyExecutionStrategy(ExecutionStrategy): """ def __init__( - self, gates: LogicalGates, initial_mapping: LogicalMapping, device: 'cirq.Device' = None + self, + gates: LogicalGates, + initial_mapping: LogicalMapping, + device: Optional['cirq.Device'] = None, ) -> None: """Inits GreedyExecutionStrategy. diff --git a/cirq-core/cirq/contrib/acquaintance/permutation.py b/cirq-core/cirq/contrib/acquaintance/permutation.py index 073b7a60d02..b4457a55d12 100644 --- a/cirq-core/cirq/contrib/acquaintance/permutation.py +++ b/cirq-core/cirq/contrib/acquaintance/permutation.py @@ -13,7 +13,18 @@ # limitations under the License. import abc -from typing import Any, cast, Dict, Iterable, Sequence, Tuple, TypeVar, Union, TYPE_CHECKING +from typing import ( + Any, + cast, + Dict, + Iterable, + Optional, + Sequence, + Tuple, + TypeVar, + Union, + TYPE_CHECKING, +) from cirq import circuits, ops, protocols, transformers, value from cirq.type_workarounds import NotImplementedType @@ -72,7 +83,7 @@ def update_mapping( mapping[new_key] = old_element @staticmethod - def validate_permutation(permutation: Dict[int, int], n_elements: int = None) -> None: + def validate_permutation(permutation: Dict[int, int], n_elements: Optional[int] = None) -> None: if not permutation: return if set(permutation.values()) != set(permutation): diff --git a/cirq-core/cirq/contrib/qasm_import/_parser.py b/cirq-core/cirq/contrib/qasm_import/_parser.py index 3c9ab94f2df..3e54558bc4a 100644 --- a/cirq-core/cirq/contrib/qasm_import/_parser.py +++ b/cirq-core/cirq/contrib/qasm_import/_parser.py @@ -141,7 +141,7 @@ class QasmParser: parsedQasm = QasmParser().parse(qasm) """ - def __init__(self): + def __init__(self) -> None: self.parser = yacc.yacc(module=self, debug=False, write_tables=False) self.circuit = Circuit() self.qregs: Dict[str, int] = {} diff --git a/cirq-core/cirq/contrib/quantum_volume/quantum_volume.py b/cirq-core/cirq/contrib/quantum_volume/quantum_volume.py index 83497425b38..4db5d4b0d91 100644 --- a/cirq-core/cirq/contrib/quantum_volume/quantum_volume.py +++ b/cirq-core/cirq/contrib/quantum_volume/quantum_volume.py @@ -200,7 +200,7 @@ def compile_circuit( *, device_graph: nx.Graph, routing_attempts: int, - compiler: Callable[[cirq.Circuit], cirq.Circuit] = None, + compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None, routing_algo_name: Optional[str] = None, router: Optional[Callable[..., ccr.SwapNetwork]] = None, add_readout_error_correction=False, @@ -357,7 +357,7 @@ def execute_circuits( samplers: List[cirq.Sampler], circuits: List[Tuple[cirq.Circuit, List[int]]], routing_attempts: int, - compiler: Callable[[cirq.Circuit], cirq.Circuit] = None, + compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None, repetitions: int = 10_000, add_readout_error_correction=False, ) -> List[QuantumVolumeResult]: @@ -429,7 +429,7 @@ def calculate_quantum_volume( device_graph: nx.Graph, samplers: List[cirq.Sampler], random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None, - compiler: Callable[[cirq.Circuit], cirq.Circuit] = None, + compiler: Optional[Callable[[cirq.Circuit], cirq.Circuit]] = None, repetitions=10_000, routing_attempts=30, add_readout_error_correction=False, diff --git a/cirq-core/cirq/contrib/quimb/mps_simulator.py b/cirq-core/cirq/contrib/quimb/mps_simulator.py index cc8bf388d8d..4b94bf32976 100644 --- a/cirq-core/cirq/contrib/quimb/mps_simulator.py +++ b/cirq-core/cirq/contrib/quimb/mps_simulator.py @@ -569,7 +569,7 @@ def __init__( simulation_options: MPSOptions = MPSOptions(), grouping: Optional[Dict['cirq.Qid', int]] = None, initial_state: int = 0, - classical_data: 'cirq.ClassicalDataStore' = None, + classical_data: Optional['cirq.ClassicalDataStore'] = None, ): """Creates and MPSState diff --git a/cirq-core/cirq/contrib/svg/svg_test.py b/cirq-core/cirq/contrib/svg/svg_test.py index ea02b6bae0a..0a94ea1e983 100644 --- a/cirq-core/cirq/contrib/svg/svg_test.py +++ b/cirq-core/cirq/contrib/svg/svg_test.py @@ -1,5 +1,5 @@ # pylint: disable=wrong-or-nonexistent-copyright-notice -import IPython.display # type: ignore +import IPython.display # type: ignore[import] import numpy as np import pytest diff --git a/cirq-core/cirq/devices/grid_qubit.py b/cirq-core/cirq/devices/grid_qubit.py index 89bfce0d273..87ceda7a956 100644 --- a/cirq-core/cirq/devices/grid_qubit.py +++ b/cirq-core/cirq/devices/grid_qubit.py @@ -27,7 +27,7 @@ TSelf = TypeVar('TSelf', bound='_BaseGridQid') -@functools.total_ordering # type: ignore +@functools.total_ordering class _BaseGridQid(ops.Qid): """The Base class for `GridQid` and `GridQubit`.""" diff --git a/cirq-core/cirq/devices/line_qubit.py b/cirq-core/cirq/devices/line_qubit.py index 6f685fe7778..f53ec69e595 100644 --- a/cirq-core/cirq/devices/line_qubit.py +++ b/cirq-core/cirq/devices/line_qubit.py @@ -25,7 +25,7 @@ TSelf = TypeVar('TSelf', bound='_BaseLineQid') -@functools.total_ordering # type: ignore +@functools.total_ordering class _BaseLineQid(ops.Qid): """The base class for `LineQid` and `LineQubit`.""" diff --git a/cirq-core/cirq/devices/named_topologies.py b/cirq-core/cirq/devices/named_topologies.py index 68384e1bc02..abc81253031 100644 --- a/cirq-core/cirq/devices/named_topologies.py +++ b/cirq-core/cirq/devices/named_topologies.py @@ -345,7 +345,7 @@ def draw_placements( small_graph: nx.Graph, small_to_big_mappings: Sequence[Dict], max_plots: int = 20, - axes: Sequence[plt.Axes] = None, + axes: Optional[Sequence[plt.Axes]] = None, tilted: bool = True, bad_placement_callback: Optional[Callable[[plt.Axes, int], None]] = None, ): diff --git a/cirq-core/cirq/devices/noise_model.py b/cirq-core/cirq/devices/noise_model.py index e8c6d049362..8395d9e1f1e 100644 --- a/cirq-core/cirq/devices/noise_model.py +++ b/cirq-core/cirq/devices/noise_model.py @@ -125,6 +125,7 @@ def noisy_moments( A sequence of OP_TREEs, with the k'th tree corresponding to the noisy operations for the k'th moment. """ + raise NotImplementedError def _noisy_moment_impl_moments( self, moment: 'cirq.Moment', system_qubits: Sequence['cirq.Qid'] @@ -150,6 +151,7 @@ def noisy_moment( Returns: An OP_TREE corresponding to the noisy operations for the moment. """ + raise NotImplementedError def _noisy_operation_impl_moments(self, operation: 'cirq.Operation') -> 'cirq.OP_TREE': return self.noisy_moments([moment_module.Moment([operation])], operation.qubits) @@ -169,6 +171,7 @@ def noisy_operation(self, operation: 'cirq.Operation') -> 'cirq.OP_TREE': An OP_TREE corresponding to the noisy operations implementing the noisy version of the given operation. """ + raise NotImplementedError @value.value_equality diff --git a/cirq-core/cirq/devices/superconducting_qubits_noise_properties.py b/cirq-core/cirq/devices/superconducting_qubits_noise_properties.py index 64e307d4623..13310e20ef4 100644 --- a/cirq-core/cirq/devices/superconducting_qubits_noise_properties.py +++ b/cirq-core/cirq/devices/superconducting_qubits_noise_properties.py @@ -27,9 +27,7 @@ # TODO: missing per-device defaults -# Type-ignored because mypy cannot handle abstract dataclasses: -# https://github.com/python/mypy/issues/5374 -@dataclass # type: ignore +@dataclass class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC): """Noise-defining properties for a superconducting-qubit-based device. diff --git a/cirq-core/cirq/experiments/n_qubit_tomography.py b/cirq-core/cirq/experiments/n_qubit_tomography.py index a2c558601cf..beae97de6ff 100644 --- a/cirq-core/cirq/experiments/n_qubit_tomography.py +++ b/cirq-core/cirq/experiments/n_qubit_tomography.py @@ -134,7 +134,7 @@ def state_tomography( qubits: Sequence['cirq.Qid'], circuit: 'cirq.Circuit', repetitions: int = 1000, - prerotations: Sequence[Tuple[float, float]] = None, + prerotations: Optional[Sequence[Tuple[float, float]]] = None, ) -> TomographyResult: """This performs n qubit tomography on a cirq circuit diff --git a/cirq-core/cirq/experiments/qubit_characterizations.py b/cirq-core/cirq/experiments/qubit_characterizations.py index 91f9d8426a9..114e2e28659 100644 --- a/cirq-core/cirq/experiments/qubit_characterizations.py +++ b/cirq-core/cirq/experiments/qubit_characterizations.py @@ -542,8 +542,8 @@ def _matrix_bar_plot( mat: np.ndarray, z_label: str, ax: plt.Axes, - kets: Sequence[str] = None, - title: str = None, + kets: Optional[Sequence[str]] = None, + title: Optional[str] = None, ylim: Tuple[int, int] = (-1, 1), **bar3d_kwargs: Any, ) -> None: diff --git a/cirq-core/cirq/experiments/single_qubit_readout_calibration.py b/cirq-core/cirq/experiments/single_qubit_readout_calibration.py index decb3659dae..0e60653ba15 100644 --- a/cirq-core/cirq/experiments/single_qubit_readout_calibration.py +++ b/cirq-core/cirq/experiments/single_qubit_readout_calibration.py @@ -111,7 +111,7 @@ def estimate_parallel_single_qubit_readout_errors( trials: int = 20, repetitions: int = 1000, trials_per_batch: Optional[int] = None, - bit_strings: np.ndarray = None, + bit_strings: Optional[np.ndarray] = None, ) -> SingleQubitReadoutCalibrationResult: """Estimate single qubit readout error using parallel operations. diff --git a/cirq-core/cirq/experiments/t2_decay_experiment.py b/cirq-core/cirq/experiments/t2_decay_experiment.py index 49e57775bc0..d1a065c2927 100644 --- a/cirq-core/cirq/experiments/t2_decay_experiment.py +++ b/cirq-core/cirq/experiments/t2_decay_experiment.py @@ -45,7 +45,7 @@ def t2_decay( min_delay: 'cirq.DURATION_LIKE' = None, repetitions: int = 1000, delay_sweep: Optional[study.Sweep] = None, - num_pulses: List[int] = None, + num_pulses: Optional[List[int]] = None, ) -> Union['cirq.experiments.T2DecayResult', List['cirq.experiments.T2DecayResult']]: """Runs a t2 transverse relaxation experiment. diff --git a/cirq-core/cirq/interop/quirk/cells/testing.py b/cirq-core/cirq/interop/quirk/cells/testing.py index e9dad1e6b4f..5e11a121732 100644 --- a/cirq-core/cirq/interop/quirk/cells/testing.py +++ b/cirq-core/cirq/interop/quirk/cells/testing.py @@ -22,7 +22,7 @@ def assert_url_to_circuit_returns( json_text: str, - circuit: 'cirq.Circuit' = None, + circuit: Optional['cirq.Circuit'] = None, *, unitary: Optional[np.ndarray] = None, diagram: Optional[str] = None, diff --git a/cirq-core/cirq/linalg/transformations.py b/cirq-core/cirq/linalg/transformations.py index 8cb1f05c446..6a04ce1dda0 100644 --- a/cirq-core/cirq/linalg/transformations.py +++ b/cirq-core/cirq/linalg/transformations.py @@ -249,7 +249,7 @@ def targeted_conjugate_about( tensor: np.ndarray, target: np.ndarray, indices: Sequence[int], - conj_indices: Sequence[int] = None, + conj_indices: Optional[Sequence[int]] = None, buffer: Optional[np.ndarray] = None, out: Optional[np.ndarray] = None, ) -> np.ndarray: diff --git a/cirq-core/cirq/ops/clifford_gate.py b/cirq-core/cirq/ops/clifford_gate.py index 24176f82d08..ab014808c7a 100644 --- a/cirq-core/cirq/ops/clifford_gate.py +++ b/cirq-core/cirq/ops/clifford_gate.py @@ -75,12 +75,6 @@ def _to_clifford_tableau( return clifford_tableau -def _pretend_initialized() -> 'SingleQubitCliffordGate': - # HACK: This is a workaround to fool mypy and pylint into correctly handling - # class fields that can't be initialized until after the class is defined. - pass - - def _validate_map_input( required_transform_count: int, pauli_map_to: Optional[Dict[Pauli, Tuple[Pauli, bool]]], diff --git a/cirq-core/cirq/ops/common_gates.py b/cirq-core/cirq/ops/common_gates.py index 00b89597980..01965cc3281 100644 --- a/cirq-core/cirq/ops/common_gates.py +++ b/cirq-core/cirq/ops/common_gates.py @@ -187,7 +187,7 @@ def _trace_distance_bound_(self) -> Optional[float]: def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, @@ -667,7 +667,7 @@ def with_canonical_global_phase(self) -> 'ZPowGate': def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, @@ -1122,7 +1122,7 @@ def _phase_by_(self, phase_turns, qubit_index): def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, @@ -1328,7 +1328,7 @@ def _pauli_expansion_(self) -> value.LinearDict[str]: def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, diff --git a/cirq-core/cirq/ops/controlled_gate.py b/cirq-core/cirq/ops/controlled_gate.py index 72719510c8e..ce97f3899e8 100644 --- a/cirq-core/cirq/ops/controlled_gate.py +++ b/cirq-core/cirq/ops/controlled_gate.py @@ -51,7 +51,7 @@ class ControlledGate(raw_types.Gate): def __init__( self, sub_gate: 'cirq.Gate', - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, @@ -143,7 +143,9 @@ def num_controls(self) -> int: def _qid_shape_(self) -> Tuple[int, ...]: return self.control_qid_shape + protocols.qid_shape(self.sub_gate) - def _decompose_(self, qubits): + def _decompose_( + self, qubits: Tuple['cirq.Qid', ...] + ) -> Union[None, NotImplementedType, 'cirq.OP_TREE']: if ( protocols.has_unitary(self.sub_gate) and protocols.num_qubits(self.sub_gate) == 1 @@ -166,15 +168,22 @@ def _decompose_(self, qubits): z_sub_gate = common_gates.ZPowGate( exponent=self.sub_gate.exponent, global_shift=self.sub_gate.global_shift ) - kwargs = { - 'num_controls': self.num_controls() + 1, - 'control_values': self.control_values & cv.ProductOfSums(((1,),)), - 'control_qid_shape': self.control_qid_shape + (2,), - } + num_controls = self.num_controls() + 1 + control_values = self.control_values & cv.ProductOfSums(((1,),)) + control_qid_shape = self.control_qid_shape + (2,) controlled_z = ( - z_sub_gate.controlled(**kwargs) + z_sub_gate.controlled( + num_controls=num_controls, + control_values=control_values, + control_qid_shape=control_qid_shape, + ) if protocols.is_parameterized(self) - else ControlledGate(z_sub_gate, **kwargs) + else ControlledGate( + z_sub_gate, + num_controls=num_controls, + control_values=control_values, + control_qid_shape=control_qid_shape, + ) ) if self != controlled_z: return protocols.decompose_once_with_qubits(controlled_z, qubits, NotImplemented) diff --git a/cirq-core/cirq/ops/matrix_gates.py b/cirq-core/cirq/ops/matrix_gates.py index 0f7c7232c54..bb2315bc38e 100644 --- a/cirq-core/cirq/ops/matrix_gates.py +++ b/cirq-core/cirq/ops/matrix_gates.py @@ -53,7 +53,7 @@ def __init__( self, matrix: np.ndarray, *, - name: str = None, + name: Optional[str] = None, qid_shape: Optional[Iterable[int]] = None, unitary_check: bool = True, unitary_check_rtol: float = 1e-5, diff --git a/cirq-core/cirq/ops/measurement_gate.py b/cirq-core/cirq/ops/measurement_gate.py index 40b3b2732f4..6fa235a6cc8 100644 --- a/cirq-core/cirq/ops/measurement_gate.py +++ b/cirq-core/cirq/ops/measurement_gate.py @@ -50,7 +50,7 @@ def __init__( num_qubits: Optional[int] = None, key: Union[str, 'cirq.MeasurementKey'] = '', invert_mask: Tuple[bool, ...] = (), - qid_shape: Tuple[int, ...] = None, + qid_shape: Optional[Tuple[int, ...]] = None, confusion_map: Optional[Dict[Tuple[int, ...], np.ndarray]] = None, ) -> None: """Inits MeasurementGate. diff --git a/cirq-core/cirq/ops/named_qubit.py b/cirq-core/cirq/ops/named_qubit.py index 9353fd73c25..e5f622a03c6 100644 --- a/cirq-core/cirq/ops/named_qubit.py +++ b/cirq-core/cirq/ops/named_qubit.py @@ -24,7 +24,7 @@ TSelf = TypeVar('TSelf', bound='_BaseNamedQid') -@functools.total_ordering # type: ignore +@functools.total_ordering class _BaseNamedQid(raw_types.Qid): """The base class for `NamedQid` and `NamedQubit`.""" diff --git a/cirq-core/cirq/ops/pauli_string.py b/cirq-core/cirq/ops/pauli_string.py index 1ba59ad76b5..de90b0fe327 100644 --- a/cirq-core/cirq/ops/pauli_string.py +++ b/cirq-core/cirq/ops/pauli_string.py @@ -242,12 +242,14 @@ def get(self, key: Any, default: None = None) -> Optional[pauli_gates.Pauli]: def get(self, key: Any, default: TDefault) -> Union[pauli_gates.Pauli, TDefault]: pass - def get(self, key: Any, default: TDefault = None) -> Union[pauli_gates.Pauli, TDefault, None]: + def get( + self, key: Any, default: Optional[TDefault] = None + ) -> Union[pauli_gates.Pauli, TDefault, None]: """Returns the `cirq.Pauli` operation acting on qubit `key` or `default` if none exists.""" return self._qubit_pauli_map.get(key, default) @overload - def __mul__( # type: ignore + def __mul__( self, other: 'cirq.PauliString[TKeyOther]' ) -> 'cirq.PauliString[Union[TKey, TKeyOther]]': pass diff --git a/cirq-core/cirq/ops/raw_types.py b/cirq-core/cirq/ops/raw_types.py index 0976e042b63..e04f9335840 100644 --- a/cirq-core/cirq/ops/raw_types.py +++ b/cirq-core/cirq/ops/raw_types.py @@ -376,7 +376,7 @@ def with_probability(self, probability: 'cirq.TParamVal') -> 'cirq.Gate': def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, @@ -424,6 +424,7 @@ def _has_stabilizer_effect_(self) -> Optional[bool]: @value.alternative(requires='_num_qubits_', implementation=_backwards_compatibility_num_qubits) def num_qubits(self) -> int: """The number of qubits this gate acts on.""" + raise NotImplementedError def _num_qubits_from_shape(self) -> int: shape = self._qid_shape_() @@ -438,6 +439,7 @@ def _num_qubits_proto_from_num_qubits(self) -> int: @value.alternative(requires='_qid_shape_', implementation=_num_qubits_from_shape) def _num_qubits_(self) -> int: """The number of qubits this gate acts on.""" + raise NotImplementedError def _default_shape_from_num_qubits(self) -> Tuple[int, ...]: num_qubits = self._num_qubits_() @@ -451,6 +453,7 @@ def _qid_shape_(self) -> Tuple[int, ...]: the gate acts on. E.g. (2, 2, 2) for the three-qubit CCZ gate and (3, 3) for a 2-qutrit ternary gate. """ + raise NotImplementedError def _commutes_on_qids_( self, qids: 'Sequence[cirq.Qid]', other: Any, *, atol: float = 1e-8 diff --git a/cirq-core/cirq/ops/three_qubit_gates.py b/cirq-core/cirq/ops/three_qubit_gates.py index 2359b46bbb4..521233dd2cf 100644 --- a/cirq-core/cirq/ops/three_qubit_gates.py +++ b/cirq-core/cirq/ops/three_qubit_gates.py @@ -190,7 +190,7 @@ def _num_qubits_(self) -> int: def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, @@ -502,7 +502,7 @@ def _num_qubits_(self) -> int: def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, @@ -672,7 +672,7 @@ def _num_qubits_(self) -> int: def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, diff --git a/cirq-core/cirq/ops/wait_gate.py b/cirq-core/cirq/ops/wait_gate.py index 3310e9fcb87..2f30ac9c3ef 100644 --- a/cirq-core/cirq/ops/wait_gate.py +++ b/cirq-core/cirq/ops/wait_gate.py @@ -34,7 +34,7 @@ def __init__( self, duration: 'cirq.DURATION_LIKE', num_qubits: Optional[int] = None, - qid_shape: Tuple[int, ...] = None, + qid_shape: Optional[Tuple[int, ...]] = None, ) -> None: """Initialize a wait gate with the given duration. diff --git a/cirq-core/cirq/protocols/act_on_protocol.py b/cirq-core/cirq/protocols/act_on_protocol.py index 703396c92c2..07c8f95ee00 100644 --- a/cirq-core/cirq/protocols/act_on_protocol.py +++ b/cirq-core/cirq/protocols/act_on_protocol.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from typing import Any, Sequence, TYPE_CHECKING, Union +from typing import Any, Optional, Sequence, TYPE_CHECKING, Union from typing_extensions import Protocol @@ -89,7 +89,7 @@ def _act_on_( def act_on( action: Any, sim_state: 'cirq.SimulationStateBase', - qubits: Sequence['cirq.Qid'] = None, + qubits: Optional[Sequence['cirq.Qid']] = None, *, allow_decompose: bool = True, ): diff --git a/cirq-core/cirq/protocols/act_on_protocol_test.py b/cirq-core/cirq/protocols/act_on_protocol_test.py index a5e4ffb1ea8..2cc31855b78 100644 --- a/cirq-core/cirq/protocols/act_on_protocol_test.py +++ b/cirq-core/cirq/protocols/act_on_protocol_test.py @@ -62,10 +62,10 @@ def test_act_on_fallback_errors(): def test_act_on_errors(): class Op(cirq.Operation): @property - def qubits(self) -> Tuple['cirq.Qid', ...]: + def qubits(self) -> Tuple['cirq.Qid', ...]: # type: ignore[empty-body] pass - def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf: + def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf: # type: ignore[empty-body] pass def _act_on_(self, sim_state): @@ -79,10 +79,10 @@ def _act_on_(self, sim_state): def test_qubits_not_allowed_for_operations(): class Op(cirq.Operation): @property - def qubits(self) -> Tuple['cirq.Qid', ...]: + def qubits(self) -> Tuple['cirq.Qid', ...]: # type: ignore[empty-body] pass - def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf: + def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf: # type: ignore[empty-body] pass state = DummySimulationState() diff --git a/cirq-core/cirq/protocols/apply_mixture_protocol_test.py b/cirq-core/cirq/protocols/apply_mixture_protocol_test.py index 56225ecff36..e6ed4c2c0e9 100644 --- a/cirq-core/cirq/protocols/apply_mixture_protocol_test.py +++ b/cirq-core/cirq/protocols/apply_mixture_protocol_test.py @@ -33,7 +33,7 @@ def assert_apply_mixture_returns( left_axes: Iterable[int], right_axes: Optional[Iterable[int]], assert_result_is_out_buf: bool = False, - expected_result: np.ndarray = None, + expected_result: Optional[np.ndarray] = None, ): out_buf, buf0, buf1 = make_buffers(rho.shape, rho.dtype) result = cirq.apply_mixture( diff --git a/cirq-core/cirq/protocols/json_serialization_test.py b/cirq-core/cirq/protocols/json_serialization_test.py index 2a1a1d5ae09..395a0e751ce 100644 --- a/cirq-core/cirq/protocols/json_serialization_test.py +++ b/cirq-core/cirq/protocols/json_serialization_test.py @@ -767,7 +767,7 @@ def test_pathlib_paths(tmpdir): assert cirq.read_json_gzip(gzip_path) == cirq.X -def test_dataclass_json_dict(): +def test_dataclass_json_dict() -> None: @dataclasses.dataclass(frozen=True) class MyDC: q: cirq.LineQubit diff --git a/cirq-core/cirq/protocols/measurement_key_protocol.py b/cirq-core/cirq/protocols/measurement_key_protocol.py index 69b552f8e23..07b44d784a4 100644 --- a/cirq-core/cirq/protocols/measurement_key_protocol.py +++ b/cirq-core/cirq/protocols/measurement_key_protocol.py @@ -316,7 +316,9 @@ def with_key_path_prefix(val: Any, prefix: Tuple[str, ...]): def with_rescoped_keys( - val: Any, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey'] = None + val: Any, + path: Tuple[str, ...], + bindable_keys: Optional[FrozenSet['cirq.MeasurementKey']] = None, ): """Rescopes any measurement and control keys to the provided path, given the existing keys. diff --git a/cirq-core/cirq/protocols/qasm.py b/cirq-core/cirq/protocols/qasm.py index 65adf3668b3..34698428769 100644 --- a/cirq-core/cirq/protocols/qasm.py +++ b/cirq-core/cirq/protocols/qasm.py @@ -36,8 +36,8 @@ def __init__( self, precision: int = 10, version: str = '2.0', - qubit_id_map: Dict['cirq.Qid', str] = None, - meas_key_id_map: Dict[str, str] = None, + qubit_id_map: Optional[Dict['cirq.Qid', str]] = None, + meas_key_id_map: Optional[Dict[str, str]] = None, ) -> None: """Inits QasmArgs. diff --git a/cirq-core/cirq/qis/channels.py b/cirq-core/cirq/qis/channels.py index d0127c2e27f..58bc858b2fa 100644 --- a/cirq-core/cirq/qis/channels.py +++ b/cirq-core/cirq/qis/channels.py @@ -51,7 +51,7 @@ def kraus_to_choi(kraus_operators: Sequence[np.ndarray]) -> np.ndarray: """ d = np.prod(kraus_operators[0].shape, dtype=np.int64) choi_rank = len(kraus_operators) - k = np.reshape(kraus_operators, (choi_rank, d)) + k = np.reshape(np.asarray(kraus_operators), (choi_rank, d)) return np.einsum('bi,bj->ij', k, k.conj()) diff --git a/cirq-core/cirq/sim/simulation_state_base.py b/cirq-core/cirq/sim/simulation_state_base.py index 89033c7ac44..044ee94c4a1 100644 --- a/cirq-core/cirq/sim/simulation_state_base.py +++ b/cirq-core/cirq/sim/simulation_state_base.py @@ -124,11 +124,14 @@ def sample( ) -> np.ndarray: """Samples the state value.""" + @abc.abstractmethod def __getitem__(self, item: Optional['cirq.Qid']) -> TSimulationState: """Gets the item associated with the qubit.""" + @abc.abstractmethod def __len__(self) -> int: """Gets the number of items in the mapping.""" + @abc.abstractmethod def __iter__(self) -> Iterator[Optional['cirq.Qid']]: """Iterates the keys of the mapping.""" diff --git a/cirq-core/cirq/sim/simulator.py b/cirq-core/cirq/sim/simulator.py index 7bb24beb62a..a4cbd25e54b 100644 --- a/cirq-core/cirq/sim/simulator.py +++ b/cirq-core/cirq/sim/simulator.py @@ -452,6 +452,7 @@ def simulate_expectation_values_sweep_iter( ValueError if 'program' has terminal measurement(s) and 'permit_terminal_measurements' is False. """ + raise NotImplementedError class SimulatesFinalState( diff --git a/cirq-core/cirq/sim/sparse_simulator_test.py b/cirq-core/cirq/sim/sparse_simulator_test.py index 50c8f441b88..a769be3028d 100644 --- a/cirq-core/cirq/sim/sparse_simulator_test.py +++ b/cirq-core/cirq/sim/sparse_simulator_test.py @@ -255,7 +255,7 @@ def test_run_mixture(dtype: Type[np.complexfloating], split: bool): simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split) circuit = cirq.Circuit(cirq.bit_flip(0.5)(q0), cirq.measure(q0)) result = simulator.run(circuit, repetitions=100) - assert 20 < sum(result.measurements['q(0)'])[0] < 80 # type: ignore + assert 20 < sum(result.measurements['q(0)'])[0] < 80 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128]) @@ -265,8 +265,8 @@ def test_run_mixture_with_gates(dtype: Type[np.complexfloating], split: bool): simulator = cirq.Simulator(dtype=dtype, split_untangled_states=split, seed=23) circuit = cirq.Circuit(cirq.H(q0), cirq.phase_flip(0.5)(q0), cirq.H(q0), cirq.measure(q0)) result = simulator.run(circuit, repetitions=100) - assert sum(result.measurements['q(0)'])[0] < 80 # type: ignore - assert sum(result.measurements['q(0)'])[0] > 20 # type: ignore + assert sum(result.measurements['q(0)'])[0] < 80 + assert sum(result.measurements['q(0)'])[0] > 20 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128]) diff --git a/cirq-core/cirq/sim/state_vector.py b/cirq-core/cirq/sim/state_vector.py index 1126911eefc..62947a81ca2 100644 --- a/cirq-core/cirq/sim/state_vector.py +++ b/cirq-core/cirq/sim/state_vector.py @@ -102,7 +102,7 @@ def dirac_notation(self, decimals: int = 2) -> str: and non-zero floats of the specified accuracy.""" return qis.dirac_notation(self.state_vector(), decimals, qid_shape=self._qid_shape) - def density_matrix_of(self, qubits: List['cirq.Qid'] = None) -> np.ndarray: + def density_matrix_of(self, qubits: Optional[List['cirq.Qid']] = None) -> np.ndarray: r"""Returns the density matrix of the state. Calculate the density matrix for the system on the qubits provided. diff --git a/cirq-core/cirq/study/flatten_expressions.py b/cirq-core/cirq/study/flatten_expressions.py index 0430afc4bad..9c3892dc1d8 100644 --- a/cirq-core/cirq/study/flatten_expressions.py +++ b/cirq-core/cirq/study/flatten_expressions.py @@ -200,7 +200,7 @@ def __init__( self, param_dict: Optional[resolver.ParamResolverOrSimilarType] = None, *, # Force keyword args - get_param_name: Callable[[sympy.Expr], str,] = None, + get_param_name: Optional[Callable[[sympy.Expr], str]] = None, ): """Initializes a new _ParamFlattener. diff --git a/cirq-core/cirq/study/sweeps.py b/cirq-core/cirq/study/sweeps.py index 6b2be3217c3..ecce76284ed 100644 --- a/cirq-core/cirq/study/sweeps.py +++ b/cirq-core/cirq/study/sweeps.py @@ -127,7 +127,7 @@ def __getitem__(self, val: int) -> resolver.ParamResolver: def __getitem__(self, val: slice) -> 'Sweep': pass - def __getitem__(self, val): + def __getitem__(self, val: Union[int, slice]) -> Union[resolver.ParamResolver, 'Sweep']: n = len(self) if isinstance(val, int): if val < -n or val >= n: diff --git a/cirq-core/cirq/testing/consistent_controlled_gate_op_test.py b/cirq-core/cirq/testing/consistent_controlled_gate_op_test.py index 4688f5722f3..0d863ac9f5b 100644 --- a/cirq-core/cirq/testing/consistent_controlled_gate_op_test.py +++ b/cirq-core/cirq/testing/consistent_controlled_gate_op_test.py @@ -49,7 +49,7 @@ def on(self, *qubits: 'cirq.Qid') -> 'cirq.Operation': def controlled( self, - num_controls: int = None, + num_controls: Optional[int] = None, control_values: Optional[ Union[cv.AbstractControlValues, Sequence[Union[int, Collection[int]]]] ] = None, diff --git a/cirq-core/cirq/testing/json.py b/cirq-core/cirq/testing/json.py index 288c04719b1..2b50518cd31 100644 --- a/cirq-core/cirq/testing/json.py +++ b/cirq-core/cirq/testing/json.py @@ -95,11 +95,11 @@ def find_classes_that_should_serialize(self) -> Set[Tuple[str, Type]]: return result - def get_resolver_cache_types(self): + def get_resolver_cache_types(self) -> Set[Tuple[str, Type]]: result: Set[Tuple[str, Type]] = set() for k, v in self.resolver_cache.items(): - t = v if isinstance(v, type) else None - result.add((k, t)) + if isinstance(v, type): + result.add((k, v)) return result def get_all_names(self) -> Iterator[str]: diff --git a/cirq-core/cirq/testing/random_circuit.py b/cirq-core/cirq/testing/random_circuit.py index 35e6dd6bf83..224036594b1 100644 --- a/cirq-core/cirq/testing/random_circuit.py +++ b/cirq-core/cirq/testing/random_circuit.py @@ -114,9 +114,7 @@ def random_circuit( free_qubits = set(qubits) while len(free_qubits) >= max_arity: gate, arity = gate_arity_pairs[prng.randint(num_gates)] - op_qubits = prng.choice( - sorted(free_qubits), size=arity, replace=False # type: ignore[arg-type] - ) + op_qubits = prng.choice(sorted(free_qubits), size=arity, replace=False) free_qubits.difference_update(op_qubits) if prng.rand() <= op_density: operations.append(gate(*op_qubits)) @@ -127,8 +125,8 @@ def random_circuit( def random_two_qubit_circuit_with_czs( num_czs: int = 3, - q0: Qid = None, - q1: Qid = None, + q0: Optional[Qid] = None, + q1: Optional[Qid] = None, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None, ) -> circuits.Circuit: """Creates a random two qubit circuit with the given number of CNOTs. diff --git a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py index 342b6789c4d..06b94c274d0 100644 --- a/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py +++ b/cirq-core/cirq/transformers/analytical_decompositions/two_qubit_to_fsim.py @@ -28,7 +28,7 @@ def decompose_two_qubit_interaction_into_four_fsim_gates( interaction: Union['cirq.SupportsUnitary', np.ndarray], *, fsim_gate: Union['cirq.FSimGate', 'cirq.ISwapPowGate'], - qubits: Sequence['cirq.Qid'] = None, + qubits: Optional[Sequence['cirq.Qid']] = None, ) -> 'cirq.Circuit': """Decomposes operations into an FSimGate near theta=pi/2, phi=0. diff --git a/cirq-core/cirq/transformers/measurement_transformers.py b/cirq-core/cirq/transformers/measurement_transformers.py index a7da2804dd3..7e38c8c991b 100644 --- a/cirq-core/cirq/transformers/measurement_transformers.py +++ b/cirq-core/cirq/transformers/measurement_transformers.py @@ -14,7 +14,7 @@ import itertools from collections import defaultdict -from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union +from typing import Any, cast, Dict, Iterable, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union import numpy as np @@ -420,13 +420,13 @@ def _kraus_(self) -> Tuple[np.ndarray, ...]: return self._kraus def _apply_channel_(self, args: 'cirq.ApplyChannelArgs'): - configs = [] + configs: List[transformations._BuildFromSlicesArgs] = [] for i in range(np.prod(self._shape) ** 2): - scale = self._confusion_map.flat[i] + scale = cast(complex, self._confusion_map.flat[i]) if scale == 0: continue index: Any = np.unravel_index(i, self._shape * 2) - slices = [] + slices: List[transformations._SliceConfig] = [] axis_count = len(args.left_axes) for j in range(axis_count): s1 = transformations._SliceConfig( diff --git a/cirq-core/cirq/transformers/stratify.py b/cirq-core/cirq/transformers/stratify.py index fa153f8815b..6761f0b26b8 100644 --- a/cirq-core/cirq/transformers/stratify.py +++ b/cirq-core/cirq/transformers/stratify.py @@ -224,6 +224,7 @@ def _category_to_classifier(category) -> Classifier: def _dummy_classifier(op: 'cirq.Operation') -> bool: """Dummy classifier, used to "complete" a collection of classifiers and make it exhaustive.""" + return False # coverage: ignore def _get_op_class(op: 'cirq.Operation', classifiers: Sequence[Classifier]) -> int: diff --git a/cirq-core/cirq/transformers/transformer_api.py b/cirq-core/cirq/transformers/transformer_api.py index 0526de4a1eb..3567e566207 100644 --- a/cirq-core/cirq/transformers/transformer_api.py +++ b/cirq-core/cirq/transformers/transformer_api.py @@ -109,7 +109,7 @@ class TransformerLogger: The `LogLevel`s can be used to control the input processing and output resolution of the logs. """ - def __init__(self): + def __init__(self) -> None: """Initializes TransformerLogger.""" self._curr_id: int = 0 self._logs: List[_LoggerNode] = [] diff --git a/cirq-core/cirq/value/abc_alt_test.py b/cirq-core/cirq/value/abc_alt_test.py index 33ff9c4ce52..bbbf53af73c 100644 --- a/cirq-core/cirq/value/abc_alt_test.py +++ b/cirq-core/cirq/value/abc_alt_test.py @@ -155,6 +155,7 @@ def _default_impl2(self, arg, kw=99): @alternative(requires='alt2', implementation=_default_impl2) def my_method(self, arg, kw=99) -> str: """Docstring.""" + raise NotImplementedError @abc.abstractmethod def alt1(self) -> Optional[str]: diff --git a/cirq-core/cirq/value/classical_data.py b/cirq-core/cirq/value/classical_data.py index ad5f9053fde..532212e84fe 100644 --- a/cirq-core/cirq/value/classical_data.py +++ b/cirq-core/cirq/value/classical_data.py @@ -14,7 +14,7 @@ import abc import enum -from typing import Dict, List, Mapping, Sequence, Tuple, TYPE_CHECKING, TypeVar +from typing import Dict, List, Mapping, Optional, Sequence, Tuple, TYPE_CHECKING, TypeVar from cirq.value import digits, value_equality_attr @@ -142,10 +142,12 @@ class ClassicalDataDictionaryStore(ClassicalDataStore): def __init__( self, *, - _records: Dict['cirq.MeasurementKey', List[Tuple[int, ...]]] = None, - _measured_qubits: Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] = None, - _channel_records: Dict['cirq.MeasurementKey', List[int]] = None, - _measurement_types: Dict['cirq.MeasurementKey', 'cirq.MeasurementType'] = None, + _records: Optional[Dict['cirq.MeasurementKey', List[Tuple[int, ...]]]] = None, + _measured_qubits: Optional[ + Dict['cirq.MeasurementKey', List[Tuple['cirq.Qid', ...]]] + ] = None, + _channel_records: Optional[Dict['cirq.MeasurementKey', List[int]]] = None, + _measurement_types: Optional[Dict['cirq.MeasurementKey', 'cirq.MeasurementType']] = None, ): """Initializes a `ClassicalDataDictionaryStore` object.""" if not _measurement_types: diff --git a/cirq-core/cirq/value/linear_dict.py b/cirq-core/cirq/value/linear_dict.py index 23063d0d3df..461c9ec102e 100644 --- a/cirq-core/cirq/value/linear_dict.py +++ b/cirq-core/cirq/value/linear_dict.py @@ -18,19 +18,19 @@ Any, Callable, Dict, + Generic, ItemsView, Iterable, Iterator, KeysView, Mapping, MutableMapping, + Optional, overload, Tuple, TypeVar, Union, ValuesView, - Generic, - Optional, ) Scalar = Union[complex, float, numbers.Complex] @@ -94,7 +94,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]): def __init__( self, terms: Optional[Mapping[TVector, Scalar]] = None, - validator: Callable[[TVector], bool] = None, + validator: Optional[Callable[[TVector], bool]] = None, ) -> None: """Initializes linear combination from a collection of terms. diff --git a/cirq-core/cirq/value/product_state.py b/cirq-core/cirq/value/product_state.py index 7050f68778b..80544400d4b 100644 --- a/cirq-core/cirq/value/product_state.py +++ b/cirq-core/cirq/value/product_state.py @@ -13,7 +13,7 @@ # limitations under the License. import abc from dataclasses import dataclass -from typing import TYPE_CHECKING, Dict, Sequence, Tuple, Iterator +from typing import Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING import numpy as np @@ -119,7 +119,7 @@ def _json_dict_(self): def _from_json_dict_(cls, states, **kwargs): return cls(states=dict(states)) - def state_vector(self, qubit_order: 'cirq.QubitOrder' = None) -> np.ndarray: + def state_vector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray: """The state-vector representation of this state.""" from cirq import ops @@ -136,7 +136,7 @@ def state_vector(self, qubit_order: 'cirq.QubitOrder' = None) -> np.ndarray: return mat - def projector(self, qubit_order: 'cirq.QubitOrder' = None) -> np.ndarray: + def projector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray: """The projector associated with this state expressed as a matrix. This is |s⟩⟨s| where |s⟩ is this state. diff --git a/cirq-core/cirq/value/value_equality_attr.py b/cirq-core/cirq/value/value_equality_attr.py index cfbecce73e9..c36fc1355c8 100644 --- a/cirq-core/cirq/value/value_equality_attr.py +++ b/cirq-core/cirq/value/value_equality_attr.py @@ -13,7 +13,7 @@ # limitations under the License. """Defines `@cirq.value_equality`, for easy __eq__/__hash__ methods.""" -from typing import Union, Callable, overload, Any +from typing import Any, Callable, Optional, overload, Union from typing_extensions import Protocol @@ -132,7 +132,7 @@ def value_equality( def value_equality( - cls: type = None, + cls: Optional[type] = None, *, unhashable: bool = False, distinct_child_types: bool = False, diff --git a/cirq-core/cirq/work/observable_measurement_data.py b/cirq-core/cirq/work/observable_measurement_data.py index 9936eed2f0d..b683ca5e70b 100644 --- a/cirq-core/cirq/work/observable_measurement_data.py +++ b/cirq-core/cirq/work/observable_measurement_data.py @@ -14,7 +14,7 @@ import dataclasses import datetime -from typing import Any, Dict, Iterable, List, Mapping, Tuple, TYPE_CHECKING, Union +from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, TYPE_CHECKING, Union import numpy as np import sympy @@ -212,10 +212,10 @@ def __init__( meas_spec: _MeasurementSpec, simul_settings: List[InitObsSetting], qubit_to_index: Dict['cirq.Qid', int], - bitstrings: np.ndarray = None, - chunksizes: np.ndarray = None, - timestamps: np.ndarray = None, - readout_calibration: 'BitstringAccumulator' = None, + bitstrings: Optional[np.ndarray] = None, + chunksizes: Optional[np.ndarray] = None, + timestamps: Optional[np.ndarray] = None, + readout_calibration: Optional['BitstringAccumulator'] = None, ): self._meas_spec = meas_spec self._simul_settings = simul_settings diff --git a/cirq-core/cirq/work/observable_readout_calibration.py b/cirq-core/cirq/work/observable_readout_calibration.py index 0ecd7051a3b..f18602c81fa 100644 --- a/cirq-core/cirq/work/observable_readout_calibration.py +++ b/cirq-core/cirq/work/observable_readout_calibration.py @@ -17,7 +17,9 @@ def calibrate_readout_error( ): # We know there won't be any fancy sweeps or observables so we can # get away with more repetitions per job - stopping_criteria = dataclasses.replace(stopping_criteria, repetitions_per_chunk=100_000) + stopping_criteria = dataclasses.replace( + stopping_criteria, repetitions_per_chunk=100_000 # type: ignore[type-var] + ) # Simultaneous readout characterization: # We can measure all qubits simultaneously (i.e. _max_setting is ZZZ..ZZ diff --git a/cirq-core/cirq/work/sampler.py b/cirq-core/cirq/work/sampler.py index ee02e01bedc..0b766b5ca1e 100644 --- a/cirq-core/cirq/work/sampler.py +++ b/cirq-core/cirq/work/sampler.py @@ -211,6 +211,7 @@ def run_sweep( Returns: Result list for this run; one for each possible parameter resolver. """ + raise NotImplementedError @value.alternative(requires='run_sweep', implementation=_run_sweep_async_impl) async def run_sweep_async( @@ -230,6 +231,7 @@ async def run_sweep_async( Returns: Result list for this run; one for each possible parameter resolver. """ + raise NotImplementedError def run_batch( self, diff --git a/cirq-core/cirq/work/zeros_sampler.py b/cirq-core/cirq/work/zeros_sampler.py index dc2ba074233..6e6e4a42108 100644 --- a/cirq-core/cirq/work/zeros_sampler.py +++ b/cirq-core/cirq/work/zeros_sampler.py @@ -13,7 +13,7 @@ # limitations under the License. import abc -from typing import List, TYPE_CHECKING +from typing import List, Optional, TYPE_CHECKING import numpy as np @@ -26,7 +26,7 @@ class ZerosSampler(work.Sampler, metaclass=abc.ABCMeta): """A dummy sampler for testing. Immediately returns zeroes.""" - def __init__(self, device: devices.Device = None): + def __init__(self, device: Optional[devices.Device] = None): """Construct a sampler that returns 0 for all measurements. Args: diff --git a/cirq-core/requirements.txt b/cirq-core/requirements.txt index e26eef68637..f936e50880b 100644 --- a/cirq-core/requirements.txt +++ b/cirq-core/requirements.txt @@ -3,7 +3,7 @@ # functools.cached_property was introduced in python 3.8 backports.cached_property~=1.0.1; python_version < '3.8' -duet~=0.2.7 +duet~=0.2.8 matplotlib~=3.0 networkx~=2.4 numpy>=1.16,<1.24 @@ -11,5 +11,5 @@ pandas sortedcontainers~=2.0 scipy sympy -typing_extensions +typing_extensions>=4.2 tqdm diff --git a/cirq-google/cirq_google/api/v2/results.py b/cirq-google/cirq_google/api/v2/results.py index d87171bce4e..1beaa43c227 100644 --- a/cirq-google/cirq_google/api/v2/results.py +++ b/cirq-google/cirq_google/api/v2/results.py @@ -148,7 +148,7 @@ def results_to_proto( def results_from_proto( - msg: result_pb2.Result, measurements: List[MeasureInfo] = None + msg: result_pb2.Result, measurements: Optional[List[MeasureInfo]] = None ) -> Sequence[Sequence[cirq.Result]]: """Converts a v2 result proto into List of list of trial results. @@ -170,7 +170,7 @@ def results_from_proto( def _trial_sweep_from_proto( - msg: result_pb2.SweepResult, measure_map: Dict[str, MeasureInfo] = None + msg: result_pb2.SweepResult, measure_map: Optional[Dict[str, MeasureInfo]] = None ) -> Sequence[cirq.Result]: """Converts a SweepResult proto into List of list of trial results. diff --git a/cirq-google/cirq_google/calibration/phased_fsim.py b/cirq-google/cirq_google/calibration/phased_fsim.py index f6607590ba6..1b974d91b9e 100644 --- a/cirq-google/cirq_google/calibration/phased_fsim.py +++ b/cirq-google/cirq_google/calibration/phased_fsim.py @@ -428,8 +428,7 @@ class PhasedFSimCalibrationError(Exception): """Error that indicates the calibration failure.""" -# We have to relax a mypy constraint, see https://github.com/python/mypy/issues/5374 -@dataclasses.dataclass(frozen=True) # type: ignore +@dataclasses.dataclass(frozen=True) class PhasedFSimCalibrationRequest(abc.ABC): """Description of the request to characterize PhasedFSimGate. @@ -445,8 +444,7 @@ class PhasedFSimCalibrationRequest(abc.ABC): gate: cirq.Gate # Any gate which can be described by cirq.PhasedFSim options: PhasedFSimCalibrationOptions - # Workaround for: https://github.com/python/mypy/issues/1362 - @property # type: ignore + @property @lru_cache_typesafe def qubit_to_pair(self) -> MutableMapping[cirq.Qid, Tuple[cirq.Qid, cirq.Qid]]: """Returns mapping from qubit to a qubit pair that it belongs to.""" diff --git a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/async_client.py b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/async_client.py index 1201a88d5f7..d14d484d39e 100644 --- a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/async_client.py +++ b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/async_client.py @@ -150,7 +150,7 @@ def transport(self) -> QuantumEngineServiceTransport: def __init__(self, *, credentials: ga_credentials.Credentials = None, transport: Union[str, QuantumEngineServiceTransport] = "grpc_asyncio", - client_options: ClientOptions = None, + client_options: Optional[ClientOptions] = None, client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, ) -> None: """Instantiates the quantum engine service client. @@ -194,10 +194,10 @@ def __init__(self, *, ) async def create_quantum_program(self, - request: Union[engine.CreateQuantumProgramRequest, dict] = None, + request: Union[engine.CreateQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProgram: r"""- @@ -264,10 +264,10 @@ def sample_create_quantum_program(): return response async def get_quantum_program(self, - request: Union[engine.GetQuantumProgramRequest, dict] = None, + request: Union[engine.GetQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProgram: r"""- @@ -334,10 +334,10 @@ def sample_get_quantum_program(): return response async def list_quantum_programs(self, - request: Union[engine.ListQuantumProgramsRequest, dict] = None, + request: Union[engine.ListQuantumProgramsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumProgramsAsyncPager: r"""- @@ -418,10 +418,10 @@ def sample_list_quantum_programs(): return response async def delete_quantum_program(self, - request: Union[engine.DeleteQuantumProgramRequest, dict] = None, + request: Union[engine.DeleteQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -478,10 +478,10 @@ def sample_delete_quantum_program(): ) async def update_quantum_program(self, - request: Union[engine.UpdateQuantumProgramRequest, dict] = None, + request: Union[engine.UpdateQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProgram: r"""- @@ -548,10 +548,10 @@ def sample_update_quantum_program(): return response async def create_quantum_job(self, - request: Union[engine.CreateQuantumJobRequest, dict] = None, + request: Union[engine.CreateQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumJob: r"""- @@ -618,10 +618,10 @@ def sample_create_quantum_job(): return response async def get_quantum_job(self, - request: Union[engine.GetQuantumJobRequest, dict] = None, + request: Union[engine.GetQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumJob: r"""- @@ -688,10 +688,10 @@ def sample_get_quantum_job(): return response async def list_quantum_jobs(self, - request: Union[engine.ListQuantumJobsRequest, dict] = None, + request: Union[engine.ListQuantumJobsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumJobsAsyncPager: r"""- @@ -772,10 +772,10 @@ def sample_list_quantum_jobs(): return response async def delete_quantum_job(self, - request: Union[engine.DeleteQuantumJobRequest, dict] = None, + request: Union[engine.DeleteQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -832,10 +832,10 @@ def sample_delete_quantum_job(): ) async def update_quantum_job(self, - request: Union[engine.UpdateQuantumJobRequest, dict] = None, + request: Union[engine.UpdateQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumJob: r"""- @@ -902,10 +902,10 @@ def sample_update_quantum_job(): return response async def cancel_quantum_job(self, - request: Union[engine.CancelQuantumJobRequest, dict] = None, + request: Union[engine.CancelQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -962,10 +962,10 @@ def sample_cancel_quantum_job(): ) async def list_quantum_job_events(self, - request: Union[engine.ListQuantumJobEventsRequest, dict] = None, + request: Union[engine.ListQuantumJobEventsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumJobEventsAsyncPager: r"""- @@ -1046,10 +1046,10 @@ def sample_list_quantum_job_events(): return response async def get_quantum_result(self, - request: Union[engine.GetQuantumResultRequest, dict] = None, + request: Union[engine.GetQuantumResultRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumResult: r"""- @@ -1116,10 +1116,10 @@ def sample_get_quantum_result(): return response async def list_quantum_processors(self, - request: Union[engine.ListQuantumProcessorsRequest, dict] = None, + request: Union[engine.ListQuantumProcessorsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumProcessorsAsyncPager: r"""- @@ -1200,10 +1200,10 @@ def sample_list_quantum_processors(): return response async def get_quantum_processor(self, - request: Union[engine.GetQuantumProcessorRequest, dict] = None, + request: Union[engine.GetQuantumProcessorRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProcessor: r"""- @@ -1270,10 +1270,10 @@ def sample_get_quantum_processor(): return response async def list_quantum_calibrations(self, - request: Union[engine.ListQuantumCalibrationsRequest, dict] = None, + request: Union[engine.ListQuantumCalibrationsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumCalibrationsAsyncPager: r"""- @@ -1354,10 +1354,10 @@ def sample_list_quantum_calibrations(): return response async def get_quantum_calibration(self, - request: Union[engine.GetQuantumCalibrationRequest, dict] = None, + request: Union[engine.GetQuantumCalibrationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumCalibration: r"""- @@ -1424,10 +1424,10 @@ def sample_get_quantum_calibration(): return response async def create_quantum_reservation(self, - request: Union[engine.CreateQuantumReservationRequest, dict] = None, + request: Union[engine.CreateQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -1494,10 +1494,10 @@ def sample_create_quantum_reservation(): return response async def cancel_quantum_reservation(self, - request: Union[engine.CancelQuantumReservationRequest, dict] = None, + request: Union[engine.CancelQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -1564,10 +1564,10 @@ def sample_cancel_quantum_reservation(): return response async def delete_quantum_reservation(self, - request: Union[engine.DeleteQuantumReservationRequest, dict] = None, + request: Union[engine.DeleteQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -1624,10 +1624,10 @@ def sample_delete_quantum_reservation(): ) async def get_quantum_reservation(self, - request: Union[engine.GetQuantumReservationRequest, dict] = None, + request: Union[engine.GetQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -1694,10 +1694,10 @@ def sample_get_quantum_reservation(): return response async def list_quantum_reservations(self, - request: Union[engine.ListQuantumReservationsRequest, dict] = None, + request: Union[engine.ListQuantumReservationsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumReservationsAsyncPager: r"""- @@ -1778,10 +1778,10 @@ def sample_list_quantum_reservations(): return response async def update_quantum_reservation(self, - request: Union[engine.UpdateQuantumReservationRequest, dict] = None, + request: Union[engine.UpdateQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -1848,10 +1848,10 @@ def sample_update_quantum_reservation(): return response def quantum_run_stream(self, - requests: AsyncIterator[engine.QuantumRunStreamRequest] = None, + requests: Optional[AsyncIterator[engine.QuantumRunStreamRequest]] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> Awaitable[AsyncIterable[engine.QuantumRunStreamResponse]]: r"""- @@ -1919,10 +1919,10 @@ def request_generator(): return response async def list_quantum_reservation_grants(self, - request: Union[engine.ListQuantumReservationGrantsRequest, dict] = None, + request: Union[engine.ListQuantumReservationGrantsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumReservationGrantsAsyncPager: r"""- @@ -2003,10 +2003,10 @@ def sample_list_quantum_reservation_grants(): return response async def reallocate_quantum_reservation_grant(self, - request: Union[engine.ReallocateQuantumReservationGrantRequest, dict] = None, + request: Union[engine.ReallocateQuantumReservationGrantRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservationGrant: r"""- @@ -2073,10 +2073,10 @@ def sample_reallocate_quantum_reservation_grant(): return response async def list_quantum_reservation_budgets(self, - request: Union[engine.ListQuantumReservationBudgetsRequest, dict] = None, + request: Union[engine.ListQuantumReservationBudgetsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumReservationBudgetsAsyncPager: r"""- @@ -2157,10 +2157,10 @@ def sample_list_quantum_reservation_budgets(): return response async def list_quantum_time_slots(self, - request: Union[engine.ListQuantumTimeSlotsRequest, dict] = None, + request: Union[engine.ListQuantumTimeSlotsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumTimeSlotsAsyncPager: r"""- diff --git a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/client.py b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/client.py index fd6f5dcfe80..c7b57431773 100644 --- a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/client.py +++ b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/client.py @@ -57,7 +57,7 @@ class QuantumEngineServiceClientMeta(type): _transport_registry["grpc_asyncio"] = QuantumEngineServiceGrpcAsyncIOTransport def get_transport_class(cls, - label: str = None, + label: Optional[str] = None, ) -> Type[QuantumEngineServiceTransport]: """Returns an appropriate transport class. @@ -408,10 +408,10 @@ def __init__(self, *, ) def create_quantum_program(self, - request: Union[engine.CreateQuantumProgramRequest, dict] = None, + request: Union[engine.CreateQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProgram: r"""- @@ -479,10 +479,10 @@ def sample_create_quantum_program(): return response def get_quantum_program(self, - request: Union[engine.GetQuantumProgramRequest, dict] = None, + request: Union[engine.GetQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProgram: r"""- @@ -550,10 +550,10 @@ def sample_get_quantum_program(): return response def list_quantum_programs(self, - request: Union[engine.ListQuantumProgramsRequest, dict] = None, + request: Union[engine.ListQuantumProgramsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumProgramsPager: r"""- @@ -635,10 +635,10 @@ def sample_list_quantum_programs(): return response def delete_quantum_program(self, - request: Union[engine.DeleteQuantumProgramRequest, dict] = None, + request: Union[engine.DeleteQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -696,10 +696,10 @@ def sample_delete_quantum_program(): ) def update_quantum_program(self, - request: Union[engine.UpdateQuantumProgramRequest, dict] = None, + request: Union[engine.UpdateQuantumProgramRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProgram: r"""- @@ -767,10 +767,10 @@ def sample_update_quantum_program(): return response def create_quantum_job(self, - request: Union[engine.CreateQuantumJobRequest, dict] = None, + request: Union[engine.CreateQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumJob: r"""- @@ -838,10 +838,10 @@ def sample_create_quantum_job(): return response def get_quantum_job(self, - request: Union[engine.GetQuantumJobRequest, dict] = None, + request: Union[engine.GetQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumJob: r"""- @@ -909,10 +909,10 @@ def sample_get_quantum_job(): return response def list_quantum_jobs(self, - request: Union[engine.ListQuantumJobsRequest, dict] = None, + request: Union[engine.ListQuantumJobsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumJobsPager: r"""- @@ -994,10 +994,10 @@ def sample_list_quantum_jobs(): return response def delete_quantum_job(self, - request: Union[engine.DeleteQuantumJobRequest, dict] = None, + request: Union[engine.DeleteQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -1055,10 +1055,10 @@ def sample_delete_quantum_job(): ) def update_quantum_job(self, - request: Union[engine.UpdateQuantumJobRequest, dict] = None, + request: Union[engine.UpdateQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumJob: r"""- @@ -1126,10 +1126,10 @@ def sample_update_quantum_job(): return response def cancel_quantum_job(self, - request: Union[engine.CancelQuantumJobRequest, dict] = None, + request: Union[engine.CancelQuantumJobRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -1187,10 +1187,10 @@ def sample_cancel_quantum_job(): ) def list_quantum_job_events(self, - request: Union[engine.ListQuantumJobEventsRequest, dict] = None, + request: Union[engine.ListQuantumJobEventsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumJobEventsPager: r"""- @@ -1272,10 +1272,10 @@ def sample_list_quantum_job_events(): return response def get_quantum_result(self, - request: Union[engine.GetQuantumResultRequest, dict] = None, + request: Union[engine.GetQuantumResultRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumResult: r"""- @@ -1343,10 +1343,10 @@ def sample_get_quantum_result(): return response def list_quantum_processors(self, - request: Union[engine.ListQuantumProcessorsRequest, dict] = None, + request: Union[engine.ListQuantumProcessorsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumProcessorsPager: r"""- @@ -1428,10 +1428,10 @@ def sample_list_quantum_processors(): return response def get_quantum_processor(self, - request: Union[engine.GetQuantumProcessorRequest, dict] = None, + request: Union[engine.GetQuantumProcessorRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumProcessor: r"""- @@ -1499,10 +1499,10 @@ def sample_get_quantum_processor(): return response def list_quantum_calibrations(self, - request: Union[engine.ListQuantumCalibrationsRequest, dict] = None, + request: Union[engine.ListQuantumCalibrationsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumCalibrationsPager: r"""- @@ -1584,10 +1584,10 @@ def sample_list_quantum_calibrations(): return response def get_quantum_calibration(self, - request: Union[engine.GetQuantumCalibrationRequest, dict] = None, + request: Union[engine.GetQuantumCalibrationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumCalibration: r"""- @@ -1655,10 +1655,10 @@ def sample_get_quantum_calibration(): return response def create_quantum_reservation(self, - request: Union[engine.CreateQuantumReservationRequest, dict] = None, + request: Union[engine.CreateQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -1726,10 +1726,10 @@ def sample_create_quantum_reservation(): return response def cancel_quantum_reservation(self, - request: Union[engine.CancelQuantumReservationRequest, dict] = None, + request: Union[engine.CancelQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -1797,10 +1797,10 @@ def sample_cancel_quantum_reservation(): return response def delete_quantum_reservation(self, - request: Union[engine.DeleteQuantumReservationRequest, dict] = None, + request: Union[engine.DeleteQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> None: r"""- @@ -1858,10 +1858,10 @@ def sample_delete_quantum_reservation(): ) def get_quantum_reservation(self, - request: Union[engine.GetQuantumReservationRequest, dict] = None, + request: Union[engine.GetQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -1929,10 +1929,10 @@ def sample_get_quantum_reservation(): return response def list_quantum_reservations(self, - request: Union[engine.ListQuantumReservationsRequest, dict] = None, + request: Union[engine.ListQuantumReservationsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumReservationsPager: r"""- @@ -2014,10 +2014,10 @@ def sample_list_quantum_reservations(): return response def update_quantum_reservation(self, - request: Union[engine.UpdateQuantumReservationRequest, dict] = None, + request: Union[engine.UpdateQuantumReservationRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservation: r"""- @@ -2085,10 +2085,10 @@ def sample_update_quantum_reservation(): return response def quantum_run_stream(self, - requests: Iterator[engine.QuantumRunStreamRequest] = None, + requests: Optional[Iterator[engine.QuantumRunStreamRequest]] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> Iterable[engine.QuantumRunStreamResponse]: r"""- @@ -2152,10 +2152,10 @@ def request_generator(): return response def list_quantum_reservation_grants(self, - request: Union[engine.ListQuantumReservationGrantsRequest, dict] = None, + request: Union[engine.ListQuantumReservationGrantsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumReservationGrantsPager: r"""- @@ -2237,10 +2237,10 @@ def sample_list_quantum_reservation_grants(): return response def reallocate_quantum_reservation_grant(self, - request: Union[engine.ReallocateQuantumReservationGrantRequest, dict] = None, + request: Union[engine.ReallocateQuantumReservationGrantRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> quantum.QuantumReservationGrant: r"""- @@ -2308,10 +2308,10 @@ def sample_reallocate_quantum_reservation_grant(): return response def list_quantum_reservation_budgets(self, - request: Union[engine.ListQuantumReservationBudgetsRequest, dict] = None, + request: Union[engine.ListQuantumReservationBudgetsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumReservationBudgetsPager: r"""- @@ -2393,10 +2393,10 @@ def sample_list_quantum_reservation_budgets(): return response def list_quantum_time_slots(self, - request: Union[engine.ListQuantumTimeSlotsRequest, dict] = None, + request: Union[engine.ListQuantumTimeSlotsRequest, dict, None] = None, *, retry: OptionalRetry = gapic_v1.method.DEFAULT, - timeout: float = None, + timeout: Optional[float] = None, metadata: Sequence[Tuple[str, str]] = (), ) -> pagers.ListQuantumTimeSlotsPager: r"""- diff --git a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc.py b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc.py index 25502be3b10..4b5a94b212d 100644 --- a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc.py +++ b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc.py @@ -46,14 +46,14 @@ class QuantumEngineServiceGrpcTransport(QuantumEngineServiceTransport): def __init__(self, *, host: str = 'quantum.googleapis.com', - credentials: ga_credentials.Credentials = None, - credentials_file: str = None, - scopes: Sequence[str] = None, - channel: grpc.Channel = None, - api_mtls_endpoint: str = None, - client_cert_source: Callable[[], Tuple[bytes, bytes]] = None, - ssl_channel_credentials: grpc.ChannelCredentials = None, - client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None, + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, + scopes: Optional[Sequence[str]] = None, + channel: Optional[grpc.Channel] = None, + api_mtls_endpoint: Optional[str] = None, + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, quota_project_id: Optional[str] = None, client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, always_use_jwt_access: Optional[bool] = False, @@ -177,8 +177,8 @@ def __init__(self, *, @classmethod def create_channel(cls, host: str = 'quantum.googleapis.com', - credentials: ga_credentials.Credentials = None, - credentials_file: str = None, + credentials: Optional[ga_credentials.Credentials] = None, + credentials_file: Optional[str] = None, scopes: Optional[Sequence[str]] = None, quota_project_id: Optional[str] = None, **kwargs) -> grpc.Channel: diff --git a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc_asyncio.py b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc_asyncio.py index a01b7ceabd2..ab3a8d873e0 100644 --- a/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc_asyncio.py +++ b/cirq-google/cirq_google/cloud/quantum_v1alpha1/services/quantum_engine_service/transports/grpc_asyncio.py @@ -93,11 +93,11 @@ def __init__(self, *, credentials: ga_credentials.Credentials = None, credentials_file: Optional[str] = None, scopes: Optional[Sequence[str]] = None, - channel: aio.Channel = None, - api_mtls_endpoint: str = None, - client_cert_source: Callable[[], Tuple[bytes, bytes]] = None, - ssl_channel_credentials: grpc.ChannelCredentials = None, - client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None, + channel: Optional[aio.Channel] = None, + api_mtls_endpoint: Optional[str] = None, + client_cert_source: Optional[Callable[[], Tuple[bytes, bytes]]] = None, + ssl_channel_credentials: Optional[grpc.ChannelCredentials] = None, + client_cert_source_for_mtls: Optional[Callable[[], Tuple[bytes, bytes]]] = None, quota_project_id=None, client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO, always_use_jwt_access: Optional[bool] = False, diff --git a/cirq-google/cirq_google/engine/abstract_job_test.py b/cirq-google/cirq_google/engine/abstract_job_test.py index 766ccfbbf9d..23a80566b24 100644 --- a/cirq-google/cirq_google/engine/abstract_job_test.py +++ b/cirq-google/cirq_google/engine/abstract_job_test.py @@ -20,42 +20,41 @@ if TYPE_CHECKING: import datetime import cirq_google.engine.abstract_engine as abstract_engine - import cirq_google.engine.abstract_processor as abstract_processor import cirq_google.engine.abstract_program as abstract_program class MockJob(AbstractJob): - def engine(self) -> 'abstract_engine.AbstractEngine': + def engine(self) -> 'abstract_engine.AbstractEngine': # type: ignore[empty-body] pass - def id(self) -> str: + def id(self) -> str: # type: ignore[empty-body] pass - def program(self) -> 'abstract_program.AbstractProgram': + def program(self) -> 'abstract_program.AbstractProgram': # type: ignore[empty-body] pass - def create_time(self) -> 'datetime.datetime': + def create_time(self) -> 'datetime.datetime': # type: ignore[empty-body] pass - def update_time(self) -> 'datetime.datetime': + def update_time(self) -> 'datetime.datetime': # type: ignore[empty-body] pass - def description(self) -> str: + def description(self) -> str: # type: ignore[empty-body] pass - def set_description(self, description: str) -> 'AbstractJob': + def set_description(self, description: str) -> 'AbstractJob': # type: ignore[empty-body] pass - def labels(self) -> Dict[str, str]: + def labels(self) -> Dict[str, str]: # type: ignore[empty-body] pass - def set_labels(self, labels: Dict[str, str]) -> 'AbstractJob': + def set_labels(self, labels: Dict[str, str]) -> 'AbstractJob': # type: ignore[empty-body] pass - def add_labels(self, labels: Dict[str, str]) -> 'AbstractJob': + def add_labels(self, labels: Dict[str, str]) -> 'AbstractJob': # type: ignore[empty-body] pass - def remove_labels(self, keys: List[str]) -> 'AbstractJob': + def remove_labels(self, keys: List[str]) -> 'AbstractJob': # type: ignore[empty-body] pass def processor_ids(self): diff --git a/cirq-google/cirq_google/engine/abstract_processor.py b/cirq-google/cirq_google/engine/abstract_processor.py index 07f58c7b651..fb1006cd68d 100644 --- a/cirq-google/cirq_google/engine/abstract_processor.py +++ b/cirq-google/cirq_google/engine/abstract_processor.py @@ -58,7 +58,7 @@ async def run_async( program: cirq.Circuit, program_id: Optional[str] = None, job_id: Optional[str] = None, - param_resolver: cirq.ParamResolver = None, + param_resolver: Optional[cirq.ParamResolver] = None, repetitions: int = 1, program_description: Optional[str] = None, program_labels: Optional[Dict[str, str]] = None, @@ -151,7 +151,7 @@ async def run_batch_async( programs: Sequence[cirq.AbstractCircuit], program_id: Optional[str] = None, job_id: Optional[str] = None, - params_list: Sequence[cirq.Sweepable] = None, + params_list: Optional[Sequence[cirq.Sweepable]] = None, repetitions: int = 1, program_description: Optional[str] = None, program_labels: Optional[Dict[str, str]] = None, @@ -363,9 +363,9 @@ def get_reservation(self, reservation_id: str) -> Optional[quantum.QuantumReserv def update_reservation( self, reservation_id: str, - start_time: datetime.datetime = None, - end_time: datetime.datetime = None, - whitelisted_users: List[str] = None, + start_time: Optional[datetime.datetime] = None, + end_time: Optional[datetime.datetime] = None, + whitelisted_users: Optional[List[str]] = None, ): """Updates a reservation with new information. diff --git a/cirq-google/cirq_google/engine/engine.py b/cirq-google/cirq_google/engine/engine.py index bd884797b4d..6004e877be2 100644 --- a/cirq-google/cirq_google/engine/engine.py +++ b/cirq-google/cirq_google/engine/engine.py @@ -331,7 +331,7 @@ async def run_batch_async( programs: Sequence[cirq.AbstractCircuit], program_id: Optional[str] = None, job_id: Optional[str] = None, - params_list: List[cirq.Sweepable] = None, + params_list: Optional[List[cirq.Sweepable]] = None, repetitions: int = 1, processor_ids: Sequence[str] = (), program_description: Optional[str] = None, @@ -411,7 +411,7 @@ async def run_calibration_async( layers: List['cirq_google.CalibrationLayer'], program_id: Optional[str] = None, job_id: Optional[str] = None, - processor_id: str = None, + processor_id: Optional[str] = None, processor_ids: Sequence[str] = (), program_description: Optional[str] = None, program_labels: Optional[Dict[str, str]] = None, diff --git a/cirq-google/cirq_google/engine/engine_processor.py b/cirq-google/cirq_google/engine/engine_processor.py index eeecc91f73f..9a04061f126 100644 --- a/cirq-google/cirq_google/engine/engine_processor.py +++ b/cirq-google/cirq_google/engine/engine_processor.py @@ -116,7 +116,7 @@ async def run_batch_async( programs: Sequence[cirq.AbstractCircuit], program_id: Optional[str] = None, job_id: Optional[str] = None, - params_list: Sequence[cirq.Sweepable] = None, + params_list: Optional[Sequence[cirq.Sweepable]] = None, repetitions: int = 1, program_description: Optional[str] = None, program_labels: Optional[Dict[str, str]] = None, @@ -472,9 +472,9 @@ def get_reservation(self, reservation_id: str) -> Optional[quantum.QuantumReserv def update_reservation( self, reservation_id: str, - start_time: datetime.datetime = None, - end_time: datetime.datetime = None, - whitelisted_users: List[str] = None, + start_time: Optional[datetime.datetime] = None, + end_time: Optional[datetime.datetime] = None, + whitelisted_users: Optional[List[str]] = None, ): """Updates a reservation with new information. diff --git a/cirq-google/cirq_google/engine/engine_program.py b/cirq-google/cirq_google/engine/engine_program.py index e0dcc06a6e9..d1ff870337d 100644 --- a/cirq-google/cirq_google/engine/engine_program.py +++ b/cirq-google/cirq_google/engine/engine_program.py @@ -124,7 +124,7 @@ async def run_sweep_async( async def run_batch_async( self, job_id: Optional[str] = None, - params_list: List[cirq.Sweepable] = None, + params_list: Optional[List[cirq.Sweepable]] = None, repetitions: int = 1, processor_ids: Sequence[str] = (), description: Optional[str] = None, diff --git a/cirq-google/cirq_google/engine/simulated_local_job.py b/cirq-google/cirq_google/engine/simulated_local_job.py index cc1c20415b6..e8d58838edd 100644 --- a/cirq-google/cirq_google/engine/simulated_local_job.py +++ b/cirq-google/cirq_google/engine/simulated_local_job.py @@ -35,7 +35,7 @@ def _to_engine_results( batch_results: Sequence[Sequence['cirq.Result']], *, job_id: str, - job_finished_time: datetime.datetime = None, + job_finished_time: Optional[datetime.datetime] = None, ) -> List[List[EngineResult]]: """Convert cirq.Result from simulators into (simulated) EngineResults.""" @@ -73,7 +73,7 @@ class SimulatedLocalJob(AbstractLocalJob): def __init__( self, *args, - sampler: cirq.Sampler = None, + sampler: Optional[cirq.Sampler] = None, simulation_type: LocalSimulationType = LocalSimulationType.SYNCHRONOUS, **kwargs, ): diff --git a/cirq-google/cirq_google/engine/simulated_local_processor.py b/cirq-google/cirq_google/engine/simulated_local_processor.py index 83121a53c6f..48055c17d51 100644 --- a/cirq-google/cirq_google/engine/simulated_local_processor.py +++ b/cirq-google/cirq_google/engine/simulated_local_processor.py @@ -13,7 +13,7 @@ # limitations under the License. import datetime -from typing import Dict, List, Optional, Sequence, TYPE_CHECKING, Union +from typing import Dict, List, Optional, Sequence, Union import cirq @@ -29,10 +29,6 @@ from cirq_google.engine.processor_sampler import ProcessorSampler from cirq_google.engine import engine_validator -if TYPE_CHECKING: - import cirq_google as cg - from cirq_google.serialization.serializer import Serializer - VALID_LANGUAGES = [ 'type.googleapis.com/cirq.google.api.v2.Program', 'type.googleapis.com/cirq.google.api.v2.BatchProgram', @@ -95,8 +91,8 @@ def __init__( *args, sampler: cirq.Sampler = cirq.Simulator(), device: cirq.Device = cirq.UNCONSTRAINED_DEVICE, - validator: validating_sampler.VALIDATOR_TYPE = None, - program_validator: engine_validator.PROGRAM_VALIDATOR_TYPE = None, + validator: Optional[validating_sampler.VALIDATOR_TYPE] = None, + program_validator: Optional[engine_validator.PROGRAM_VALIDATOR_TYPE] = None, simulation_type: LocalSimulationType = LocalSimulationType.SYNCHRONOUS, calibrations: Optional[Dict[int, calibration.Calibration]] = None, device_specification: Optional[v2.device_pb2.DeviceSpecification] = None, @@ -206,7 +202,7 @@ async def run_batch_async( programs: Sequence[cirq.AbstractCircuit], program_id: Optional[str] = None, job_id: Optional[str] = None, - params_list: Sequence[cirq.Sweepable] = None, + params_list: Optional[Sequence[cirq.Sweepable]] = None, repetitions: int = 1, program_description: Optional[str] = None, program_labels: Optional[Dict[str, str]] = None, diff --git a/cirq-google/cirq_google/engine/virtual_engine_factory.py b/cirq-google/cirq_google/engine/virtual_engine_factory.py index f927aaebb80..fcb1a168c76 100644 --- a/cirq-google/cirq_google/engine/virtual_engine_factory.py +++ b/cirq-google/cirq_google/engine/virtual_engine_factory.py @@ -384,7 +384,7 @@ def create_noiseless_virtual_engine_from_latest_templates() -> SimulatedLocalEng def create_default_noisy_quantum_virtual_machine( - processor_id: str, simulator_class: Type[SimulatesSamples] = None, **kwargs + processor_id: str, simulator_class: Optional[Type[SimulatesSamples]] = None, **kwargs ) -> SimulatedLocalEngine: """Creates a virtual engine with a noisy simulator based on a processor id. diff --git a/cirq-google/cirq_google/experimental/noise_models/noise_models.py b/cirq-google/cirq_google/experimental/noise_models/noise_models.py index f5b13f4edac..bac457e3821 100644 --- a/cirq-google/cirq_google/experimental/noise_models/noise_models.py +++ b/cirq-google/cirq_google/experimental/noise_models/noise_models.py @@ -13,7 +13,7 @@ # limitations under the License. from math import exp -from typing import Dict, Sequence, TYPE_CHECKING +from typing import Dict, Optional, Sequence, TYPE_CHECKING import cirq from cirq.devices.noise_model import validate_all_measurements @@ -35,9 +35,9 @@ class PerQubitDepolarizingWithDampedReadoutNoiseModel(cirq.NoiseModel): def __init__( self, - depol_probs: Dict[cirq.Qid, float] = None, - bitflip_probs: Dict[cirq.Qid, float] = None, - decay_probs: Dict[cirq.Qid, float] = None, + depol_probs: Optional[Dict[cirq.Qid, float]] = None, + bitflip_probs: Optional[Dict[cirq.Qid, float]] = None, + decay_probs: Optional[Dict[cirq.Qid, float]] = None, ): """A depolarizing noise model with damped readout error. diff --git a/cirq-google/cirq_google/line/placement/anneal.py b/cirq-google/cirq_google/line/placement/anneal.py index 78591b5f5d8..b2ed8e9d3c0 100644 --- a/cirq-google/cirq_google/line/placement/anneal.py +++ b/cirq-google/cirq_google/line/placement/anneal.py @@ -42,7 +42,10 @@ def __init__(self, device: 'cirq_google.GridDevice', seed=None) -> None: self._rand = np.random.RandomState(seed) def search( - self, trace_func: Callable[[List[LineSequence], float, float, float, bool], None] = None + self, + trace_func: Optional[ + Callable[[List[LineSequence], float, float, float, bool], None] + ] = None, ) -> List[LineSequence]: """Issues new linear sequence search. @@ -329,8 +332,10 @@ class AnnealSequenceSearchStrategy(place_strategy.LinePlacementStrategy): def __init__( self, - trace_func: Callable[[List[LineSequence], float, float, float, bool], None] = None, - seed: int = None, + trace_func: Optional[ + Callable[[List[LineSequence], float, float, float, bool], None] + ] = None, + seed: Optional[int] = None, ) -> None: """Linearized sequence search using simulated annealing method. diff --git a/cirq-google/cirq_google/line/placement/optimization.py b/cirq-google/cirq_google/line/placement/optimization.py index 50908d11973..9e16dafd049 100644 --- a/cirq-google/cirq_google/line/placement/optimization.py +++ b/cirq-google/cirq_google/line/placement/optimization.py @@ -14,7 +14,7 @@ import math -from typing import Callable, Tuple, TypeVar +from typing import Callable, Optional, Tuple, TypeVar T = TypeVar('T') @@ -51,7 +51,7 @@ def anneal_minimize( temp_final: float = 1e-6, cooling_factor: float = 0.99, repeat: int = 100, - trace_func: Callable[[T, float, float, float, bool], None] = None, + trace_func: Optional[Callable[[T, float, float, float, bool], None]] = None, ) -> T: """Minimize solution using Simulated Annealing meta-heuristic. diff --git a/cirq-google/cirq_google/serialization/circuit_serializer.py b/cirq-google/cirq_google/serialization/circuit_serializer.py index 589e76ec753..fc1e15dff51 100644 --- a/cirq-google/cirq_google/serialization/circuit_serializer.py +++ b/cirq-google/cirq_google/serialization/circuit_serializer.py @@ -591,8 +591,8 @@ def _deserialize_circuit_op( operation_proto: v2.program_pb2.CircuitOperation, *, arg_function_language: str = '', - constants: Optional[List[v2.program_pb2.Constant]] = None, - deserialized_constants: Optional[List[Any]] = None, + constants: List[v2.program_pb2.Constant], + deserialized_constants: List[Any], ) -> cirq.CircuitOperation: """Deserialize a CircuitOperation from a cirq.google.api.v2.CircuitOperation. diff --git a/cirq-google/cirq_google/serialization/op_deserializer.py b/cirq-google/cirq_google/serialization/op_deserializer.py index 32c67469bfe..e682712a189 100644 --- a/cirq-google/cirq_google/serialization/op_deserializer.py +++ b/cirq-google/cirq_google/serialization/op_deserializer.py @@ -45,8 +45,8 @@ def from_proto( proto, *, arg_function_language: str = '', - constants: List[v2.program_pb2.Constant] = None, - deserialized_constants: List[Any] = None, + constants: List[v2.program_pb2.Constant], + deserialized_constants: List[Any], ) -> cirq.Operation: """Converts a proto-formatted operation into a Cirq operation. @@ -75,8 +75,8 @@ def from_proto( proto: v2.program_pb2.CircuitOperation, *, arg_function_language: str = '', - constants: List[v2.program_pb2.Constant] = None, - deserialized_constants: List[Any] = None, + constants: List[v2.program_pb2.Constant], + deserialized_constants: List[Any], ) -> cirq.CircuitOperation: """Turns a cirq.google.api.v2.CircuitOperation proto into a CircuitOperation. @@ -95,11 +95,6 @@ def from_proto( Raises: ValueError: If the circuit operatio proto cannot be deserialied because it is malformed. """ - if constants is None or deserialized_constants is None: - raise ValueError( - 'CircuitOp deserialization requires a constants list and a corresponding list of ' - 'post-deserialization values (deserialized_constants).' - ) if len(deserialized_constants) <= proto.circuit_constant_index: raise ValueError( f'Constant index {proto.circuit_constant_index} in CircuitOperation ' diff --git a/cirq-google/cirq_google/serialization/op_deserializer_test.py b/cirq-google/cirq_google/serialization/op_deserializer_test.py index 738ec62d446..d1a7f4aedd2 100644 --- a/cirq-google/cirq_google/serialization/op_deserializer_test.py +++ b/cirq-google/cirq_google/serialization/op_deserializer_test.py @@ -57,16 +57,6 @@ def test_circuit_op_from_proto_errors(): v2.program_pb2.Constant(string_value=DEFAULT_TOKEN), v2.program_pb2.Constant(circuit_value=default_circuit_proto()), ] - deserialized_constants = [DEFAULT_TOKEN, default_circuit()] - - with pytest.raises(ValueError, match='CircuitOp deserialization requires a constants list'): - deserializer.from_proto(serialized) - - with pytest.raises(ValueError, match='CircuitOp deserialization requires a constants list'): - deserializer.from_proto(serialized, constants=constants) - - with pytest.raises(ValueError, match='CircuitOp deserialization requires a constants list'): - deserializer.from_proto(serialized, deserialized_constants=deserialized_constants) bad_deserialized_constants = [DEFAULT_TOKEN] with pytest.raises(ValueError, match='does not appear in the deserialized_constants list'): diff --git a/cirq-google/cirq_google/serialization/op_serializer.py b/cirq-google/cirq_google/serialization/op_serializer.py index fb5c5ee758a..550577c1633 100644 --- a/cirq-google/cirq_google/serialization/op_serializer.py +++ b/cirq-google/cirq_google/serialization/op_serializer.py @@ -61,8 +61,8 @@ def to_proto( msg=None, *, arg_function_language: Optional[str] = '', - constants: List[v2.program_pb2.Constant] = None, - raw_constants: Dict[Any, int] = None, + constants: List[v2.program_pb2.Constant], + raw_constants: Dict[Any, int], ) -> Optional[v2.program_pb2.CircuitOperation]: """Converts op to proto using this serializer. @@ -117,20 +117,14 @@ def to_proto( msg: Optional[v2.program_pb2.CircuitOperation] = None, *, arg_function_language: Optional[str] = '', - constants: List[v2.program_pb2.Constant] = None, - raw_constants: Dict[Any, int] = None, + constants: List[v2.program_pb2.Constant], + raw_constants: Dict[Any, int], ) -> v2.program_pb2.CircuitOperation: """Returns the cirq.google.api.v2.CircuitOperation message as a proto dict. Note that this function requires constants and raw_constants to be pre-populated with the circuit in op. """ - if constants is None or raw_constants is None: - raise ValueError( - 'CircuitOp serialization requires a constants list and a corresponding list of ' - 'pre-serialization values (raw_constants).' - ) - if not isinstance(op, cirq.CircuitOperation): raise ValueError(f'Serializer expected CircuitOperation but got {type(op)}.') diff --git a/cirq-google/cirq_google/serialization/op_serializer_test.py b/cirq-google/cirq_google/serialization/op_serializer_test.py index 028a5aae135..0faf4fffe42 100644 --- a/cirq-google/cirq_google/serialization/op_serializer_test.py +++ b/cirq-google/cirq_google/serialization/op_serializer_test.py @@ -71,15 +71,6 @@ def test_circuit_op_to_proto_errors(): ] raw_constants = {DEFAULT_TOKEN: 0, default_circuit(): 1} - with pytest.raises(ValueError, match='CircuitOp serialization requires a constants list'): - serializer.to_proto(to_serialize) - - with pytest.raises(ValueError, match='CircuitOp serialization requires a constants list'): - serializer.to_proto(to_serialize, constants=constants) - - with pytest.raises(ValueError, match='CircuitOp serialization requires a constants list'): - serializer.to_proto(to_serialize, raw_constants=raw_constants) - with pytest.raises(ValueError, match='Serializer expected CircuitOperation'): serializer.to_proto( v2.program_pb2.Operation(), constants=constants, raw_constants=raw_constants diff --git a/cirq-google/cirq_google/serialization/serializer.py b/cirq-google/cirq_google/serialization/serializer.py index 12beccf8af4..226a86d5ad2 100644 --- a/cirq-google/cirq_google/serialization/serializer.py +++ b/cirq-google/cirq_google/serialization/serializer.py @@ -48,6 +48,7 @@ def serialize( `Program.Language`. """ + @abc.abstractmethod def deserialize(self, proto: v2.program_pb2.Program) -> cirq.Circuit: """Deserialize a Circuit from a cirq_google.api.v2.Program. diff --git a/cirq-google/cirq_google/workflow/io_test.py b/cirq-google/cirq_google/workflow/io_test.py index 206b743adb0..6727f436b87 100644 --- a/cirq-google/cirq_google/workflow/io_test.py +++ b/cirq-google/cirq_google/workflow/io_test.py @@ -73,7 +73,7 @@ def test_egr_filesystem_record_from_json(tmpdir): ) -def test_filesystem_saver(tmpdir): +def test_filesystem_saver(tmpdir) -> None: run_id = 'asdf' fs_saver = _FilesystemSaver(base_data_dir=tmpdir, run_id=run_id) diff --git a/cirq-google/cirq_google/workflow/quantum_runtime_test.py b/cirq-google/cirq_google/workflow/quantum_runtime_test.py index 59a8de63607..9b35fc5085a 100644 --- a/cirq-google/cirq_google/workflow/quantum_runtime_test.py +++ b/cirq-google/cirq_google/workflow/quantum_runtime_test.py @@ -176,7 +176,7 @@ def _load_result_by_hand(tmpdir: str, run_id: str) -> cg.ExecutableGroupResult: ) -def test_execute(tmpdir, rt_config): +def test_execute(tmpdir, rt_config) -> None: executable_group = cg.QuantumExecutableGroup(_get_quantum_executables()) returned_exegroup_result = cg.execute( rt_config=rt_config, executable_group=executable_group, base_data_dir=tmpdir @@ -189,6 +189,8 @@ def test_execute(tmpdir, rt_config): start_dt = returned_exegroup_result.shared_runtime_info.run_start_time end_dt = returned_exegroup_result.shared_runtime_info.run_end_time + assert start_dt is not None + assert end_dt is not None assert end_dt > start_dt assert end_dt <= datetime.datetime.now(tz=datetime.timezone.utc) diff --git a/cirq-google/cirq_google/workflow/qubit_placement.py b/cirq-google/cirq_google/workflow/qubit_placement.py index 819d7afaefa..800bf67fe4c 100644 --- a/cirq-google/cirq_google/workflow/qubit_placement.py +++ b/cirq-google/cirq_google/workflow/qubit_placement.py @@ -187,7 +187,7 @@ def _json_dict_(self): return d @classmethod - def _from_json_dict_(cls, **kwargs): + def _from_json_dict_(cls, **kwargs) -> 'HardcodedQubitPlacer': # From nested list(key_value_pair) to dictionary mapping: Dict[cirq.NamedTopology, Dict[Any, 'cirq.Qid']] = {} for topo, placement_kvs in kwargs['mapping']: diff --git a/cirq-ionq/cirq_ionq/ionq_client.py b/cirq-ionq/cirq_ionq/ionq_client.py index 46b6cc68fa2..2cc43124c37 100644 --- a/cirq-ionq/cirq_ionq/ionq_client.py +++ b/cirq-ionq/cirq_ionq/ionq_client.py @@ -235,8 +235,8 @@ def request(): def list_calibrations( self, - start: datetime.datetime = None, - end: datetime.datetime = None, + start: Optional[datetime.datetime] = None, + end: Optional[datetime.datetime] = None, limit: int = 100, batch_size: int = 1000, ) -> List[dict]: diff --git a/cirq-ionq/cirq_ionq/ionq_exceptions.py b/cirq-ionq/cirq_ionq/ionq_exceptions.py index 3a5ffefb61a..1078bcc3550 100644 --- a/cirq-ionq/cirq_ionq/ionq_exceptions.py +++ b/cirq-ionq/cirq_ionq/ionq_exceptions.py @@ -13,6 +13,8 @@ # limitations under the License. """Exceptions for the IonQ API.""" +from typing import Optional + import requests @@ -23,7 +25,7 @@ class IonQException(Exception): status_code: A http status code, if coming from an http response with a failing status. """ - def __init__(self, message, status_code: int = None): + def __init__(self, message, status_code: Optional[int] = None): super().__init__(f'Status code: {status_code}, Message: \'{message}\'') self.status_code = status_code diff --git a/cirq-ionq/cirq_ionq/results.py b/cirq-ionq/cirq_ionq/results.py index 6d5bbc09520..0ad909d830a 100644 --- a/cirq-ionq/cirq_ionq/results.py +++ b/cirq-ionq/cirq_ionq/results.py @@ -229,7 +229,7 @@ def measurement_dict(self) -> Dict[str, Sequence[int]]: def to_cirq_result( self, - params: cirq.ParamResolver = None, + params: Optional[cirq.ParamResolver] = None, seed: cirq.RANDOM_STATE_OR_SEED_LIKE = None, override_repetitions=None, ) -> cirq.Result: diff --git a/cirq-ionq/cirq_ionq/service.py b/cirq-ionq/cirq_ionq/service.py index da269e051c6..1a052e2d96d 100644 --- a/cirq-ionq/cirq_ionq/service.py +++ b/cirq-ionq/cirq_ionq/service.py @@ -34,7 +34,7 @@ def __init__( self, remote_host: Optional[str] = None, api_key: Optional[str] = None, - default_target: str = None, + default_target: Optional[str] = None, api_version='v0.1', max_retry_seconds: int = 3600, verbose=False, @@ -212,8 +212,8 @@ def get_current_calibration(self) -> calibration.Calibration: def list_calibrations( self, - start: datetime.datetime = None, - end: datetime.datetime = None, + start: Optional[datetime.datetime] = None, + end: Optional[datetime.datetime] = None, limit: int = 100, batch_size: int = 1000, ) -> Sequence[calibration.Calibration]: diff --git a/cirq-pasqal/cirq_pasqal/pasqal_sampler.py b/cirq-pasqal/cirq_pasqal/pasqal_sampler.py index 9ed49ec6fc1..e22c6713d6c 100644 --- a/cirq-pasqal/cirq_pasqal/pasqal_sampler.py +++ b/cirq-pasqal/cirq_pasqal/pasqal_sampler.py @@ -11,7 +11,7 @@ # 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 List +from typing import List, Optional import time import requests @@ -22,7 +22,10 @@ class PasqalSampler(cirq.work.Sampler): def __init__( - self, remote_host: str, access_token: str = '', device: cirq_pasqal.PasqalDevice = None + self, + remote_host: str, + access_token: str = '', + device: Optional[cirq_pasqal.PasqalDevice] = None, ) -> None: """Inits PasqalSampler. diff --git a/cirq-rigetti/cirq_rigetti/conftest.py b/cirq-rigetti/cirq_rigetti/conftest.py index b7e97788d78..1fa6ce3a5ce 100644 --- a/cirq-rigetti/cirq_rigetti/conftest.py +++ b/cirq-rigetti/cirq_rigetti/conftest.py @@ -63,7 +63,7 @@ def __init__(self, *args, **kwargs) -> None: self._run_count = 0 self._mock_results: Dict[str, np.ndarray] = {} - def execute(self, executable: QuantumExecutable) -> T: + def execute(self, executable: QuantumExecutable) -> T: # type: ignore[empty-body] pass def run(self, program: QuantumExecutable) -> QAMExecutionResult: diff --git a/cirq-web/cirq_web/bloch_sphere/bloch_sphere.py b/cirq-web/cirq_web/bloch_sphere/bloch_sphere.py index 246fba65b0f..43b4db4e9fd 100644 --- a/cirq-web/cirq_web/bloch_sphere/bloch_sphere.py +++ b/cirq-web/cirq_web/bloch_sphere/bloch_sphere.py @@ -11,13 +11,18 @@ # 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 Optional + import cirq from cirq_web import widget class BlochSphere(widget.Widget): - def __init__(self, sphere_radius: int = 5, state_vector: cirq.STATE_VECTOR_LIKE = None): + def __init__( + self, sphere_radius: int = 5, state_vector: Optional[cirq.STATE_VECTOR_LIKE] = None + ): """Initializes a BlochSphere. Also initializes it's parent class Widget with the bundle file provided. diff --git a/dev_tools/env_tools.py b/dev_tools/env_tools.py index ffa10e592ef..53eb896078f 100644 --- a/dev_tools/env_tools.py +++ b/dev_tools/env_tools.py @@ -67,7 +67,7 @@ def prepare_temporary_test_environment( verbose: bool, env_name: str = '.test_virtualenv', python_path: str = sys.executable, - commit_ids_known_callback: Callable[[PreparedEnv], None] = None, + commit_ids_known_callback: Optional[Callable[[PreparedEnv], None]] = None, ) -> PreparedEnv: """Prepares a temporary test environment at the (existing empty) directory. diff --git a/dev_tools/modules_test.py b/dev_tools/modules_test.py index 60760c46246..12718e9977a 100644 --- a/dev_tools/modules_test.py +++ b/dev_tools/modules_test.py @@ -19,7 +19,7 @@ import tempfile from io import StringIO from pathlib import Path -from typing import Generator +from typing import Iterator, Optional from unittest import mock import pytest @@ -81,7 +81,7 @@ def test_cli(): @contextlib.contextmanager -def chdir(*, target_dir: str = None, clone_dir: str = None) -> Generator[None, None, None]: +def chdir(*, target_dir: Optional[str] = None, clone_dir: Optional[str] = None) -> Iterator[None]: """Changes for the duration of the test the working directory. Args: diff --git a/dev_tools/pr_monitor.py b/dev_tools/pr_monitor.py index 59bdbc04dd1..f7257ecd113 100644 --- a/dev_tools/pr_monitor.py +++ b/dev_tools/pr_monitor.py @@ -1171,7 +1171,7 @@ def indent(text: str) -> str: return ' ' + text.replace('\n', '\n ') -def main(): +def main() -> None: access_token = os.getenv(ACCESS_TOKEN_ENV_VARIABLE) if not access_token: project_id = 'cirq-infra' diff --git a/dev_tools/requirements/deps/mypy.txt b/dev_tools/requirements/deps/mypy.txt index ba2c2b3fbdc..ee6380ae7e5 100644 --- a/dev_tools/requirements/deps/mypy.txt +++ b/dev_tools/requirements/deps/mypy.txt @@ -1,5 +1,5 @@ # the mypy dependency file -mypy==0.961.0 +mypy==1.2.0 # packages with stub types for various libraries types-backports==0.1.3 diff --git a/dev_tools/snippets_test.py b/dev_tools/snippets_test.py index 8e792fcbf72..9b6aec48a56 100644 --- a/dev_tools/snippets_test.py +++ b/dev_tools/snippets_test.py @@ -55,7 +55,7 @@ """ import inspect import sys -from typing import Any, Dict, List, Pattern, Tuple, Iterator +from typing import Any, Dict, List, Optional, Pattern, Tuple, Iterator import os import pathlib @@ -462,7 +462,9 @@ def test_canonicalize_printed_line(): assert canonicalize_printed_line(a) == canonicalize_printed_line(b) -def assert_code_snippet_executes_correctly(snippet: str, state: Dict, line_number: int = None): +def assert_code_snippet_executes_correctly( + snippet: str, state: Dict, line_number: Optional[int] = None +): """Executes a snippet and compares output / errors to annotations.""" raises_annotation = re.search(r"# raises\s*(\S*)", snippet) @@ -484,7 +486,7 @@ def assert_code_snippet_executes_correctly(snippet: str, state: Dict, line_numbe def assert_code_snippet_runs_and_prints_expected( - snippet: str, state: Dict, line_number: int = None + snippet: str, state: Dict, line_number: Optional[int] = None ): """Executes a snippet and compares captured output to annotated output.""" output_lines: List[str] = []