From db5cdf8dca3f3536647fe10469e193560bf193bd Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Fri, 17 Feb 2023 11:02:43 -0600 Subject: [PATCH 01/10] Store deprecation metadata on functions for docs generation --- qiskit/utils/deprecation.py | 85 ++++++++++++++++++++++++++++--------- 1 file changed, 65 insertions(+), 20 deletions(-) diff --git a/qiskit/utils/deprecation.py b/qiskit/utils/deprecation.py index 633c2472288d..77fdf29d8b5c 100644 --- a/qiskit/utils/deprecation.py +++ b/qiskit/utils/deprecation.py @@ -14,17 +14,18 @@ import functools import warnings -from typing import Type +from dataclasses import dataclass +from typing import Callable, ClassVar, Dict, Optional, Type, cast, Any -def deprecate_arguments(kwarg_map, category: Type[Warning] = DeprecationWarning): +def deprecate_arguments(kwarg_map: Dict[str, str], category: Type[Warning] = DeprecationWarning): """Decorator to automatically alias deprecated argument names and warn upon use.""" def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): if kwargs: - _rename_kwargs(func.__name__, kwargs, kwarg_map, category) + _rename_kwargs(func, kwargs, kwarg_map, category) return func(*args, **kwargs) return wrapper @@ -37,7 +38,7 @@ def deprecate_function(msg: str, stacklevel: int = 2, category: Type[Warning] = Args: msg: Warning message to emit. - stacklevel: The warning stackevel to use, defaults to 2. + stacklevel: The warning stacklevel to use, defaults to 2. category: warning category, defaults to DeprecationWarning Returns: @@ -50,30 +51,74 @@ def wrapper(*args, **kwargs): warnings.warn(msg, category=category, stacklevel=stacklevel) return func(*args, **kwargs) + _DeprecationMetadata.set_func_deprecation(func, msg=msg, since="TODO") return wrapper return decorator -def _rename_kwargs(func_name, kwargs, kwarg_map, category: Type[Warning] = DeprecationWarning): +def _rename_kwargs( + func: Callable, + kwargs: Dict[str, Any], + kwarg_map: Dict[str, str], + category: Type[Warning] = DeprecationWarning, +) -> None: + func_name = func.__name__ for old_arg, new_arg in kwarg_map.items(): + if new_arg is None: + msg = ( + f"{func_name} keyword argument {old_arg} is deprecated and " + "will in the future be removed." + ) + else: + msg = ( + f"{func_name} keyword argument {old_arg} is deprecated and " + f"replaced with {new_arg}." + ) + _DeprecationMetadata.set_args_deprecation(func, arg=old_arg, msg=msg, since="TODO") if old_arg in kwargs: if new_arg in kwargs: raise TypeError(f"{func_name} received both {new_arg} and {old_arg} (deprecated).") + warnings.warn(msg, category=category, stacklevel=3) + if new_arg is not None: + kwargs[new_arg] = kwargs.pop(old_arg) - if new_arg is None: - warnings.warn( - f"{func_name} keyword argument {old_arg} is deprecated and " - "will in future be removed.", - category=category, - stacklevel=3, - ) - else: - warnings.warn( - f"{func_name} keyword argument {old_arg} is deprecated and " - f"replaced with {new_arg}.", - category=category, - stacklevel=3, - ) - kwargs[new_arg] = kwargs.pop(old_arg) +@dataclass(frozen=True) +class _DeprecationMetadataEntry: + msg: str + since: str + + +@dataclass +class _DeprecationMetadata: + """Used to store deprecation information on a function. + + This is used by the Qiskit Sphinx Theme to render deprecations in documentation. Warning: + coordinate changes with the Sphinx Theme's extension. + """ + + func_deprecation: Optional[_DeprecationMetadataEntry] + args_deprecations: Dict[str, _DeprecationMetadataEntry] + + dunder_name: ClassVar[str] = "__qiskit_deprecation__" + + @classmethod + def set_func_deprecation(cls, func: Callable, *, msg: str, since: str) -> None: + entry = _DeprecationMetadataEntry(msg, since) + if hasattr(func, cls.dunder_name): + metadata = cast(_DeprecationMetadata, getattr(func, cls.dunder_name)) + metadata.func_deprecation = entry + else: + metadata = cls(func_deprecation=entry, args_deprecations={}) + setattr(func, cls.dunder_name, metadata) + + @classmethod + def set_args_deprecation(cls, func: Callable, *, arg: str, msg: str, since: str) -> None: + entry = _DeprecationMetadataEntry(msg, since) + if hasattr(func, cls.dunder_name): + metadata = cast(_DeprecationMetadata, getattr(func, cls.dunder_name)) + metadata.args_deprecations[arg] = entry + else: + metadata = cls(func_deprecation=None, args_deprecations={arg: entry}) + setattr(func, cls.dunder_name, metadata) From 718f562a2020df4003fea83c13f327a2cb8ea259 Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Fri, 17 Feb 2023 14:54:56 -0600 Subject: [PATCH 02/10] Store whether it's a pending deprecation --- qiskit/utils/deprecation.py | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/qiskit/utils/deprecation.py b/qiskit/utils/deprecation.py index 77fdf29d8b5c..29ab9838c2b7 100644 --- a/qiskit/utils/deprecation.py +++ b/qiskit/utils/deprecation.py @@ -51,7 +51,9 @@ def wrapper(*args, **kwargs): warnings.warn(msg, category=category, stacklevel=stacklevel) return func(*args, **kwargs) - _DeprecationMetadata.set_func_deprecation(func, msg=msg, since="TODO") + _DeprecationMetadata.set_func_deprecation( + func, msg=msg, since="TODO", pending=isinstance(category, PendingDeprecationWarning) + ) return wrapper return decorator @@ -75,7 +77,13 @@ def _rename_kwargs( f"{func_name} keyword argument {old_arg} is deprecated and " f"replaced with {new_arg}." ) - _DeprecationMetadata.set_args_deprecation(func, arg=old_arg, msg=msg, since="TODO") + _DeprecationMetadata.set_args_deprecation( + func, + arg=old_arg, + msg=msg, + since="TODO", + pending=isinstance(category, PendingDeprecationWarning), + ) if old_arg in kwargs: if new_arg in kwargs: raise TypeError(f"{func_name} received both {new_arg} and {old_arg} (deprecated).") @@ -88,6 +96,7 @@ def _rename_kwargs( class _DeprecationMetadataEntry: msg: str since: str + pending: bool @dataclass @@ -95,7 +104,7 @@ class _DeprecationMetadata: """Used to store deprecation information on a function. This is used by the Qiskit Sphinx Theme to render deprecations in documentation. Warning: - coordinate changes with the Sphinx Theme's extension. + changes may accidentally break the Sphinx Theme; pay attention to backwards compatibility. """ func_deprecation: Optional[_DeprecationMetadataEntry] @@ -104,8 +113,9 @@ class _DeprecationMetadata: dunder_name: ClassVar[str] = "__qiskit_deprecation__" @classmethod - def set_func_deprecation(cls, func: Callable, *, msg: str, since: str) -> None: - entry = _DeprecationMetadataEntry(msg, since) + def set_func_deprecation(cls, func: Callable, *, msg: str, since: str, pending: bool) -> None: + """Add or modify `__qiskit_deprecation__` to set `func_deprecation`.""" + entry = _DeprecationMetadataEntry(msg, since, pending) if hasattr(func, cls.dunder_name): metadata = cast(_DeprecationMetadata, getattr(func, cls.dunder_name)) metadata.func_deprecation = entry @@ -114,8 +124,11 @@ def set_func_deprecation(cls, func: Callable, *, msg: str, since: str) -> None: setattr(func, cls.dunder_name, metadata) @classmethod - def set_args_deprecation(cls, func: Callable, *, arg: str, msg: str, since: str) -> None: - entry = _DeprecationMetadataEntry(msg, since) + def set_args_deprecation( + cls, func: Callable, *, arg: str, msg: str, since: str, pending: bool + ) -> None: + """Add or modify `__qiskit_deprecation__` to set `args_deprecations` for `arg`.""" + entry = _DeprecationMetadataEntry(msg, since, pending) if hasattr(func, cls.dunder_name): metadata = cast(_DeprecationMetadata, getattr(func, cls.dunder_name)) metadata.args_deprecations[arg] = entry From 4ab0875737b688cbfa8831bd49819a399eb7a8c6 Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Thu, 23 Feb 2023 15:18:21 -0600 Subject: [PATCH 03/10] Redesign to list format, add tests, and fix wrapping wrong function --- qiskit/utils/deprecation.py | 103 ++++++++++---------------- test/python/utils/test_deprecation.py | 40 ++++++++++ 2 files changed, 79 insertions(+), 64 deletions(-) create mode 100644 test/python/utils/test_deprecation.py diff --git a/qiskit/utils/deprecation.py b/qiskit/utils/deprecation.py index 29ab9838c2b7..a08c497a8756 100644 --- a/qiskit/utils/deprecation.py +++ b/qiskit/utils/deprecation.py @@ -15,19 +15,33 @@ import functools import warnings from dataclasses import dataclass -from typing import Callable, ClassVar, Dict, Optional, Type, cast, Any +from typing import Any, Callable, ClassVar, Dict, Type def deprecate_arguments(kwarg_map: Dict[str, str], category: Type[Warning] = DeprecationWarning): """Decorator to automatically alias deprecated argument names and warn upon use.""" def decorator(func): + func_name = func.__name__ + old_kwarg_to_msg = {} + for old_arg, new_arg in kwarg_map.items(): + msg_suffix = ( + "will in the future be removed." if new_arg is None else f"replaced with {new_arg}." + ) + old_kwarg_to_msg[ + old_arg + ] = f"{func_name} keyword argument {old_arg} is deprecated and {msg_suffix}" + @functools.wraps(func) def wrapper(*args, **kwargs): if kwargs: - _rename_kwargs(func, kwargs, kwarg_map, category) + _rename_kwargs(func_name, kwargs, old_kwarg_to_msg, kwarg_map, category) return func(*args, **kwargs) + for msg in old_kwarg_to_msg.values(): + _DeprecationMetadataEntry( + msg, since="TODO", pending=issubclass(category, PendingDeprecationWarning) + ).store_on_function(wrapper) return wrapper return decorator @@ -51,87 +65,48 @@ def wrapper(*args, **kwargs): warnings.warn(msg, category=category, stacklevel=stacklevel) return func(*args, **kwargs) - _DeprecationMetadata.set_func_deprecation( - func, msg=msg, since="TODO", pending=isinstance(category, PendingDeprecationWarning) - ) + _DeprecationMetadataEntry( + msg=msg, since="TODO", pending=issubclass(category, PendingDeprecationWarning) + ).store_on_function(wrapper) return wrapper return decorator def _rename_kwargs( - func: Callable, + func_name: str, kwargs: Dict[str, Any], + old_kwarg_to_msg: Dict[str, str], kwarg_map: Dict[str, str], category: Type[Warning] = DeprecationWarning, ) -> None: - func_name = func.__name__ for old_arg, new_arg in kwarg_map.items(): - if new_arg is None: - msg = ( - f"{func_name} keyword argument {old_arg} is deprecated and " - "will in the future be removed." - ) - else: - msg = ( - f"{func_name} keyword argument {old_arg} is deprecated and " - f"replaced with {new_arg}." - ) - _DeprecationMetadata.set_args_deprecation( - func, - arg=old_arg, - msg=msg, - since="TODO", - pending=isinstance(category, PendingDeprecationWarning), - ) - if old_arg in kwargs: - if new_arg in kwargs: - raise TypeError(f"{func_name} received both {new_arg} and {old_arg} (deprecated).") - warnings.warn(msg, category=category, stacklevel=3) - if new_arg is not None: - kwargs[new_arg] = kwargs.pop(old_arg) + if old_arg not in kwargs: + continue + if new_arg in kwargs: + raise TypeError(f"{func_name} received both {new_arg} and {old_arg} (deprecated).") + warnings.warn(old_kwarg_to_msg[old_arg], category=category, stacklevel=3) + if new_arg is not None: + kwargs[new_arg] = kwargs.pop(old_arg) @dataclass(frozen=True) class _DeprecationMetadataEntry: - msg: str - since: str - pending: bool - - -@dataclass -class _DeprecationMetadata: """Used to store deprecation information on a function. - This is used by the Qiskit Sphinx Theme to render deprecations in documentation. Warning: - changes may accidentally break the Sphinx Theme; pay attention to backwards compatibility. + This is used by the Qiskit meta repository to render deprecations in documentation. Warning: + changes may accidentally break the meta repository; pay attention to backwards compatibility. """ - func_deprecation: Optional[_DeprecationMetadataEntry] - args_deprecations: Dict[str, _DeprecationMetadataEntry] + msg: str + since: str + pending: bool - dunder_name: ClassVar[str] = "__qiskit_deprecation__" + dunder_name: ClassVar[str] = "__qiskit_deprecations__" - @classmethod - def set_func_deprecation(cls, func: Callable, *, msg: str, since: str, pending: bool) -> None: - """Add or modify `__qiskit_deprecation__` to set `func_deprecation`.""" - entry = _DeprecationMetadataEntry(msg, since, pending) - if hasattr(func, cls.dunder_name): - metadata = cast(_DeprecationMetadata, getattr(func, cls.dunder_name)) - metadata.func_deprecation = entry - else: - metadata = cls(func_deprecation=entry, args_deprecations={}) - setattr(func, cls.dunder_name, metadata) - - @classmethod - def set_args_deprecation( - cls, func: Callable, *, arg: str, msg: str, since: str, pending: bool - ) -> None: - """Add or modify `__qiskit_deprecation__` to set `args_deprecations` for `arg`.""" - entry = _DeprecationMetadataEntry(msg, since, pending) - if hasattr(func, cls.dunder_name): - metadata = cast(_DeprecationMetadata, getattr(func, cls.dunder_name)) - metadata.args_deprecations[arg] = entry + def store_on_function(self, func: Callable) -> None: + """Add this metadata to the function's `__qiskit_deprecations__` attribute.""" + if hasattr(func, self.dunder_name): + getattr(func, self.dunder_name).append(self) else: - metadata = cls(func_deprecation=None, args_deprecations={arg: entry}) - setattr(func, cls.dunder_name, metadata) + setattr(func, self.dunder_name, [self]) diff --git a/test/python/utils/test_deprecation.py b/test/python/utils/test_deprecation.py new file mode 100644 index 000000000000..06c4270307c4 --- /dev/null +++ b/test/python/utils/test_deprecation.py @@ -0,0 +1,40 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2023. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Tests for the functions in ``utils.deprecation``.""" + +from qiskit.test import QiskitTestCase +from qiskit.utils.deprecation import ( + _DeprecationMetadataEntry, + deprecate_function, + deprecate_arguments, +) + + +class TestDeprecations(QiskitTestCase): + def test_deprecations_store_metadata(self) -> None: + @deprecate_function("Stop using my_func!") + @deprecate_arguments({"old_arg": "new_arg"}, category=PendingDeprecationWarning) + def my_func(old_arg: int, new_arg: int) -> None: + pass + + self.assertEqual( + getattr(my_func, _DeprecationMetadataEntry.dunder_name), + [ + _DeprecationMetadataEntry( + "my_func keyword argument old_arg is deprecated and replaced with new_arg.", + since="TODO", + pending=True, + ), + _DeprecationMetadataEntry("Stop using my_func!", since="TODO", pending=False), + ], + ) From 2162cd81aa81081b444b6f05b5f1efcc97d2e9a0 Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Fri, 24 Feb 2023 08:23:37 -0600 Subject: [PATCH 04/10] Fix Pylint issues --- test/python/utils/test_deprecation.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/test/python/utils/test_deprecation.py b/test/python/utils/test_deprecation.py index 06c4270307c4..9d49888ce336 100644 --- a/test/python/utils/test_deprecation.py +++ b/test/python/utils/test_deprecation.py @@ -21,11 +21,19 @@ class TestDeprecations(QiskitTestCase): + """Test functions in ``utils.deprecation``.""" + def test_deprecations_store_metadata(self) -> None: + """Test that our deprecation decorators store the metadata in __qiskit_deprecations__. + + This should support multiple deprecations on the same function. + """ + @deprecate_function("Stop using my_func!") @deprecate_arguments({"old_arg": "new_arg"}, category=PendingDeprecationWarning) def my_func(old_arg: int, new_arg: int) -> None: - pass + del old_arg + del new_arg self.assertEqual( getattr(my_func, _DeprecationMetadataEntry.dunder_name), From 01cadaa198deb26102e52bc7cfcc62dbeda5df36 Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Fri, 24 Feb 2023 10:02:06 -0600 Subject: [PATCH 05/10] Fix the test to use `since` --- test/python/utils/test_deprecation.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/test/python/utils/test_deprecation.py b/test/python/utils/test_deprecation.py index 9d49888ce336..148e0355450d 100644 --- a/test/python/utils/test_deprecation.py +++ b/test/python/utils/test_deprecation.py @@ -29,8 +29,10 @@ def test_deprecations_store_metadata(self) -> None: This should support multiple deprecations on the same function. """ - @deprecate_function("Stop using my_func!") - @deprecate_arguments({"old_arg": "new_arg"}, category=PendingDeprecationWarning) + @deprecate_function("Stop using my_func!", since="9.99") + @deprecate_arguments( + {"old_arg": "new_arg"}, category=PendingDeprecationWarning, since="9.99" + ) def my_func(old_arg: int, new_arg: int) -> None: del old_arg del new_arg @@ -40,9 +42,9 @@ def my_func(old_arg: int, new_arg: int) -> None: [ _DeprecationMetadataEntry( "my_func keyword argument old_arg is deprecated and replaced with new_arg.", - since="TODO", + since="9.99", pending=True, ), - _DeprecationMetadataEntry("Stop using my_func!", since="TODO", pending=False), + _DeprecationMetadataEntry("Stop using my_func!", since="9.99", pending=False), ], ) From 50f3a950fdee35c8cd1e6721de99abd68d326340 Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Fri, 24 Feb 2023 10:57:24 -0600 Subject: [PATCH 06/10] Fix type hint. `since` may be Optional --- qiskit/utils/deprecation.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qiskit/utils/deprecation.py b/qiskit/utils/deprecation.py index ace0a57fd3ae..bfa4718e5c1c 100644 --- a/qiskit/utils/deprecation.py +++ b/qiskit/utils/deprecation.py @@ -126,7 +126,7 @@ class _DeprecationMetadataEntry: """ msg: str - since: str + since: Optional[str] pending: bool dunder_name: ClassVar[str] = "__qiskit_deprecations__" From bfb90a6f60a4664cc81c41d0801f8c29d51bd569 Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Fri, 24 Feb 2023 13:13:24 -0600 Subject: [PATCH 07/10] Fix type hint for kwarg_map --- qiskit/utils/deprecation.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/qiskit/utils/deprecation.py b/qiskit/utils/deprecation.py index bfa4718e5c1c..622cb4a5c26f 100644 --- a/qiskit/utils/deprecation.py +++ b/qiskit/utils/deprecation.py @@ -19,7 +19,7 @@ def deprecate_arguments( - kwarg_map: Dict[str, str], + kwarg_map: Dict[str, Optional[str]], category: Type[Warning] = DeprecationWarning, *, since: Optional[str] = None, @@ -104,7 +104,7 @@ def _rename_kwargs( func_name: str, kwargs: Dict[str, Any], old_kwarg_to_msg: Dict[str, str], - kwarg_map: Dict[str, str], + kwarg_map: Dict[str, Optional[str]], category: Type[Warning] = DeprecationWarning, ) -> None: for old_arg, new_arg in kwarg_map.items(): From 59f1beba3c2a80861c5482150123c3176589c48f Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Fri, 24 Feb 2023 15:44:08 -0600 Subject: [PATCH 08/10] Add `@deprecate_argument` decorator --- .../algorithms/amplitude_amplifiers/grover.py | 15 +- qiskit/algorithms/amplitude_estimators/ae.py | 15 +- qiskit/algorithms/amplitude_estimators/fae.py | 15 +- qiskit/algorithms/amplitude_estimators/iae.py | 15 +- .../algorithms/amplitude_estimators/mlae.py | 15 +- qiskit/algorithms/optimizers/adam_amsgrad.py | 13 +- qiskit/algorithms/optimizers/qnspsa.py | 21 ++- .../hamiltonian_phase_estimation.py | 16 +- qiskit/algorithms/phase_estimators/ipe.py | 16 +- .../phase_estimators/phase_estimation.py | 15 +- qiskit/primitives/base/base_estimator.py | 8 +- qiskit/primitives/base/base_sampler.py | 7 +- qiskit/providers/basicaer/qasm_simulator.py | 13 +- qiskit/pulse/library/symbolic_pulses.py | 25 +-- qiskit/qpy/interface.py | 7 +- .../synthesis/two_qubit_decompose.py | 4 +- qiskit/transpiler/target.py | 4 +- qiskit/utils/__init__.py | 3 +- qiskit/utils/deprecation.py | 127 ++++++++++++-- qiskit/visualization/counts_visualization.py | 31 +++- qiskit/visualization/state_visualization.py | 12 +- test/python/utils/test_deprecation.py | 159 ++++++++++++++++-- 22 files changed, 397 insertions(+), 159 deletions(-) diff --git a/qiskit/algorithms/amplitude_amplifiers/grover.py b/qiskit/algorithms/amplitude_amplifiers/grover.py index 0e0c1decd0e7..614a6b055836 100644 --- a/qiskit/algorithms/amplitude_amplifiers/grover.py +++ b/qiskit/algorithms/amplitude_amplifiers/grover.py @@ -25,7 +25,7 @@ from qiskit.providers import Backend from qiskit.quantum_info import partial_trace from qiskit.utils import QuantumInstance, algorithm_globals -from qiskit.utils.deprecation import deprecate_function +from qiskit.utils.deprecation import deprecate_argument, deprecate_function from .amplification_problem import AmplificationProblem from .amplitude_amplifier import AmplitudeAmplifier, AmplitudeAmplifierResult @@ -112,6 +112,12 @@ class Grover(AmplitudeAmplifier): `arXiv:quant-ph/0005055 `_. """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, iterations: Optional[Union[List[int], Iterator[int], int]] = None, @@ -174,13 +180,6 @@ def __init__( self._quantum_instance = None if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - stacklevel=2, - ) with warnings.catch_warnings(): warnings.simplefilter("ignore", category=PendingDeprecationWarning) self.quantum_instance = quantum_instance diff --git a/qiskit/algorithms/amplitude_estimators/ae.py b/qiskit/algorithms/amplitude_estimators/ae.py index 91521eede709..9810ae644e56 100644 --- a/qiskit/algorithms/amplitude_estimators/ae.py +++ b/qiskit/algorithms/amplitude_estimators/ae.py @@ -23,7 +23,7 @@ from qiskit.providers import Backend from qiskit.primitives import BaseSampler from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_function +from qiskit.utils.deprecation import deprecate_argument, deprecate_function from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult from .ae_utils import pdf_a, derivative_log_pdf_a, bisect_max from .estimation_problem import EstimationProblem @@ -57,6 +57,12 @@ class AmplitudeEstimation(AmplitudeEstimator): `arXiv:1912.05559 `_. """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, num_eval_qubits: int, @@ -86,13 +92,6 @@ def __init__( super().__init__() # set quantum instance - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - ) with warnings.catch_warnings(): warnings.simplefilter("ignore") self.quantum_instance = quantum_instance diff --git a/qiskit/algorithms/amplitude_estimators/fae.py b/qiskit/algorithms/amplitude_estimators/fae.py index c1bb0eec9846..bb6d0a8cede5 100644 --- a/qiskit/algorithms/amplitude_estimators/fae.py +++ b/qiskit/algorithms/amplitude_estimators/fae.py @@ -20,7 +20,7 @@ from qiskit.providers import Backend from qiskit.primitives import BaseSampler from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_function +from qiskit.utils.deprecation import deprecate_argument, deprecate_function from qiskit.algorithms.exceptions import AlgorithmError from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult @@ -48,6 +48,12 @@ class FasterAmplitudeEstimation(AmplitudeEstimator): """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, delta: float, @@ -73,13 +79,6 @@ def __init__( """ super().__init__() # set quantum instance - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - ) with warnings.catch_warnings(): warnings.simplefilter("ignore") self.quantum_instance = quantum_instance diff --git a/qiskit/algorithms/amplitude_estimators/iae.py b/qiskit/algorithms/amplitude_estimators/iae.py index 0b0348c15adf..90609ceb0c8b 100644 --- a/qiskit/algorithms/amplitude_estimators/iae.py +++ b/qiskit/algorithms/amplitude_estimators/iae.py @@ -22,7 +22,7 @@ from qiskit.providers import Backend from qiskit.primitives import BaseSampler from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_function +from qiskit.utils.deprecation import deprecate_argument, deprecate_function from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult from .estimation_problem import EstimationProblem @@ -50,6 +50,12 @@ class IterativeAmplitudeEstimation(AmplitudeEstimator): `arXiv:quant-ph/0005055 `_. """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, epsilon_target: float, @@ -95,13 +101,6 @@ def __init__( super().__init__() # set quantum instance - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - ) with warnings.catch_warnings(): warnings.simplefilter("ignore") self.quantum_instance = quantum_instance diff --git a/qiskit/algorithms/amplitude_estimators/mlae.py b/qiskit/algorithms/amplitude_estimators/mlae.py index 45ab626ce507..96d83a02f900 100644 --- a/qiskit/algorithms/amplitude_estimators/mlae.py +++ b/qiskit/algorithms/amplitude_estimators/mlae.py @@ -23,7 +23,7 @@ from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit from qiskit.utils import QuantumInstance from qiskit.primitives import BaseSampler -from qiskit.utils.deprecation import deprecate_function +from qiskit.utils.deprecation import deprecate_argument, deprecate_function from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult from .estimation_problem import EstimationProblem @@ -53,6 +53,12 @@ class in named ``MaximumLikelihoodAmplitudeEstimation``. `arXiv:quant-ph/0005055 `_. """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, evaluation_schedule: list[int] | int, @@ -81,13 +87,6 @@ def __init__( super().__init__() # set quantum instance - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - ) with warnings.catch_warnings(): warnings.simplefilter("ignore") self.quantum_instance = quantum_instance diff --git a/qiskit/algorithms/optimizers/adam_amsgrad.py b/qiskit/algorithms/optimizers/adam_amsgrad.py index c1c9a64bdbc8..1e6c94c19b1a 100644 --- a/qiskit/algorithms/optimizers/adam_amsgrad.py +++ b/qiskit/algorithms/optimizers/adam_amsgrad.py @@ -17,7 +17,7 @@ import csv import numpy as np -from qiskit.utils.deprecation import deprecate_arguments +from qiskit.utils.deprecation import deprecate_argument from .optimizer import Optimizer, OptimizerSupportLevel, OptimizerResult, POINT # pylint: disable=invalid-name @@ -193,14 +193,9 @@ def load_params(self, load_dir: str) -> None: t = t[1:-1] self._t = np.fromstring(t, dtype=int, sep=" ") - @deprecate_arguments( - { - "objective_function": "fun", - "initial_point": "x0", - "gradient_function": "jac", - }, - since="0.19.0", - ) + @deprecate_argument("objective_function", new_alias="fun", since="0.19.0") + @deprecate_argument("initial_point", new_alias="fun", since="0.19.0") + @deprecate_argument("gradient_function", new_alias="jac", since="0.19.0") # pylint: disable=arguments-differ def minimize( self, diff --git a/qiskit/algorithms/optimizers/qnspsa.py b/qiskit/algorithms/optimizers/qnspsa.py index 207c9f59bbfb..ac44c2fb32b2 100644 --- a/qiskit/algorithms/optimizers/qnspsa.py +++ b/qiskit/algorithms/optimizers/qnspsa.py @@ -14,13 +14,13 @@ from __future__ import annotations from typing import Any, Iterator, Callable -import warnings import numpy as np from qiskit.providers import Backend from qiskit.circuit import ParameterVector, QuantumCircuit from qiskit.opflow import StateFn, CircuitSampler, ExpectationBase from qiskit.utils import QuantumInstance +from qiskit.utils.deprecation import deprecate_argument from qiskit.primitives import BaseSampler, Sampler from qiskit.algorithms.state_fidelities import ComputeUncompute @@ -253,6 +253,18 @@ def settings(self) -> dict[str, Any]: return settings @staticmethod + @deprecate_argument( + "backend", + deprecation_description="Setting the argument `backend` in QNSPSA.get_fidelity()", + since="0.22", + pending=True, + ) + @deprecate_argument( + "expectation", + deprecation_description="Setting the argument `expectation` in QNSPSA.get_fidelity()", + since="0.22", + pending=True, + ) def get_fidelity( circuit: QuantumCircuit, backend: Backend | QuantumInstance | None = None, @@ -301,13 +313,6 @@ def get_fidelity( sampler = Sampler() if expectation is not None or backend is not None: - warnings.warn( - "Passing a backend and expectation converter to QNSPSA.get_fidelity is pending " - "deprecation and will be deprecated in a future release. Instead, pass a " - "sampler primitive.", - stacklevel=2, - category=PendingDeprecationWarning, - ) return QNSPSA._legacy_get_fidelity(circuit, backend, expectation) fid = ComputeUncompute(sampler) diff --git a/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py b/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py index 0dcc4deb87ec..6d1a7c896957 100644 --- a/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py +++ b/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py @@ -14,10 +14,9 @@ from __future__ import annotations -import warnings - from qiskit import QuantumCircuit from qiskit.utils import QuantumInstance +from qiskit.utils.deprecation import deprecate_argument from qiskit.opflow import ( SummedOp, PauliOp, @@ -92,6 +91,12 @@ class HamiltonianPhaseEstimation: """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, num_evaluation_qubits: int, @@ -106,13 +111,6 @@ def __init__( the circuit will be run. sampler: The sampler primitive on which the circuit will be sampled. """ - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - ) self._phase_estimation = PhaseEstimation( num_evaluation_qubits=num_evaluation_qubits, quantum_instance=quantum_instance, diff --git a/qiskit/algorithms/phase_estimators/ipe.py b/qiskit/algorithms/phase_estimators/ipe.py index 276fb096c783..967d51a07def 100644 --- a/qiskit/algorithms/phase_estimators/ipe.py +++ b/qiskit/algorithms/phase_estimators/ipe.py @@ -15,8 +15,6 @@ from __future__ import annotations -import warnings - import numpy import qiskit @@ -24,6 +22,7 @@ from qiskit.circuit.classicalregister import ClassicalRegister from qiskit.providers import Backend from qiskit.utils import QuantumInstance +from qiskit.utils.deprecation import deprecate_argument from qiskit.algorithms.exceptions import AlgorithmError from .phase_estimator import PhaseEstimator from .phase_estimator import PhaseEstimatorResult @@ -40,6 +39,12 @@ class IterativePhaseEstimation(PhaseEstimator): qubit benchmark, `arxiv/quant-ph/0610214 `_ """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, num_iterations: int, @@ -60,13 +65,6 @@ def __init__( raise AlgorithmError( "Neither a sampler nor a quantum instance was provided. Please provide one of them." ) - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - ) if isinstance(quantum_instance, Backend): quantum_instance = QuantumInstance(quantum_instance) self._quantum_instance = quantum_instance diff --git a/qiskit/algorithms/phase_estimators/phase_estimation.py b/qiskit/algorithms/phase_estimators/phase_estimation.py index bf18efcdcf95..f2e6cb934d50 100644 --- a/qiskit/algorithms/phase_estimators/phase_estimation.py +++ b/qiskit/algorithms/phase_estimators/phase_estimation.py @@ -14,7 +14,6 @@ """The Quantum Phase Estimation Algorithm.""" from __future__ import annotations -import warnings import numpy @@ -24,6 +23,7 @@ from qiskit.circuit.classicalregister import ClassicalRegister from qiskit.providers import Backend from qiskit.utils import QuantumInstance +from qiskit.utils.deprecation import deprecate_argument from qiskit.result import Result from qiskit.algorithms.exceptions import AlgorithmError from .phase_estimation_result import PhaseEstimationResult, _sort_phases @@ -81,6 +81,12 @@ class PhaseEstimation(PhaseEstimator): """ + @deprecate_argument( + "quantum_instance", + additional_msg="Instead, use the `sampler` argument.", + since="0.22.0", + pending=True, + ) def __init__( self, num_evaluation_qubits: int, @@ -102,13 +108,6 @@ def __init__( raise AlgorithmError( "Neither a sampler nor a quantum instance was provided. Please provide one of them." ) - if quantum_instance is not None: - warnings.warn( - "The quantum_instance argument has been superseded by the sampler argument. " - "This argument will be deprecated in a future release and subsequently " - "removed after that.", - category=PendingDeprecationWarning, - ) self._measurements_added = False if num_evaluation_qubits is not None: self._num_evaluation_qubits = num_evaluation_qubits diff --git a/qiskit/primitives/base/base_estimator.py b/qiskit/primitives/base/base_estimator.py index e5d396884fdb..797021f95bfd 100644 --- a/qiskit/primitives/base/base_estimator.py +++ b/qiskit/primitives/base/base_estimator.py @@ -94,7 +94,7 @@ from qiskit.providers import JobV1 as Job from qiskit.quantum_info.operators import SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator -from qiskit.utils.deprecation import deprecate_arguments, deprecate_function +from qiskit.utils.deprecation import deprecate_argument, deprecate_function from ..utils import _circuit_key, _observable_key, init_observable from .base_primitive import BasePrimitive @@ -367,10 +367,8 @@ def close(self): "Use the 'run' method instead.", since="0.22.0", ) - @deprecate_arguments( - {"circuit_indices": "circuits", "observable_indices": "observables"}, - since="0.21.0", - ) + @deprecate_argument("circuit_indices", new_alias="circuits", since="0.21.0") + @deprecate_argument("observable_indices", new_alias="observables", since="0.21.0") def __call__( self, circuits: Sequence[int | QuantumCircuit], diff --git a/qiskit/primitives/base/base_sampler.py b/qiskit/primitives/base/base_sampler.py index 28b717e45b1a..76f28bdef86f 100644 --- a/qiskit/primitives/base/base_sampler.py +++ b/qiskit/primitives/base/base_sampler.py @@ -86,7 +86,7 @@ from qiskit.circuit import Parameter, QuantumCircuit from qiskit.circuit.parametertable import ParameterView from qiskit.providers import JobV1 as Job -from qiskit.utils.deprecation import deprecate_arguments, deprecate_function +from qiskit.utils.deprecation import deprecate_argument, deprecate_function from ..utils import _circuit_key from .base_primitive import BasePrimitive @@ -284,10 +284,7 @@ def close(self): "Use run method instead.", since="0.22.0", ) - @deprecate_arguments( - {"circuit_indices": "circuits"}, - since="0.21.0", - ) + @deprecate_argument("circuit_indices", new_alias="circuits", since="0.21.0") def __call__( self, circuits: Sequence[int | QuantumCircuit], diff --git a/qiskit/providers/basicaer/qasm_simulator.py b/qiskit/providers/basicaer/qasm_simulator.py index d4c016002dc6..22ad8b466606 100644 --- a/qiskit/providers/basicaer/qasm_simulator.py +++ b/qiskit/providers/basicaer/qasm_simulator.py @@ -38,6 +38,7 @@ import numpy as np from qiskit.circuit.quantumcircuit import QuantumCircuit +from qiskit.utils.deprecation import deprecate_argument from qiskit.utils.multiprocessing import local_hardware_info from qiskit.providers.models import QasmBackendConfiguration from qiskit.result import Result @@ -373,6 +374,13 @@ def _validate_measure_sampling(self, experiment): # measure sampling is allowed self._sample_measure = True + @deprecate_argument( + "qobj", + deprecation_description="Using a qobj for the first argument to QasmSimulatorPy.run()", + since="0.22.0", + pending=True, + predicate=lambda qobj: not isinstance(qobj, (QuantumCircuit, list)), + ) def run(self, qobj, **backend_options): """Run qobj asynchronously. @@ -412,11 +420,6 @@ def run(self, qobj, **backend_options): qobj = assemble(qobj, self, **out_options) qobj_options = qobj.config else: - warnings.warn( - "Using a qobj for run() is deprecated and will be removed in a future release.", - PendingDeprecationWarning, - stacklevel=2, - ) qobj_options = qobj.config self._set_options(qobj_config=qobj_options, backend_options=backend_options) job_id = str(uuid.uuid4()) diff --git a/qiskit/pulse/library/symbolic_pulses.py b/qiskit/pulse/library/symbolic_pulses.py index 1aab1c58c184..dbd728b66c94 100644 --- a/qiskit/pulse/library/symbolic_pulses.py +++ b/qiskit/pulse/library/symbolic_pulses.py @@ -29,6 +29,7 @@ from qiskit.pulse.library.pulse import Pulse from qiskit.pulse.library.waveform import Waveform from qiskit.utils import optionals as _optional +from qiskit.utils.deprecation import deprecate_argument if _optional.HAS_SYMENGINE: import symengine as sym @@ -586,6 +587,16 @@ class ScalableSymbolicPulse(SymbolicPulse): :math:'\text{amp}\times\exp\left(i\times\text{angle}\right)' is compared. """ + @deprecate_argument( + "amp", + deprecation_description=( + "Setting `amp` to a complex in the ScalableSymbolicPulse constructor" + ), + additional_msg="Instead, use a float for `amp` (for the magnitude) and a float for `angle`", + since="0.23.0", + pending=True, + predicate=lambda amp: isinstance(amp, complex), + ) def __init__( self, pulse_type: str, @@ -620,18 +631,10 @@ def __init__( Raises: PulseError: If both `amp` is complex and `angle` is not `None` or 0. - """ - # This should be removed once complex amp support is deprecated. - if isinstance(amp, complex): - if angle is None or angle == 0: - warnings.warn( - "Complex amp will be deprecated. " - "Use float amp (for the magnitude) and float angle instead.", - PendingDeprecationWarning, - ) - else: - raise PulseError("amp can't be complex with angle not None or 0") + # This should be removed once complex amp support is removed. + if isinstance(amp, complex) and (angle is not None or angle != 0): + raise PulseError("amp can't be complex with angle not None or 0") if angle is None: angle = 0 diff --git a/qiskit/qpy/interface.py b/qiskit/qpy/interface.py index b68db9bc6c50..fd76554b8d6c 100644 --- a/qiskit/qpy/interface.py +++ b/qiskit/qpy/interface.py @@ -25,7 +25,7 @@ from qiskit.qpy import formats, common, binary_io, type_keys from qiskit.qpy.exceptions import QpyError from qiskit.version import __version__ -from qiskit.utils.deprecation import deprecate_arguments +from qiskit.utils.deprecation import deprecate_argument # pylint: disable=invalid-name @@ -72,10 +72,7 @@ VERSION_PATTERN_REGEX = re.compile(VERSION_PATTERN, re.VERBOSE | re.IGNORECASE) -@deprecate_arguments( - {"circuits": "programs"}, - since="0.21.0", -) +@deprecate_argument("circuits", new_alias="programs", since="0.21.0") def dump( programs: Union[List[QPY_SUPPORTED_TYPES], QPY_SUPPORTED_TYPES], file_obj: BinaryIO, diff --git a/qiskit/quantum_info/synthesis/two_qubit_decompose.py b/qiskit/quantum_info/synthesis/two_qubit_decompose.py index 6e580265e944..c6ba88ba8b38 100644 --- a/qiskit/quantum_info/synthesis/two_qubit_decompose.py +++ b/qiskit/quantum_info/synthesis/two_qubit_decompose.py @@ -43,7 +43,7 @@ OneQubitEulerDecomposer, DEFAULT_ATOL, ) -from qiskit.utils.deprecation import deprecate_arguments +from qiskit.utils.deprecation import deprecate_argument logger = logging.getLogger(__name__) @@ -1085,7 +1085,7 @@ def decomp3_supercontrolled(self, target): return U3r, U3l, U2r, U2l, U1r, U1l, U0r, U0l - @deprecate_arguments({"target": "unitary"}, since="0.23.0") + @deprecate_argument("target", new_alias="unitary", since="0.23.0") def __call__( self, unitary: Union[Operator, np.ndarray], diff --git a/qiskit/transpiler/target.py b/qiskit/transpiler/target.py index ead475326c39..5d2c1a93d9f0 100644 --- a/qiskit/transpiler/target.py +++ b/qiskit/transpiler/target.py @@ -35,7 +35,7 @@ from qiskit.transpiler.exceptions import TranspilerError from qiskit.transpiler.instruction_durations import InstructionDurations from qiskit.transpiler.timing_constraints import TimingConstraints -from qiskit.utils.deprecation import deprecate_arguments +from qiskit.utils.deprecation import deprecate_argument # import QubitProperties here to provide convenience alias for building a # full target @@ -203,7 +203,7 @@ class Target(Mapping): "_global_operations", ) - @deprecate_arguments({"aquire_alignment": "acquire_alignment"}, since="0.23.0") + @deprecate_argument("aquire_alignment", new_alias="acquire_alignment", since="0.23.0") def __init__( self, description=None, diff --git a/qiskit/utils/__init__.py b/qiskit/utils/__init__.py index f4461e5ba755..ffda1bf930dc 100644 --- a/qiskit/utils/__init__.py +++ b/qiskit/utils/__init__.py @@ -64,7 +64,7 @@ """ from .quantum_instance import QuantumInstance -from .deprecation import deprecate_arguments +from .deprecation import deprecate_argument, deprecate_arguments from .deprecation import deprecate_function from .multiprocessing import local_hardware_info from .multiprocessing import is_main_process @@ -93,6 +93,7 @@ "has_aer", "name_args", "algorithm_globals", + "deprecate_argument", "deprecate_arguments", "deprecate_function", "local_hardware_info", diff --git a/qiskit/utils/deprecation.py b/qiskit/utils/deprecation.py index 622cb4a5c26f..5f98ea993974 100644 --- a/qiskit/utils/deprecation.py +++ b/qiskit/utils/deprecation.py @@ -18,13 +18,97 @@ from typing import Any, Callable, ClassVar, Dict, Optional, Type +def deprecate_argument( + name: str, + *, + since: str, + additional_msg: Optional[str] = None, + deprecation_description: Optional[str] = None, + pending: bool = False, + project_name: str = "Qiskit Terra", + new_alias: Optional[str] = None, + predicate: Optional[Callable[[Any], bool]] = None, +): + """Decorator to indicate an argument has been deprecated in some way. + + This decorator may be used multiple times on the same function, once per deprecated argument. + It should be placed beneath other decorators like `@staticmethod` and property decorators. + + Args: + name: The name of the deprecated argument. + since: The version the deprecation started at. Only Optional for backwards + compatibility - this should always be set. If the deprecation is pending, set + the version to when that started; but later, when switching from pending to + deprecated, update `since` to the new version. + deprecation_description: What is being deprecated? E.g. "Setting my_func()'s `my_arg` + argument to `None`." If not set, will default to "{func_name}'s argument `{name}`". + additional_msg: Put here any additional information, such as what to use instead + (if new_alias is not set). For example, "Instead, use the argument `new_arg`, + which is similar but does not impact the circuit's setup." + pending: Set to `True` if the deprecation is still pending. + project_name: The name of the project, e.g. "Qiskit Nature". + new_alias: If the arg has simply been renamed, set this to the new name. The decorator will + dynamically update the `kwargs` so that when the user sets the old arg, it will be + passed in as the `new_alias` arg. + predicate: Only log the runtime warning if the predicate returns True. This is useful to + deprecate certain values or types for an argument, e.g. + `lambda my_arg: isinstance(my_arg, dict)`. Regardless of if a predicate is set, the + runtime warning will only log when the user specifies the argument. + + Returns: + Callable: The decorated callable. + """ + + def decorator(func): + func_name = f"{func.__qualname__}()" # For methods, `qualname` includes the class name. + deprecated_entity = deprecation_description or f"{func_name}'s argument `{name}`" + if pending: + category = PendingDeprecationWarning + deprecation_status = "pending deprecation" + removal_desc = ( + "marked deprecated in a future release, and then removed in a future release" + ) + else: + category = DeprecationWarning + deprecation_status = "deprecated" + removal_desc = "removed no earlier than 3 months after the release date" + + msg = ( + f"{deprecated_entity} is {deprecation_status} as of {project_name} {since}. " + f"It will be {removal_desc}." + ) + if new_alias: + msg += f" Instead, use the argument `{new_alias}`, which behaves identically." + if additional_msg: + msg += f" {additional_msg}" + + @functools.wraps(func) + def wrapper(*args, **kwargs): + if kwargs: + _maybe_warn_and_rename_kwarg( + func_name, + kwargs, + old_arg=name, + new_alias=new_alias, + warning_msg=msg, + category=category, + predicate=predicate, + ) + return func(*args, **kwargs) + + _DeprecationMetadataEntry(msg, since=since, pending=pending).store_on_function(wrapper) + return wrapper + + return decorator + + def deprecate_arguments( kwarg_map: Dict[str, Optional[str]], category: Type[Warning] = DeprecationWarning, *, since: Optional[str] = None, ): - """Decorator to automatically alias deprecated argument names and warn upon use. + """Deprecated in favor of `deprecate_argument` instead. Args: kwarg_map: A dictionary of the old argument name to the new name. @@ -39,7 +123,7 @@ def deprecate_arguments( """ def decorator(func): - func_name = func.__name__ + func_name = func.__qualname__ old_kwarg_to_msg = {} for old_arg, new_arg in kwarg_map.items(): msg_suffix = ( @@ -52,7 +136,16 @@ def decorator(func): @functools.wraps(func) def wrapper(*args, **kwargs): if kwargs: - _rename_kwargs(func_name, kwargs, old_kwarg_to_msg, kwarg_map, category) + for old, new in kwarg_map.items(): + _maybe_warn_and_rename_kwarg( + func_name, + kwargs, + old_arg=old, + new_alias=new, + warning_msg=old_kwarg_to_msg[old], + category=category, + predicate=None, + ) return func(*args, **kwargs) for msg in old_kwarg_to_msg.values(): @@ -100,21 +193,25 @@ def wrapper(*args, **kwargs): return decorator -def _rename_kwargs( +def _maybe_warn_and_rename_kwarg( func_name: str, kwargs: Dict[str, Any], - old_kwarg_to_msg: Dict[str, str], - kwarg_map: Dict[str, Optional[str]], - category: Type[Warning] = DeprecationWarning, + *, + old_arg: str, + new_alias: Optional[str], + warning_msg: str, + category: Type[Warning], + predicate: Optional[Callable[[Any], bool]], ) -> None: - for old_arg, new_arg in kwarg_map.items(): - if old_arg not in kwargs: - continue - if new_arg in kwargs: - raise TypeError(f"{func_name} received both {new_arg} and {old_arg} (deprecated).") - warnings.warn(old_kwarg_to_msg[old_arg], category=category, stacklevel=3) - if new_arg is not None: - kwargs[new_arg] = kwargs.pop(old_arg) + if old_arg not in kwargs: + return + if new_alias and new_alias in kwargs: + raise TypeError(f"{func_name} received both {new_alias} and {old_arg} (deprecated).") + if predicate and not predicate(kwargs[old_arg]): + return + warnings.warn(warning_msg, category=category, stacklevel=3) + if new_alias is not None: + kwargs[new_alias] = kwargs.pop(old_arg) @dataclass(frozen=True) diff --git a/qiskit/visualization/counts_visualization.py b/qiskit/visualization/counts_visualization.py index fa1a2977dde4..644d5aeabb10 100644 --- a/qiskit/visualization/counts_visualization.py +++ b/qiskit/visualization/counts_visualization.py @@ -16,11 +16,11 @@ from collections import OrderedDict import functools -import warnings import numpy as np from qiskit.utils import optionals as _optionals +from qiskit.utils.deprecation import deprecate_argument from qiskit.result import QuasiDistribution, ProbDistribution from .exceptions import VisualizationError from .utils import matplotlib_close_if_inline @@ -46,6 +46,28 @@ def hamming_distance(str1, str2): DIST_MEAS = {"hamming": hamming_distance} +def _is_deprecated_data_format(data) -> bool: + if not isinstance(data, list): + data = [data] + for dat in data: + if isinstance(dat, (QuasiDistribution, ProbDistribution)) or isinstance( + next(iter(dat.values())), float + ): + return True + return False + + +@deprecate_argument( + "data", + deprecation_description=( + "Using plot_histogram() `data` argument with QuasiDistribution, ProbDistribution, or a " + "distribution dictionary" + ), + since="0.22.0", + additional_msg="Instead, use `plot_distribution()`.", + predicate=_is_deprecated_data_format, + pending=True, +) def plot_histogram( data, figsize=(7, 5), @@ -134,13 +156,6 @@ def plot_histogram( if isinstance(dat, (QuasiDistribution, ProbDistribution)) or isinstance( next(iter(dat.values())), float ): - warnings.warn( - "Using plot histogram with QuasiDistribution, ProbDistribution, or a " - "distribution dictionary will be deprecated in 0.23.0 and subsequently " - "removed in a future release. You should use plot_distribution() instead.", - PendingDeprecationWarning, - stacklevel=2, - ) kind = "distribution" return _plotting_core( data, diff --git a/qiskit/visualization/state_visualization.py b/qiskit/visualization/state_visualization.py index a3df767e15b1..735a36769a2e 100644 --- a/qiskit/visualization/state_visualization.py +++ b/qiskit/visualization/state_visualization.py @@ -26,7 +26,7 @@ from qiskit.quantum_info.states.statevector import Statevector from qiskit.quantum_info.operators.symplectic import PauliList, SparsePauliOp from qiskit.quantum_info.states.densitymatrix import DensityMatrix -from qiskit.utils.deprecation import deprecate_arguments +from qiskit.utils.deprecation import deprecate_argument from qiskit.utils import optionals as _optionals from qiskit.circuit.tools.pi_check import pi_check @@ -35,7 +35,7 @@ from .exceptions import VisualizationError -@deprecate_arguments({"rho": "state"}, since="0.15.1") +@deprecate_argument("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_state_hinton( state, title="", figsize=None, ax_real=None, ax_imag=None, *, rho=None, filename=None @@ -250,7 +250,7 @@ def plot_bloch_vector(bloch, title="", ax=None, figsize=None, coord_type="cartes return None -@deprecate_arguments({"rho": "state"}, since="0.15.1") +@deprecate_argument("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_bloch_multivector( state, title="", figsize=None, *, rho=None, reverse_bits=False, filename=None @@ -338,7 +338,7 @@ def plot_bloch_multivector( return fig.savefig(filename) -@deprecate_arguments({"rho": "state"}, since="0.15.1") +@deprecate_argument("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_state_city( state, @@ -595,7 +595,7 @@ def plot_state_city( return fig.savefig(filename) -@deprecate_arguments({"rho": "state"}, since="0.15.1") +@deprecate_argument("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_state_paulivec( state, title="", figsize=None, color=None, ax=None, *, rho=None, filename=None @@ -766,7 +766,7 @@ def phase_to_rgb(complex_number): return rgb -@deprecate_arguments({"rho": "state"}, since="0.15.1") +@deprecate_argument("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call @_optionals.HAS_SEABORN.require_in_call def plot_state_qsphere( diff --git a/test/python/utils/test_deprecation.py b/test/python/utils/test_deprecation.py index 148e0355450d..8aa8aff61a89 100644 --- a/test/python/utils/test_deprecation.py +++ b/test/python/utils/test_deprecation.py @@ -16,6 +16,7 @@ from qiskit.utils.deprecation import ( _DeprecationMetadataEntry, deprecate_function, + deprecate_argument, deprecate_arguments, ) @@ -23,28 +24,164 @@ class TestDeprecations(QiskitTestCase): """Test functions in ``utils.deprecation``.""" - def test_deprecations_store_metadata(self) -> None: - """Test that our deprecation decorators store the metadata in __qiskit_deprecations__. + def test_deprecate_argument_metadata(self) -> None: + """Test that `@deprecate_argument` stores the correct metadata.""" - This should support multiple deprecations on the same function. - """ + @deprecate_argument("arg1", since="9.99") + @deprecate_argument("arg2", pending=True, since="9.99") + @deprecate_argument( + "arg3", + since="9.99", + deprecation_description="Using the argument arg3", + new_alias="new_arg3", + ) + @deprecate_argument( + "arg4", + since="9.99", + additional_msg="Instead, use foo.", + # This predicate always fails, but it should not impact storing the deprecation + # metadata. That ensures the deprecation still shows up in our docs. + predicate=lambda arg4: False, + ) + def my_func() -> None: + pass + + self.assertEqual( + getattr(my_func, _DeprecationMetadataEntry.dunder_name), + [ + _DeprecationMetadataEntry( + ( + "TestDeprecations.test_deprecate_argument_metadata..my_func()'s " + "argument `arg4` is deprecated as of Qiskit Terra 9.99. It will be removed " + "no earlier than 3 months after the release date. Instead, use foo." + ), + since="9.99", + pending=False, + ), + _DeprecationMetadataEntry( + ( + "Using the argument arg3 is deprecated as of Qiskit Terra 9.99. It will " + "be removed no earlier than 3 months after the release date. Instead, " + "use the argument `new_arg3`, which behaves identically." + ), + since="9.99", + pending=False, + ), + _DeprecationMetadataEntry( + ( + "TestDeprecations.test_deprecate_argument_metadata..my_func()'s " + "argument `arg2` is pending deprecation as of Qiskit Terra 9.99. " + "It will be marked deprecated in a future release, and then removed in a " + "future release." + ), + since="9.99", + pending=True, + ), + _DeprecationMetadataEntry( + ( + "TestDeprecations.test_deprecate_argument_metadata..my_func()'s " + "argument `arg1` is deprecated as of Qiskit Terra 9.99. It will " + "be removed no earlier than 3 months after the release date." + ), + since="9.99", + pending=False, + ), + ], + ) + + def test_deprecate_arguments_metadata(self) -> None: + """Test that `@deprecate_arguments` stores the correct metadata.""" - @deprecate_function("Stop using my_func!", since="9.99") @deprecate_arguments( - {"old_arg": "new_arg"}, category=PendingDeprecationWarning, since="9.99" + {"old_arg1": "new_arg1", "old_arg2": None}, + category=PendingDeprecationWarning, + since="9.99", ) - def my_func(old_arg: int, new_arg: int) -> None: - del old_arg - del new_arg + def my_func() -> None: + pass self.assertEqual( getattr(my_func, _DeprecationMetadataEntry.dunder_name), [ _DeprecationMetadataEntry( - "my_func keyword argument old_arg is deprecated and replaced with new_arg.", + "TestDeprecations.test_deprecate_arguments_metadata..my_func keyword " + "argument old_arg1 is deprecated and replaced with new_arg1.", + since="9.99", + pending=True, + ), + _DeprecationMetadataEntry( + "TestDeprecations.test_deprecate_arguments_metadata..my_func keyword " + "argument old_arg2 is deprecated and will in the future be removed.", since="9.99", pending=True, ), - _DeprecationMetadataEntry("Stop using my_func!", since="9.99", pending=False), ], ) + + def test_deprecate_function_metadata(self) -> None: + """Test that `@deprecate_function` stores the correct metadata.""" + + @deprecate_function("Stop using my_func!", since="9.99") + def my_func() -> None: + pass + + self.assertEqual( + getattr(my_func, _DeprecationMetadataEntry.dunder_name), + [_DeprecationMetadataEntry("Stop using my_func!", since="9.99", pending=False)], + ) + + def test_deprecate_argument_runtime_warning(self) -> None: + """Test that `@deprecate_argument` warns whenever the arguments are used. + + Also check these edge cases: + * If `new_alias` is set, pass the old argument as the new alias. + * If `predicate` is set, only warn if the predicate is True. + """ + + @deprecate_argument("arg1", since="9.99") + @deprecate_argument("arg2", new_alias="new_arg2", since="9.99") + @deprecate_argument("arg3", predicate=lambda arg3: arg3 == "deprecated value", since="9.99") + def my_func(*, arg1: str = "a", new_arg2: str, arg3: str = "a") -> None: + del arg1 + del arg3 + assert new_arg2 == "z" + + my_func(new_arg2="z") # No warnings if no deprecated args used. + with self.assertWarns(DeprecationWarning): + my_func(arg1="a", new_arg2="z") + with self.assertWarns(DeprecationWarning): + # `arg2` should be converted into `new_arg2`. + my_func(arg2="z") # pylint: disable=missing-kwoa + + # Test the `predicate` functionality. + my_func(new_arg2="z", arg3="okay value") + with self.assertWarns(DeprecationWarning): + my_func(new_arg2="z", arg3="deprecated value") + + def test_deprecate_arguments_runtime_warning(self) -> None: + """Test that `@deprecate_arguments` warns whenever the arguments are used. + + Also check that old arguments are passed in as their new alias. + """ + + @deprecate_arguments({"arg1": None, "arg2": "new_arg2"}, since="9.99") + def my_func(*, arg1: str = "a", new_arg2: str) -> None: + del arg1 + assert new_arg2 == "z" + + my_func(new_arg2="z") # No warnings if no deprecated args used. + with self.assertWarns(DeprecationWarning): + my_func(arg1="a", new_arg2="z") + with self.assertWarns(DeprecationWarning): + # `arg2` should be converted into `new_arg2`. + my_func(arg2="z") # pylint: disable=missing-kwoa + + def test_deprecate_function_runtime_warning(self) -> None: + """Test that `@deprecate_function` warns whenever the function is used.""" + + @deprecate_function("Stop using my_func!", since="9.99") + def my_func() -> None: + pass + + with self.assertWarns(DeprecationWarning): + my_func() From 6476507a6cd780dd4d20d26830d01442a5947ed7 Mon Sep 17 00:00:00 2001 From: Eric Arellano Date: Mon, 27 Feb 2023 13:19:43 -0600 Subject: [PATCH 09/10] Migrate all DeprecationWarnings --- qiskit/assembler/run_config.py | 18 +++-- qiskit/circuit/instructionset.py | 26 +++---- qiskit/compiler/assembler.py | 16 ++-- qiskit/dagcircuit/dagnode.py | 31 +++++--- qiskit/execute_function.py | 42 +++++------ qiskit/primitives/base/base_estimator.py | 22 +++--- qiskit/primitives/base/base_sampler.py | 17 ++--- .../providers/models/backendconfiguration.py | 16 ++-- qiskit/qobj/pulse_qobj.py | 18 +++-- qiskit/qobj/qasm_qobj.py | 18 +++-- .../operators/symplectic/pauli_utils.py | 17 +++-- qiskit/synthesis/evolution/suzuki_trotter.py | 29 ++++---- qiskit/transpiler/instruction_durations.py | 25 ++++--- .../passes/calibration/rzx_builder.py | 10 +-- qiskit/visualization/circuit/_utils.py | 24 ++---- qiskit/visualization/circuit/latex.py | 63 ++++++---------- qiskit/visualization/circuit/matplotlib.py | 74 +++++++------------ qiskit/visualization/circuit/text.py | 63 ++++++---------- 18 files changed, 238 insertions(+), 291 deletions(-) diff --git a/qiskit/assembler/run_config.py b/qiskit/assembler/run_config.py index 78da74f4b08e..386ad52d9346 100644 --- a/qiskit/assembler/run_config.py +++ b/qiskit/assembler/run_config.py @@ -13,7 +13,8 @@ """Models for RunConfig and its related components.""" from types import SimpleNamespace -import warnings + +from qiskit.utils.deprecation import deprecate_argument class RunConfig(SimpleNamespace): @@ -30,6 +31,14 @@ class RunConfig(SimpleNamespace): parameter_binds (list[dict]): List of parameter bindings """ + @deprecate_argument( + "max_credits", + since="0.20.0", + additional_msg=( + "This argument has no effect on modern IBM Quantum systems, and no alternative is" + "necessary." + ), + ) def __init__( self, shots=None, @@ -55,13 +64,6 @@ def __init__( self.shots = shots if max_credits is not None: self.max_credits = max_credits - warnings.warn( - "The `max_credits` parameter is deprecated as of Qiskit Terra 0.20.0, " - "and will be removed in a future release. This parameter has no effect on " - "modern IBM Quantum systems, and no alternative is necessary.", - DeprecationWarning, - stacklevel=2, - ) if seed_simulator is not None: self.seed_simulator = seed_simulator if memory is not None: diff --git a/qiskit/circuit/instructionset.py b/qiskit/circuit/instructionset.py index 10155460030d..ccba996bbc54 100644 --- a/qiskit/circuit/instructionset.py +++ b/qiskit/circuit/instructionset.py @@ -15,10 +15,10 @@ """ import functools -import warnings from typing import Callable, Optional, Tuple, Union from qiskit.circuit.exceptions import CircuitError +from qiskit.utils.deprecation import deprecate_argument from .classicalregister import Clbit, ClassicalRegister from .operation import Operation from .quantumcircuitdata import CircuitInstruction @@ -92,6 +92,16 @@ class InstructionSet: __slots__ = ("_instructions", "_requester") + @deprecate_argument( + "circuit_cregs", + since="0.19.0", + additional_msg=( + "Instead, pass a complete resource requester with the 'resource_requester' argument. " + "(The classical registers are insufficient to access all classical resources in a " + "circuit, as there may be loose classical bits as well. It can also cause integer " + "indices to be resolved incorrectly if any registers overlap.)" + ), + ) def __init__(self, circuit_cregs=None, *, resource_requester: Optional[Callable] = None): """New collection of instructions. @@ -101,13 +111,6 @@ def __init__(self, circuit_cregs=None, *, resource_requester: Optional[Callable] Args: circuit_cregs (list[ClassicalRegister]): Optional. List of cregs of the circuit to which the instruction is added. Default: `None`. - - .. deprecated:: qiskit-terra 0.19 - The classical registers are insufficient to access all classical resources in a - circuit, as there may be loose classical bits as well. It can also cause - integer indices to be resolved incorrectly if any registers overlap. Instead, - pass a complete requester to the ``resource_requester`` argument. - resource_requester: A callable that takes in the classical resource used in the condition, verifies that it is present in the attached circuit, resolves any indices into concrete :obj:`.Clbit` instances, and returns the concrete resource. If this @@ -128,13 +131,6 @@ def __init__(self, circuit_cregs=None, *, resource_requester: Optional[Callable] if circuit_cregs is not None: if resource_requester is not None: raise CircuitError("Cannot pass both 'circuit_cregs' and 'resource_requester'.") - warnings.warn( - "The 'circuit_cregs' argument to 'InstructionSet' is deprecated as of" - " qiskit-terra 0.19, and will be removed no sooner than 3 months after its release." - " Pass a complete resource requester as the 'resource_requester' instead.", - DeprecationWarning, - stacklevel=2, - ) self._requester: Optional[Callable] = _requester_from_cregs(tuple(circuit_cregs)) else: self._requester = resource_requester diff --git a/qiskit/compiler/assembler.py b/qiskit/compiler/assembler.py index f4d7d37ec81c..1a3075eba052 100644 --- a/qiskit/compiler/assembler.py +++ b/qiskit/compiler/assembler.py @@ -29,6 +29,7 @@ from qiskit.pulse.channels import PulseChannel from qiskit.qobj import Qobj, QobjHeader from qiskit.qobj.utils import MeasLevel, MeasReturnType +from qiskit.utils.deprecation import deprecate_argument logger = logging.getLogger(__name__) @@ -39,6 +40,14 @@ def _log_assembly_time(start_time, end_time): # TODO: parallelize over the experiments (serialize each separately, then add global header/config) +@deprecate_argument( + "max_credits", + since="0.20.0", + additional_msg=( + "This argument has no effect on modern IBM Quantum systems, and no alternative is" + "necessary." + ), +) def assemble( experiments: Union[ QuantumCircuit, @@ -159,13 +168,6 @@ def assemble( """ if max_credits is not None: max_credits = None - warnings.warn( - "The `max_credits` parameter is deprecated as of Qiskit Terra 0.20.0, " - "and will be removed in a future release. This parameter has no effect on " - "modern IBM Quantum systems, and no alternative is necessary.", - DeprecationWarning, - stacklevel=2, - ) start_time = time() experiments = experiments if isinstance(experiments, list) else [experiments] pulse_qobj = any(isinstance(exp, (ScheduleBlock, Schedule, Instruction)) for exp in experiments) diff --git a/qiskit/dagcircuit/dagnode.py b/qiskit/dagcircuit/dagnode.py index 85485ca41f62..30f75b3f8d7c 100644 --- a/qiskit/dagcircuit/dagnode.py +++ b/qiskit/dagcircuit/dagnode.py @@ -14,10 +14,10 @@ """Objects to represent the information at a node in the DAGCircuit.""" -import warnings from typing import Iterable from qiskit.circuit import Qubit, Clbit +from qiskit.utils.deprecation import deprecate_argument def _condition_as_indices(operation, bit_indices): @@ -50,6 +50,26 @@ def __str__(self): return str(id(self)) @staticmethod + @deprecate_argument( + "bit_indices1", + deprecation_description="Not setting bit_indices1 in DAGNode.semantic_eq()", + additional_msg=( + "To ease the transition, bit_indices1 and bit_indices2 will for now be " + "pre-populated based on the values found in Bit.index and Bit.register." + ), + since="0.21.0", + predicate=lambda arg: arg is None, + ) + @deprecate_argument( + "bit_indices2", + deprecation_description="Not setting bit_indices2 in DAGNode.semantic_eq()", + additional_msg=( + "To ease the transition, bit_indices1 and bit_indices2 will for now be " + "pre-populated based on the values found in Bit.index and Bit.register." + ), + since="0.21.0", + predicate=lambda arg: arg is None, + ) def semantic_eq(node1, node2, bit_indices1=None, bit_indices2=None): """ Check if DAG nodes are considered equivalent, e.g., as a node_match for nx.is_isomorphic. @@ -66,15 +86,6 @@ def semantic_eq(node1, node2, bit_indices1=None, bit_indices2=None): Bool: If node1 == node2 """ if bit_indices1 is None or bit_indices2 is None: - warnings.warn( - "DAGNode.semantic_eq now expects two bit-to-circuit index " - "mappings as arguments. To ease the transition, these will be " - "pre-populated based on the values found in Bit.index and " - "Bit.register. However, this behavior is deprecated and a future " - "release will require the mappings to be provided as arguments.", - DeprecationWarning, - ) - bit_indices1 = {arg: arg for arg in node1.qargs + node1.cargs} bit_indices2 = {arg: arg for arg in node2.qargs + node2.cargs} diff --git a/qiskit/execute_function.py b/qiskit/execute_function.py index df6256edd749..c3b6974ea175 100644 --- a/qiskit/execute_function.py +++ b/qiskit/execute_function.py @@ -21,11 +21,12 @@ """ import logging from time import time -import warnings + from qiskit.compiler import transpile, schedule from qiskit.providers.backend import Backend from qiskit.pulse import Schedule, ScheduleBlock from qiskit.exceptions import QiskitError +from qiskit.utils.deprecation import deprecate_argument logger = logging.getLogger(__name__) @@ -35,6 +36,20 @@ def _log_submission_time(start_time, end_time): logger.info(log_msg) +@deprecate_argument( + "max_credits", + since="0.20.0", + additional_msg=( + "This argument has no effect on modern IBM Quantum systems, and no alternative is" + "necessary." + ), +) +@deprecate_argument( + "qobj_id", since="0.21.0", additional_msg="This argument has no effect anymore." +) +@deprecate_argument( + "qobj_header", since="0.21.0", additional_msg="This argument has no effect anymore." +) def execute( experiments, backend, @@ -280,6 +295,9 @@ def execute( job = execute(qc, backend, shots=4321) """ + del qobj_id + del qobj_header + del max_credits if isinstance(experiments, (Schedule, ScheduleBlock)) or ( isinstance(experiments, list) and isinstance(experiments[0], (Schedule, ScheduleBlock)) ): @@ -318,28 +336,6 @@ def execute( meas_map=meas_map, method=scheduling_method, ) - if max_credits is not None: - warnings.warn( - "The `max_credits` parameter is deprecated as of Qiskit Terra 0.20.0, " - "and will be removed in a future release. This parameter has no effect on " - "modern IBM Quantum systems, and no alternative is necessary.", - DeprecationWarning, - stacklevel=2, - ) - - if qobj_id is not None: - warnings.warn( - "The qobj_id argument is deprecated as of the Qiskit Terra 0.21.0, " - "and will be remvoed in a future release. This argument has no effect and " - "is not used by any backends." - ) - - if qobj_header is not None: - warnings.warn( - "The qobj_header argument is deprecated as of the Qiskit Terra 0.21.0, " - "and will be remvoed in a future release. This argument has no effect and " - "is not used by any backends." - ) if isinstance(backend, Backend): start_time = time() diff --git a/qiskit/primitives/base/base_estimator.py b/qiskit/primitives/base/base_estimator.py index 797021f95bfd..1b12fe08733b 100644 --- a/qiskit/primitives/base/base_estimator.py +++ b/qiskit/primitives/base/base_estimator.py @@ -84,7 +84,6 @@ from collections.abc import Iterable, Sequence from copy import copy from typing import cast -from warnings import warn import numpy as np @@ -109,6 +108,19 @@ class BaseEstimator(BasePrimitive): __hash__ = None + @deprecate_argument( + "circuits", since="0.22", additional_msg="Instead, use the run() method to append objects." + ) + @deprecate_argument( + "observables", + since="0.22", + additional_msg="Instead, use the run() method to append objects.", + ) + @deprecate_argument( + "parameters", + since="0.22", + additional_msg="Instead, use the run() method to append objects.", + ) def __init__( self, circuits: Iterable[QuantumCircuit] | QuantumCircuit | None = None, @@ -132,14 +144,6 @@ def __init__( Raises: ValueError: For mismatch of circuits and parameters list. """ - if circuits is not None or observables is not None or parameters is not None: - warn( - "The BaseEstimator `circuits`, `observables`, `parameters` kwarg are deprecated " - "as of Qiskit Terra 0.22.0 and will be removed no earlier than 3 months after " - "the release date. You can use the 'run' method to append objects.", - DeprecationWarning, - 2, - ) if isinstance(circuits, QuantumCircuit): circuits = (circuits,) self._circuits = [] if circuits is None else list(circuits) diff --git a/qiskit/primitives/base/base_sampler.py b/qiskit/primitives/base/base_sampler.py index 76f28bdef86f..51b4c94da383 100644 --- a/qiskit/primitives/base/base_sampler.py +++ b/qiskit/primitives/base/base_sampler.py @@ -79,7 +79,6 @@ from collections.abc import Iterable, Sequence from copy import copy from typing import cast -from warnings import warn import numpy as np @@ -101,6 +100,14 @@ class BaseSampler(BasePrimitive): __hash__ = None + @deprecate_argument( + "circuits", since="0.22", additional_msg="Instead, use the run() method to append objects." + ) + @deprecate_argument( + "parameters", + since="0.22", + additional_msg="Instead, use the run() method to append objects.", + ) def __init__( self, circuits: Iterable[QuantumCircuit] | QuantumCircuit | None = None, @@ -117,14 +124,6 @@ def __init__( Raises: ValueError: For mismatch of circuits and parameters list. """ - if circuits is not None or parameters is not None: - warn( - "The BaseSampler 'circuits', and `parameters` kwarg are deprecated " - "as of 0.22.0 and will be removed no earlier than 3 months after the " - "release date. You can use 'run' method to append objects.", - DeprecationWarning, - 2, - ) if isinstance(circuits, QuantumCircuit): circuits = (circuits,) self._circuits = [] if circuits is None else list(circuits) diff --git a/qiskit/providers/models/backendconfiguration.py b/qiskit/providers/models/backendconfiguration.py index 899fe6dc0f48..703ace0ddfaf 100644 --- a/qiskit/providers/models/backendconfiguration.py +++ b/qiskit/providers/models/backendconfiguration.py @@ -14,7 +14,6 @@ import re import copy import numbers -import warnings from typing import Dict, List, Any, Iterable, Tuple, Union from collections import defaultdict @@ -27,6 +26,7 @@ DriveChannel, MeasureChannel, ) +from qiskit.utils.deprecation import deprecate_argument class GateConfig: @@ -831,6 +831,14 @@ def acquire(self, qubit: int) -> AcquireChannel: raise BackendConfigurationError(f"Invalid index for {qubit}-qubit systems.") return AcquireChannel(qubit) + @deprecate_argument( + "qubits", + since="0.19.0", + additional_msg=( + "Instead, use the `qubits` argument. This method will now return accurate " + "ControlChannels determined by qubit indices." + ), + ) def control(self, qubits: Iterable[int] = None, channel: int = None) -> List[ControlChannel]: """ Return the secondary drive channel for the given qubit -- typically utilized for @@ -848,12 +856,6 @@ def control(self, qubits: Iterable[int] = None, channel: int = None) -> List[Con List of control channels. """ if channel is not None: - warnings.warn( - "The channel argument has been deprecated in favor of qubits. " - "This method will now return accurate ControlChannels determined " - "by qubit indices.", - DeprecationWarning, - ) qubits = [channel] try: if isinstance(qubits, list): diff --git a/qiskit/qobj/pulse_qobj.py b/qiskit/qobj/pulse_qobj.py index f14fa193c5a5..09334ecb64be 100644 --- a/qiskit/qobj/pulse_qobj.py +++ b/qiskit/qobj/pulse_qobj.py @@ -18,11 +18,12 @@ import copy import pprint from typing import Union, List -import warnings + import numpy from qiskit.qobj.common import QobjDictField from qiskit.qobj.common import QobjHeader from qiskit.qobj.common import QobjExperimentHeader +from qiskit.utils.deprecation import deprecate_argument class QobjMeasurementOption: @@ -282,6 +283,14 @@ def _to_complex(value: Union[List[float], complex]) -> complex: class PulseQobjConfig(QobjDictField): """A configuration for a Pulse Qobj.""" + @deprecate_argument( + "max_credits", + since="0.20.0", + additional_msg=( + "This argument has no effect on modern IBM Quantum systems, and no alternative is" + "necessary." + ), + ) def __init__( self, meas_level, @@ -344,13 +353,6 @@ def __init__( if max_credits is not None: self.max_credits = int(max_credits) - warnings.warn( - "The `max_credits` parameter is deprecated as of Qiskit Terra 0.20.0, " - "and will be removed in a future release. This parameter has no effect on " - "modern IBM Quantum systems, and no alternative is necessary.", - DeprecationWarning, - stacklevel=2, - ) if seed_simulator is not None: self.seed_simulator = int(seed_simulator) diff --git a/qiskit/qobj/qasm_qobj.py b/qiskit/qobj/qasm_qobj.py index 2afda7349e64..237a174576a9 100644 --- a/qiskit/qobj/qasm_qobj.py +++ b/qiskit/qobj/qasm_qobj.py @@ -15,10 +15,10 @@ import copy import pprint from types import SimpleNamespace -import warnings from qiskit.circuit.parameterexpression import ParameterExpression from qiskit.qobj.pulse_qobj import PulseQobjInstruction, PulseLibraryItem from qiskit.qobj.common import QobjDictField, QobjHeader +from qiskit.utils.deprecation import deprecate_argument class QasmQobjInstruction: @@ -279,6 +279,14 @@ def __eq__(self, other): class QasmQobjConfig(SimpleNamespace): """A configuration for a QASM Qobj.""" + @deprecate_argument( + "max_credits", + since="0.20.0", + additional_msg=( + "This argument has no effect on modern IBM Quantum systems, and no alternative is" + "necessary." + ), + ) def __init__( self, shots=None, @@ -328,13 +336,7 @@ def __init__( if max_credits is not None: self.max_credits = int(max_credits) - warnings.warn( - "The `max_credits` parameter is deprecated as of Qiskit Terra 0.20.0, " - "and will be removed in a future release. This parameter has no effect on " - "modern IBM Quantum systems, and no alternative is necessary.", - DeprecationWarning, - stacklevel=2, - ) + if seed_simulator is not None: self.seed_simulator = int(seed_simulator) diff --git a/qiskit/quantum_info/operators/symplectic/pauli_utils.py b/qiskit/quantum_info/operators/symplectic/pauli_utils.py index 0d2529fcb7fe..1bbf134bae62 100644 --- a/qiskit/quantum_info/operators/symplectic/pauli_utils.py +++ b/qiskit/quantum_info/operators/symplectic/pauli_utils.py @@ -13,10 +13,17 @@ PauliList utility functions. """ -import warnings from qiskit.quantum_info.operators.symplectic.pauli_list import PauliList +from qiskit.utils.deprecation import deprecate_argument +@deprecate_argument( + "pauli_basis", + since="0.22", + additional_msg=( + "The argument `pauli_list` has no effect as the function always returns a PauliList." + ), +) def pauli_basis(num_qubits, weight=False, pauli_list=None): """Return the ordered PauliTable or PauliList for the n-qubit Pauli basis. @@ -30,13 +37,7 @@ def pauli_basis(num_qubits, weight=False, pauli_list=None): Returns: PauliList: the Paulis for the basis """ - if pauli_list is not None: - warnings.warn( - "The `pauli_list` kwarg is deprecated as of Qiskit Terra 0.22 and " - "no longer has an effect as `pauli_basis` always returns a PauliList.", - DeprecationWarning, - stacklevel=2, - ) + del pauli_list pauli_1q = PauliList(["I", "X", "Y", "Z"]) if num_qubits == 1: return pauli_1q diff --git a/qiskit/synthesis/evolution/suzuki_trotter.py b/qiskit/synthesis/evolution/suzuki_trotter.py index cefedd07b9b4..82aa6696b5a1 100644 --- a/qiskit/synthesis/evolution/suzuki_trotter.py +++ b/qiskit/synthesis/evolution/suzuki_trotter.py @@ -14,11 +14,11 @@ from typing import Callable, Optional, Union -import warnings import numpy as np from qiskit.circuit.quantumcircuit import QuantumCircuit from qiskit.quantum_info.operators import SparsePauliOp, Pauli +from qiskit.utils.deprecation import deprecate_argument from .product_formula import ProductFormula @@ -51,6 +51,17 @@ class SuzukiTrotter(ProductFormula): `arXiv:math-ph/0506007 `_ """ + @deprecate_argument( + "order", + deprecation_description=( + "Setting `order` to an odd number in the constructor of SuzukiTrotter" + ), + additional_msg=( + "Suzuki product formulae are symmetric and therefore only defined for even orders." + ), + since="0.20.0", + predicate=lambda order: order % 2 == 1, + ) def __init__( self, order: int = 2, @@ -73,18 +84,10 @@ def __init__( Pauli string. Per default, a single Pauli evolution is decomopsed in a CX chain and a single qubit Z rotation. """ - if order % 2 == 1: - warnings.warn( - "SuzukiTrotter for odd orders is deprecated as of 0.20.0, and will be " - "removed no earlier than 3 months after that release date. Suzuki " - "product formulae are symmetric and therefore only defined for even" - "orders.", - DeprecationWarning, - stacklevel=2, - ) - # TODO replace deprecation warning by the following error and add unit test for odd - # raise ValueError("Suzuki product formulae are symmetric and therefore only defined " - # "for even orders.") + # TODO replace deprecation warning by the following error and add unit test for odd + # if order % 2 == 1: + # raise ValueError("Suzuki product formulae are symmetric and therefore only defined " + # "for even orders.") super().__init__(order, reps, insert_barriers, cx_structure, atomic_evolution) def synthesize(self, evolution): diff --git a/qiskit/transpiler/instruction_durations.py b/qiskit/transpiler/instruction_durations.py index a13d6e6e5629..26302e4f379c 100644 --- a/qiskit/transpiler/instruction_durations.py +++ b/qiskit/transpiler/instruction_durations.py @@ -11,7 +11,6 @@ # that they have been altered from the originals. """Durations of instructions, one of transpiler configurations.""" -import warnings from typing import Optional, List, Tuple, Union, Iterable, Set from qiskit.circuit import Barrier, Delay @@ -19,9 +18,16 @@ from qiskit.circuit.duration import duration_in_dt from qiskit.providers import Backend from qiskit.transpiler.exceptions import TranspilerError +from qiskit.utils.deprecation import deprecate_argument from qiskit.utils.units import apply_prefix +def _is_deprecated_qubits_argument(qubits: Union[int, List[int], Qubit, List[Qubit]]) -> bool: + if isinstance(qubits, (int, Qubit)): + qubits = [qubits] + return isinstance(qubits[0], Qubit) + + class InstructionDurations: """Helper class to provide durations of instructions for scheduling. @@ -158,6 +164,15 @@ def update(self, inst_durations: Optional["InstructionDurationsType"], dt: float return self + @deprecate_argument( + "qubits", + deprecation_description=( + "Using a Qubit or List[Qubit] for the `qubits` argument to InstructionDurations.get()" + ), + additional_msg="Instead, use an integer for the qubit index.", + since="0.19.0", + predicate=_is_deprecated_qubits_argument, + ) def get( self, inst: Union[str, Instruction], @@ -195,14 +210,6 @@ def get( qubits = [qubits] if isinstance(qubits[0], Qubit): - warnings.warn( - "Querying an InstructionDurations object with a Qubit " - "has been deprecated and will be removed in a future " - "release. Instead, query using the integer qubit " - "index.", - DeprecationWarning, - stacklevel=2, - ) qubits = [q.index for q in qubits] try: diff --git a/qiskit/transpiler/passes/calibration/rzx_builder.py b/qiskit/transpiler/passes/calibration/rzx_builder.py index 85d428db4e9e..c35b657d14ba 100644 --- a/qiskit/transpiler/passes/calibration/rzx_builder.py +++ b/qiskit/transpiler/passes/calibration/rzx_builder.py @@ -34,6 +34,7 @@ from qiskit.pulse.filters import filter_instructions from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap from qiskit.transpiler.target import Target +from qiskit.utils.deprecation import deprecate_argument from .base_builder import CalibrationBuilder from .exceptions import CalibrationNotAvailable @@ -63,6 +64,7 @@ class RZXCalibrationBuilder(CalibrationBuilder): angle. Additional details can be found in https://arxiv.org/abs/2012.11660. """ + @deprecate_argument("qubit_channel_mapping", since="0.22.0") def __init__( self, instruction_schedule_map: InstructionScheduleMap = None, @@ -86,14 +88,8 @@ def __init__( Raises: QiskitError: Instruction schedule map is not provided. """ + del qubit_channel_mapping super().__init__() - - if qubit_channel_mapping: - warnings.warn( - "'qubit_channel_mapping' is no longer used. This value is ignored.", - DeprecationWarning, - ) - self._inst_map = instruction_schedule_map self._verbose = verbose if target: diff --git a/qiskit/visualization/circuit/_utils.py b/qiskit/visualization/circuit/_utils.py index 5242e0c48d46..0edf80826bc6 100644 --- a/qiskit/visualization/circuit/_utils.py +++ b/qiskit/visualization/circuit/_utils.py @@ -14,7 +14,6 @@ import re from collections import OrderedDict -from warnings import warn import numpy as np @@ -32,6 +31,7 @@ from qiskit.circuit.tools import pi_check from qiskit.converters import circuit_to_dag from qiskit.utils import optionals as _optionals +from qiskit.utils.deprecation import deprecate_argument from ..exceptions import VisualizationError @@ -196,6 +196,7 @@ def get_bit_register(circuit, bit): return bit_loc.registers[0][0] if bit_loc.registers else None +@deprecate_argument("reverse_bits", since="0.22.0") def get_bit_reg_index(circuit, bit, reverse_bits=None): """Get the register for a bit if there is one, and the index of the bit from the top of the circuit, or the index of the bit within a register. @@ -210,15 +211,7 @@ def get_bit_reg_index(circuit, bit, reverse_bits=None): int: index of the bit from the top of the circuit int: index of the bit within the register, if there is a register """ - if reverse_bits is not None: - warn( - "The 'reverse_bits' kwarg to the function " - "~qiskit.visualization.utils.get_bit_reg_index " - "is deprecated as of 0.22.0 and will be removed no earlier than 3 months " - "after the release date.", - DeprecationWarning, - 2, - ) + del reverse_bits bit_loc = circuit.find_bit(bit) bit_index = bit_loc.index register, reg_index = bit_loc.registers[0] if bit_loc.registers else (None, None) @@ -291,6 +284,7 @@ def get_wire_label(drawer, register, index, layout=None, cregbundle=True): return wire_label +@deprecate_argument("reverse_bits", since="0.22.0") def get_condition_label_val(condition, circuit, cregbundle, reverse_bits=None): """Get the label and value list to display a condition @@ -304,15 +298,7 @@ def get_condition_label_val(condition, circuit, cregbundle, reverse_bits=None): str: label to display for the condition list(str): list of 1's and 0's indicating values of condition """ - if reverse_bits is not None: - warn( - "The 'reverse_bits' kwarg to the function " - "~qiskit.visualization.utils.get_condition_label_val " - "is deprecated as of 0.22.0 and will be removed no earlier than 3 months " - "after the release date.", - DeprecationWarning, - 2, - ) + del reverse_bits cond_is_bit = bool(isinstance(condition[0], Clbit)) cond_val = int(condition[1]) diff --git a/qiskit/visualization/circuit/latex.py b/qiskit/visualization/circuit/latex.py index 4f97ea34fc44..28fd029045bd 100644 --- a/qiskit/visualization/circuit/latex.py +++ b/qiskit/visualization/circuit/latex.py @@ -24,6 +24,7 @@ from qiskit.circuit.library.standard_gates import SwapGate, XGate, ZGate, RZZGate, U1Gate, PhaseGate from qiskit.circuit.measure import Measure from qiskit.circuit.tools.pi_check import pi_check +from qiskit.utils.deprecation import deprecate_argument from .qcstyle import load_style from ._utils import ( @@ -47,6 +48,23 @@ class QCircuitImage: Thanks to Eric Sabo for the initial implementation for Qiskit. """ + @deprecate_argument("gregs", since="0.20.0") + @deprecate_argument("cregs", since="0.20.0") + @deprecate_argument("layout", since="0.20.0") + @deprecate_argument("global_phase", since="0.20.0") + @deprecate_argument( + "circuit", + deprecation_description=( + "Not setting the `circuit` argument in the `QCircuitImage` constructor`" + ), + since="0.20.0", + predicate=lambda circuit: circuit is None, + additional_msg=( + "The `circuit` argument must be a valid QuantumCircuit. If `circuit` is set to `None`, " + "then the circuit will be built using the `qubits` and `clbits` arguments for " + "rendering the drawing." + ), + ) def __init__( self, qubits, @@ -85,52 +103,15 @@ def __init__( Raises: ImportError: If pylatexenc is not installed """ - if qregs is not None: - warn( - "The 'qregs' kwarg to the QCircuitImage class is deprecated " - "as of 0.20.0 and will be removed no earlier than 3 months " - "after the release date.", - DeprecationWarning, - 2, - ) - if cregs is not None: - warn( - "The 'cregs' kwarg to the QCircuitImage class is deprecated " - "as of 0.20.0 and will be removed no earlier than 3 months " - "after the release date.", - DeprecationWarning, - 2, - ) - if layout is not None: - warn( - "The 'layout' kwarg to the QCircuitImage class is deprecated " - "as of 0.20.0 and will be removed no earlier than 3 months " - "after the release date.", - DeprecationWarning, - 2, - ) - if global_phase is not None: - warn( - "The 'global_phase' kwarg to the QCircuitImage class is deprecated " - "as of 0.20.0 and will be removed no earlier than 3 months " - "after the release date.", - DeprecationWarning, - 2, - ) + del layout + del global_phase # This check should be removed when the 4 deprecations above are removed if circuit is None: - warn( - "The 'circuit' kwarg to the QCircuitImage class must be a valid " - "QuantumCircuit and not None. A new circuit is being created using " - "the qubits and clbits for rendering the drawing.", - DeprecationWarning, - 2, - ) circ = QuantumCircuit(qubits, clbits) - for reg in qregs: + for reg in qregs or []: bits = [qubits[circ._qubit_indices[q].index] for q in reg] circ.add_register(QuantumRegister(None, reg.name, list(bits))) - for reg in cregs: + for reg in cregs or []: bits = [clbits[circ._clbit_indices[q].index] for q in reg] circ.add_register(ClassicalRegister(None, reg.name, list(bits))) self._circuit = circ diff --git a/qiskit/visualization/circuit/matplotlib.py b/qiskit/visualization/circuit/matplotlib.py index 155afff43776..305adae326f3 100644 --- a/qiskit/visualization/circuit/matplotlib.py +++ b/qiskit/visualization/circuit/matplotlib.py @@ -33,6 +33,7 @@ from qiskit.extensions import Initialize from qiskit.circuit.tools.pi_check import pi_check from qiskit.utils import optionals as _optionals +from qiskit.utils.deprecation import deprecate_argument from .qcstyle import load_style from ._utils import ( @@ -64,6 +65,24 @@ class MatplotlibDrawer: _mathmode_regex = re.compile(r"(? Date: Mon, 27 Feb 2023 13:21:54 -0600 Subject: [PATCH 10/10] Rename to deprecate_arg --- .../algorithms/amplitude_amplifiers/grover.py | 4 ++-- qiskit/algorithms/amplitude_estimators/ae.py | 4 ++-- qiskit/algorithms/amplitude_estimators/fae.py | 4 ++-- qiskit/algorithms/amplitude_estimators/iae.py | 4 ++-- .../algorithms/amplitude_estimators/mlae.py | 4 ++-- qiskit/algorithms/optimizers/adam_amsgrad.py | 8 ++++---- qiskit/algorithms/optimizers/qnspsa.py | 6 +++--- .../hamiltonian_phase_estimation.py | 4 ++-- qiskit/algorithms/phase_estimators/ipe.py | 4 ++-- .../phase_estimators/phase_estimation.py | 4 ++-- qiskit/assembler/run_config.py | 4 ++-- qiskit/circuit/instructionset.py | 4 ++-- qiskit/compiler/assembler.py | 4 ++-- qiskit/dagcircuit/dagnode.py | 6 +++--- qiskit/execute_function.py | 12 ++++------- qiskit/primitives/base/base_estimator.py | 12 +++++------ qiskit/primitives/base/base_sampler.py | 8 ++++---- qiskit/providers/basicaer/qasm_simulator.py | 4 ++-- .../providers/models/backendconfiguration.py | 4 ++-- qiskit/pulse/library/symbolic_pulses.py | 4 ++-- qiskit/qobj/pulse_qobj.py | 4 ++-- qiskit/qobj/qasm_qobj.py | 4 ++-- qiskit/qpy/interface.py | 4 ++-- .../operators/symplectic/pauli_utils.py | 4 ++-- .../synthesis/two_qubit_decompose.py | 4 ++-- qiskit/synthesis/evolution/suzuki_trotter.py | 4 ++-- qiskit/transpiler/instruction_durations.py | 4 ++-- .../passes/calibration/rzx_builder.py | 4 ++-- qiskit/transpiler/target.py | 4 ++-- qiskit/utils/__init__.py | 4 ++-- qiskit/utils/deprecation.py | 4 ++-- qiskit/visualization/circuit/_utils.py | 6 +++--- qiskit/visualization/circuit/latex.py | 12 +++++------ qiskit/visualization/circuit/matplotlib.py | 14 ++++++------- qiskit/visualization/circuit/text.py | 12 +++++------ qiskit/visualization/counts_visualization.py | 4 ++-- qiskit/visualization/state_visualization.py | 12 +++++------ test/python/utils/test_deprecation.py | 20 +++++++++---------- 38 files changed, 114 insertions(+), 118 deletions(-) diff --git a/qiskit/algorithms/amplitude_amplifiers/grover.py b/qiskit/algorithms/amplitude_amplifiers/grover.py index 614a6b055836..2332ff643904 100644 --- a/qiskit/algorithms/amplitude_amplifiers/grover.py +++ b/qiskit/algorithms/amplitude_amplifiers/grover.py @@ -25,7 +25,7 @@ from qiskit.providers import Backend from qiskit.quantum_info import partial_trace from qiskit.utils import QuantumInstance, algorithm_globals -from qiskit.utils.deprecation import deprecate_argument, deprecate_function +from qiskit.utils.deprecation import deprecate_arg, deprecate_function from .amplification_problem import AmplificationProblem from .amplitude_amplifier import AmplitudeAmplifier, AmplitudeAmplifierResult @@ -112,7 +112,7 @@ class Grover(AmplitudeAmplifier): `arXiv:quant-ph/0005055 `_. """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/algorithms/amplitude_estimators/ae.py b/qiskit/algorithms/amplitude_estimators/ae.py index 9810ae644e56..63d853fabc79 100644 --- a/qiskit/algorithms/amplitude_estimators/ae.py +++ b/qiskit/algorithms/amplitude_estimators/ae.py @@ -23,7 +23,7 @@ from qiskit.providers import Backend from qiskit.primitives import BaseSampler from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_argument, deprecate_function +from qiskit.utils.deprecation import deprecate_arg, deprecate_function from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult from .ae_utils import pdf_a, derivative_log_pdf_a, bisect_max from .estimation_problem import EstimationProblem @@ -57,7 +57,7 @@ class AmplitudeEstimation(AmplitudeEstimator): `arXiv:1912.05559 `_. """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/algorithms/amplitude_estimators/fae.py b/qiskit/algorithms/amplitude_estimators/fae.py index bb6d0a8cede5..4ee9f4e9e055 100644 --- a/qiskit/algorithms/amplitude_estimators/fae.py +++ b/qiskit/algorithms/amplitude_estimators/fae.py @@ -20,7 +20,7 @@ from qiskit.providers import Backend from qiskit.primitives import BaseSampler from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_argument, deprecate_function +from qiskit.utils.deprecation import deprecate_arg, deprecate_function from qiskit.algorithms.exceptions import AlgorithmError from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult @@ -48,7 +48,7 @@ class FasterAmplitudeEstimation(AmplitudeEstimator): """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/algorithms/amplitude_estimators/iae.py b/qiskit/algorithms/amplitude_estimators/iae.py index 90609ceb0c8b..08bb7c59e4c4 100644 --- a/qiskit/algorithms/amplitude_estimators/iae.py +++ b/qiskit/algorithms/amplitude_estimators/iae.py @@ -22,7 +22,7 @@ from qiskit.providers import Backend from qiskit.primitives import BaseSampler from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_argument, deprecate_function +from qiskit.utils.deprecation import deprecate_arg, deprecate_function from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult from .estimation_problem import EstimationProblem @@ -50,7 +50,7 @@ class IterativeAmplitudeEstimation(AmplitudeEstimator): `arXiv:quant-ph/0005055 `_. """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/algorithms/amplitude_estimators/mlae.py b/qiskit/algorithms/amplitude_estimators/mlae.py index 96d83a02f900..11efbd4531a1 100644 --- a/qiskit/algorithms/amplitude_estimators/mlae.py +++ b/qiskit/algorithms/amplitude_estimators/mlae.py @@ -23,7 +23,7 @@ from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit from qiskit.utils import QuantumInstance from qiskit.primitives import BaseSampler -from qiskit.utils.deprecation import deprecate_argument, deprecate_function +from qiskit.utils.deprecation import deprecate_arg, deprecate_function from .amplitude_estimator import AmplitudeEstimator, AmplitudeEstimatorResult from .estimation_problem import EstimationProblem @@ -53,7 +53,7 @@ class in named ``MaximumLikelihoodAmplitudeEstimation``. `arXiv:quant-ph/0005055 `_. """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/algorithms/optimizers/adam_amsgrad.py b/qiskit/algorithms/optimizers/adam_amsgrad.py index 1e6c94c19b1a..08b5de5dad80 100644 --- a/qiskit/algorithms/optimizers/adam_amsgrad.py +++ b/qiskit/algorithms/optimizers/adam_amsgrad.py @@ -17,7 +17,7 @@ import csv import numpy as np -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from .optimizer import Optimizer, OptimizerSupportLevel, OptimizerResult, POINT # pylint: disable=invalid-name @@ -193,9 +193,9 @@ def load_params(self, load_dir: str) -> None: t = t[1:-1] self._t = np.fromstring(t, dtype=int, sep=" ") - @deprecate_argument("objective_function", new_alias="fun", since="0.19.0") - @deprecate_argument("initial_point", new_alias="fun", since="0.19.0") - @deprecate_argument("gradient_function", new_alias="jac", since="0.19.0") + @deprecate_arg("objective_function", new_alias="fun", since="0.19.0") + @deprecate_arg("initial_point", new_alias="fun", since="0.19.0") + @deprecate_arg("gradient_function", new_alias="jac", since="0.19.0") # pylint: disable=arguments-differ def minimize( self, diff --git a/qiskit/algorithms/optimizers/qnspsa.py b/qiskit/algorithms/optimizers/qnspsa.py index ac44c2fb32b2..6ce7e05f4b55 100644 --- a/qiskit/algorithms/optimizers/qnspsa.py +++ b/qiskit/algorithms/optimizers/qnspsa.py @@ -20,7 +20,7 @@ from qiskit.circuit import ParameterVector, QuantumCircuit from qiskit.opflow import StateFn, CircuitSampler, ExpectationBase from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from qiskit.primitives import BaseSampler, Sampler from qiskit.algorithms.state_fidelities import ComputeUncompute @@ -253,13 +253,13 @@ def settings(self) -> dict[str, Any]: return settings @staticmethod - @deprecate_argument( + @deprecate_arg( "backend", deprecation_description="Setting the argument `backend` in QNSPSA.get_fidelity()", since="0.22", pending=True, ) - @deprecate_argument( + @deprecate_arg( "expectation", deprecation_description="Setting the argument `expectation` in QNSPSA.get_fidelity()", since="0.22", diff --git a/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py b/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py index 6d1a7c896957..80e37a70d3a4 100644 --- a/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py +++ b/qiskit/algorithms/phase_estimators/hamiltonian_phase_estimation.py @@ -16,7 +16,7 @@ from qiskit import QuantumCircuit from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from qiskit.opflow import ( SummedOp, PauliOp, @@ -91,7 +91,7 @@ class HamiltonianPhaseEstimation: """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/algorithms/phase_estimators/ipe.py b/qiskit/algorithms/phase_estimators/ipe.py index 967d51a07def..fc40ed000b0b 100644 --- a/qiskit/algorithms/phase_estimators/ipe.py +++ b/qiskit/algorithms/phase_estimators/ipe.py @@ -22,7 +22,7 @@ from qiskit.circuit.classicalregister import ClassicalRegister from qiskit.providers import Backend from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from qiskit.algorithms.exceptions import AlgorithmError from .phase_estimator import PhaseEstimator from .phase_estimator import PhaseEstimatorResult @@ -39,7 +39,7 @@ class IterativePhaseEstimation(PhaseEstimator): qubit benchmark, `arxiv/quant-ph/0610214 `_ """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/algorithms/phase_estimators/phase_estimation.py b/qiskit/algorithms/phase_estimators/phase_estimation.py index f2e6cb934d50..01358098fd45 100644 --- a/qiskit/algorithms/phase_estimators/phase_estimation.py +++ b/qiskit/algorithms/phase_estimators/phase_estimation.py @@ -23,7 +23,7 @@ from qiskit.circuit.classicalregister import ClassicalRegister from qiskit.providers import Backend from qiskit.utils import QuantumInstance -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from qiskit.result import Result from qiskit.algorithms.exceptions import AlgorithmError from .phase_estimation_result import PhaseEstimationResult, _sort_phases @@ -81,7 +81,7 @@ class PhaseEstimation(PhaseEstimator): """ - @deprecate_argument( + @deprecate_arg( "quantum_instance", additional_msg="Instead, use the `sampler` argument.", since="0.22.0", diff --git a/qiskit/assembler/run_config.py b/qiskit/assembler/run_config.py index 386ad52d9346..cc02b9820eb2 100644 --- a/qiskit/assembler/run_config.py +++ b/qiskit/assembler/run_config.py @@ -14,7 +14,7 @@ from types import SimpleNamespace -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg class RunConfig(SimpleNamespace): @@ -31,7 +31,7 @@ class RunConfig(SimpleNamespace): parameter_binds (list[dict]): List of parameter bindings """ - @deprecate_argument( + @deprecate_arg( "max_credits", since="0.20.0", additional_msg=( diff --git a/qiskit/circuit/instructionset.py b/qiskit/circuit/instructionset.py index ccba996bbc54..f552a0a35296 100644 --- a/qiskit/circuit/instructionset.py +++ b/qiskit/circuit/instructionset.py @@ -18,7 +18,7 @@ from typing import Callable, Optional, Tuple, Union from qiskit.circuit.exceptions import CircuitError -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from .classicalregister import Clbit, ClassicalRegister from .operation import Operation from .quantumcircuitdata import CircuitInstruction @@ -92,7 +92,7 @@ class InstructionSet: __slots__ = ("_instructions", "_requester") - @deprecate_argument( + @deprecate_arg( "circuit_cregs", since="0.19.0", additional_msg=( diff --git a/qiskit/compiler/assembler.py b/qiskit/compiler/assembler.py index 1a3075eba052..f3d41a019931 100644 --- a/qiskit/compiler/assembler.py +++ b/qiskit/compiler/assembler.py @@ -29,7 +29,7 @@ from qiskit.pulse.channels import PulseChannel from qiskit.qobj import Qobj, QobjHeader from qiskit.qobj.utils import MeasLevel, MeasReturnType -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg logger = logging.getLogger(__name__) @@ -40,7 +40,7 @@ def _log_assembly_time(start_time, end_time): # TODO: parallelize over the experiments (serialize each separately, then add global header/config) -@deprecate_argument( +@deprecate_arg( "max_credits", since="0.20.0", additional_msg=( diff --git a/qiskit/dagcircuit/dagnode.py b/qiskit/dagcircuit/dagnode.py index 30f75b3f8d7c..a3ee5ca922a9 100644 --- a/qiskit/dagcircuit/dagnode.py +++ b/qiskit/dagcircuit/dagnode.py @@ -17,7 +17,7 @@ from typing import Iterable from qiskit.circuit import Qubit, Clbit -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg def _condition_as_indices(operation, bit_indices): @@ -50,7 +50,7 @@ def __str__(self): return str(id(self)) @staticmethod - @deprecate_argument( + @deprecate_arg( "bit_indices1", deprecation_description="Not setting bit_indices1 in DAGNode.semantic_eq()", additional_msg=( @@ -60,7 +60,7 @@ def __str__(self): since="0.21.0", predicate=lambda arg: arg is None, ) - @deprecate_argument( + @deprecate_arg( "bit_indices2", deprecation_description="Not setting bit_indices2 in DAGNode.semantic_eq()", additional_msg=( diff --git a/qiskit/execute_function.py b/qiskit/execute_function.py index c3b6974ea175..45cb585be24e 100644 --- a/qiskit/execute_function.py +++ b/qiskit/execute_function.py @@ -26,7 +26,7 @@ from qiskit.providers.backend import Backend from qiskit.pulse import Schedule, ScheduleBlock from qiskit.exceptions import QiskitError -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg logger = logging.getLogger(__name__) @@ -36,7 +36,7 @@ def _log_submission_time(start_time, end_time): logger.info(log_msg) -@deprecate_argument( +@deprecate_arg( "max_credits", since="0.20.0", additional_msg=( @@ -44,12 +44,8 @@ def _log_submission_time(start_time, end_time): "necessary." ), ) -@deprecate_argument( - "qobj_id", since="0.21.0", additional_msg="This argument has no effect anymore." -) -@deprecate_argument( - "qobj_header", since="0.21.0", additional_msg="This argument has no effect anymore." -) +@deprecate_arg("qobj_id", since="0.21.0", additional_msg="This argument has no effect anymore.") +@deprecate_arg("qobj_header", since="0.21.0", additional_msg="This argument has no effect anymore.") def execute( experiments, backend, diff --git a/qiskit/primitives/base/base_estimator.py b/qiskit/primitives/base/base_estimator.py index 1b12fe08733b..d3a8815b2eb7 100644 --- a/qiskit/primitives/base/base_estimator.py +++ b/qiskit/primitives/base/base_estimator.py @@ -93,7 +93,7 @@ from qiskit.providers import JobV1 as Job from qiskit.quantum_info.operators import SparsePauliOp from qiskit.quantum_info.operators.base_operator import BaseOperator -from qiskit.utils.deprecation import deprecate_argument, deprecate_function +from qiskit.utils.deprecation import deprecate_arg, deprecate_function from ..utils import _circuit_key, _observable_key, init_observable from .base_primitive import BasePrimitive @@ -108,15 +108,15 @@ class BaseEstimator(BasePrimitive): __hash__ = None - @deprecate_argument( + @deprecate_arg( "circuits", since="0.22", additional_msg="Instead, use the run() method to append objects." ) - @deprecate_argument( + @deprecate_arg( "observables", since="0.22", additional_msg="Instead, use the run() method to append objects.", ) - @deprecate_argument( + @deprecate_arg( "parameters", since="0.22", additional_msg="Instead, use the run() method to append objects.", @@ -371,8 +371,8 @@ def close(self): "Use the 'run' method instead.", since="0.22.0", ) - @deprecate_argument("circuit_indices", new_alias="circuits", since="0.21.0") - @deprecate_argument("observable_indices", new_alias="observables", since="0.21.0") + @deprecate_arg("circuit_indices", new_alias="circuits", since="0.21.0") + @deprecate_arg("observable_indices", new_alias="observables", since="0.21.0") def __call__( self, circuits: Sequence[int | QuantumCircuit], diff --git a/qiskit/primitives/base/base_sampler.py b/qiskit/primitives/base/base_sampler.py index 51b4c94da383..72ffee12446c 100644 --- a/qiskit/primitives/base/base_sampler.py +++ b/qiskit/primitives/base/base_sampler.py @@ -85,7 +85,7 @@ from qiskit.circuit import Parameter, QuantumCircuit from qiskit.circuit.parametertable import ParameterView from qiskit.providers import JobV1 as Job -from qiskit.utils.deprecation import deprecate_argument, deprecate_function +from qiskit.utils.deprecation import deprecate_arg, deprecate_function from ..utils import _circuit_key from .base_primitive import BasePrimitive @@ -100,10 +100,10 @@ class BaseSampler(BasePrimitive): __hash__ = None - @deprecate_argument( + @deprecate_arg( "circuits", since="0.22", additional_msg="Instead, use the run() method to append objects." ) - @deprecate_argument( + @deprecate_arg( "parameters", since="0.22", additional_msg="Instead, use the run() method to append objects.", @@ -283,7 +283,7 @@ def close(self): "Use run method instead.", since="0.22.0", ) - @deprecate_argument("circuit_indices", new_alias="circuits", since="0.21.0") + @deprecate_arg("circuit_indices", new_alias="circuits", since="0.21.0") def __call__( self, circuits: Sequence[int | QuantumCircuit], diff --git a/qiskit/providers/basicaer/qasm_simulator.py b/qiskit/providers/basicaer/qasm_simulator.py index 22ad8b466606..7c1231d99334 100644 --- a/qiskit/providers/basicaer/qasm_simulator.py +++ b/qiskit/providers/basicaer/qasm_simulator.py @@ -38,7 +38,7 @@ import numpy as np from qiskit.circuit.quantumcircuit import QuantumCircuit -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from qiskit.utils.multiprocessing import local_hardware_info from qiskit.providers.models import QasmBackendConfiguration from qiskit.result import Result @@ -374,7 +374,7 @@ def _validate_measure_sampling(self, experiment): # measure sampling is allowed self._sample_measure = True - @deprecate_argument( + @deprecate_arg( "qobj", deprecation_description="Using a qobj for the first argument to QasmSimulatorPy.run()", since="0.22.0", diff --git a/qiskit/providers/models/backendconfiguration.py b/qiskit/providers/models/backendconfiguration.py index 703ace0ddfaf..df4d7c46d27e 100644 --- a/qiskit/providers/models/backendconfiguration.py +++ b/qiskit/providers/models/backendconfiguration.py @@ -26,7 +26,7 @@ DriveChannel, MeasureChannel, ) -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg class GateConfig: @@ -831,7 +831,7 @@ def acquire(self, qubit: int) -> AcquireChannel: raise BackendConfigurationError(f"Invalid index for {qubit}-qubit systems.") return AcquireChannel(qubit) - @deprecate_argument( + @deprecate_arg( "qubits", since="0.19.0", additional_msg=( diff --git a/qiskit/pulse/library/symbolic_pulses.py b/qiskit/pulse/library/symbolic_pulses.py index dbd728b66c94..afa516d61293 100644 --- a/qiskit/pulse/library/symbolic_pulses.py +++ b/qiskit/pulse/library/symbolic_pulses.py @@ -29,7 +29,7 @@ from qiskit.pulse.library.pulse import Pulse from qiskit.pulse.library.waveform import Waveform from qiskit.utils import optionals as _optional -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg if _optional.HAS_SYMENGINE: import symengine as sym @@ -587,7 +587,7 @@ class ScalableSymbolicPulse(SymbolicPulse): :math:'\text{amp}\times\exp\left(i\times\text{angle}\right)' is compared. """ - @deprecate_argument( + @deprecate_arg( "amp", deprecation_description=( "Setting `amp` to a complex in the ScalableSymbolicPulse constructor" diff --git a/qiskit/qobj/pulse_qobj.py b/qiskit/qobj/pulse_qobj.py index 09334ecb64be..caa4d8738436 100644 --- a/qiskit/qobj/pulse_qobj.py +++ b/qiskit/qobj/pulse_qobj.py @@ -23,7 +23,7 @@ from qiskit.qobj.common import QobjDictField from qiskit.qobj.common import QobjHeader from qiskit.qobj.common import QobjExperimentHeader -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg class QobjMeasurementOption: @@ -283,7 +283,7 @@ def _to_complex(value: Union[List[float], complex]) -> complex: class PulseQobjConfig(QobjDictField): """A configuration for a Pulse Qobj.""" - @deprecate_argument( + @deprecate_arg( "max_credits", since="0.20.0", additional_msg=( diff --git a/qiskit/qobj/qasm_qobj.py b/qiskit/qobj/qasm_qobj.py index 237a174576a9..69422ace83d1 100644 --- a/qiskit/qobj/qasm_qobj.py +++ b/qiskit/qobj/qasm_qobj.py @@ -18,7 +18,7 @@ from qiskit.circuit.parameterexpression import ParameterExpression from qiskit.qobj.pulse_qobj import PulseQobjInstruction, PulseLibraryItem from qiskit.qobj.common import QobjDictField, QobjHeader -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg class QasmQobjInstruction: @@ -279,7 +279,7 @@ def __eq__(self, other): class QasmQobjConfig(SimpleNamespace): """A configuration for a QASM Qobj.""" - @deprecate_argument( + @deprecate_arg( "max_credits", since="0.20.0", additional_msg=( diff --git a/qiskit/qpy/interface.py b/qiskit/qpy/interface.py index fd76554b8d6c..a22ce5f20db3 100644 --- a/qiskit/qpy/interface.py +++ b/qiskit/qpy/interface.py @@ -25,7 +25,7 @@ from qiskit.qpy import formats, common, binary_io, type_keys from qiskit.qpy.exceptions import QpyError from qiskit.version import __version__ -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg # pylint: disable=invalid-name @@ -72,7 +72,7 @@ VERSION_PATTERN_REGEX = re.compile(VERSION_PATTERN, re.VERBOSE | re.IGNORECASE) -@deprecate_argument("circuits", new_alias="programs", since="0.21.0") +@deprecate_arg("circuits", new_alias="programs", since="0.21.0") def dump( programs: Union[List[QPY_SUPPORTED_TYPES], QPY_SUPPORTED_TYPES], file_obj: BinaryIO, diff --git a/qiskit/quantum_info/operators/symplectic/pauli_utils.py b/qiskit/quantum_info/operators/symplectic/pauli_utils.py index 1bbf134bae62..f157646db6ce 100644 --- a/qiskit/quantum_info/operators/symplectic/pauli_utils.py +++ b/qiskit/quantum_info/operators/symplectic/pauli_utils.py @@ -14,10 +14,10 @@ """ from qiskit.quantum_info.operators.symplectic.pauli_list import PauliList -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg -@deprecate_argument( +@deprecate_arg( "pauli_basis", since="0.22", additional_msg=( diff --git a/qiskit/quantum_info/synthesis/two_qubit_decompose.py b/qiskit/quantum_info/synthesis/two_qubit_decompose.py index c6ba88ba8b38..43d0d4a9e4be 100644 --- a/qiskit/quantum_info/synthesis/two_qubit_decompose.py +++ b/qiskit/quantum_info/synthesis/two_qubit_decompose.py @@ -43,7 +43,7 @@ OneQubitEulerDecomposer, DEFAULT_ATOL, ) -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg logger = logging.getLogger(__name__) @@ -1085,7 +1085,7 @@ def decomp3_supercontrolled(self, target): return U3r, U3l, U2r, U2l, U1r, U1l, U0r, U0l - @deprecate_argument("target", new_alias="unitary", since="0.23.0") + @deprecate_arg("target", new_alias="unitary", since="0.23.0") def __call__( self, unitary: Union[Operator, np.ndarray], diff --git a/qiskit/synthesis/evolution/suzuki_trotter.py b/qiskit/synthesis/evolution/suzuki_trotter.py index 82aa6696b5a1..cba416fa5fa3 100644 --- a/qiskit/synthesis/evolution/suzuki_trotter.py +++ b/qiskit/synthesis/evolution/suzuki_trotter.py @@ -18,7 +18,7 @@ from qiskit.circuit.quantumcircuit import QuantumCircuit from qiskit.quantum_info.operators import SparsePauliOp, Pauli -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from .product_formula import ProductFormula @@ -51,7 +51,7 @@ class SuzukiTrotter(ProductFormula): `arXiv:math-ph/0506007 `_ """ - @deprecate_argument( + @deprecate_arg( "order", deprecation_description=( "Setting `order` to an odd number in the constructor of SuzukiTrotter" diff --git a/qiskit/transpiler/instruction_durations.py b/qiskit/transpiler/instruction_durations.py index 26302e4f379c..28d649635309 100644 --- a/qiskit/transpiler/instruction_durations.py +++ b/qiskit/transpiler/instruction_durations.py @@ -18,7 +18,7 @@ from qiskit.circuit.duration import duration_in_dt from qiskit.providers import Backend from qiskit.transpiler.exceptions import TranspilerError -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from qiskit.utils.units import apply_prefix @@ -164,7 +164,7 @@ def update(self, inst_durations: Optional["InstructionDurationsType"], dt: float return self - @deprecate_argument( + @deprecate_arg( "qubits", deprecation_description=( "Using a Qubit or List[Qubit] for the `qubits` argument to InstructionDurations.get()" diff --git a/qiskit/transpiler/passes/calibration/rzx_builder.py b/qiskit/transpiler/passes/calibration/rzx_builder.py index c35b657d14ba..7f21ff0c8098 100644 --- a/qiskit/transpiler/passes/calibration/rzx_builder.py +++ b/qiskit/transpiler/passes/calibration/rzx_builder.py @@ -34,7 +34,7 @@ from qiskit.pulse.filters import filter_instructions from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap from qiskit.transpiler.target import Target -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from .base_builder import CalibrationBuilder from .exceptions import CalibrationNotAvailable @@ -64,7 +64,7 @@ class RZXCalibrationBuilder(CalibrationBuilder): angle. Additional details can be found in https://arxiv.org/abs/2012.11660. """ - @deprecate_argument("qubit_channel_mapping", since="0.22.0") + @deprecate_arg("qubit_channel_mapping", since="0.22.0") def __init__( self, instruction_schedule_map: InstructionScheduleMap = None, diff --git a/qiskit/transpiler/target.py b/qiskit/transpiler/target.py index 5d2c1a93d9f0..d94ac2e83ce5 100644 --- a/qiskit/transpiler/target.py +++ b/qiskit/transpiler/target.py @@ -35,7 +35,7 @@ from qiskit.transpiler.exceptions import TranspilerError from qiskit.transpiler.instruction_durations import InstructionDurations from qiskit.transpiler.timing_constraints import TimingConstraints -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg # import QubitProperties here to provide convenience alias for building a # full target @@ -203,7 +203,7 @@ class Target(Mapping): "_global_operations", ) - @deprecate_argument("aquire_alignment", new_alias="acquire_alignment", since="0.23.0") + @deprecate_arg("aquire_alignment", new_alias="acquire_alignment", since="0.23.0") def __init__( self, description=None, diff --git a/qiskit/utils/__init__.py b/qiskit/utils/__init__.py index ffda1bf930dc..752139af58ff 100644 --- a/qiskit/utils/__init__.py +++ b/qiskit/utils/__init__.py @@ -64,7 +64,7 @@ """ from .quantum_instance import QuantumInstance -from .deprecation import deprecate_argument, deprecate_arguments +from .deprecation import deprecate_arg, deprecate_arguments from .deprecation import deprecate_function from .multiprocessing import local_hardware_info from .multiprocessing import is_main_process @@ -93,7 +93,7 @@ "has_aer", "name_args", "algorithm_globals", - "deprecate_argument", + "deprecate_arg", "deprecate_arguments", "deprecate_function", "local_hardware_info", diff --git a/qiskit/utils/deprecation.py b/qiskit/utils/deprecation.py index 5f98ea993974..078b78dff45f 100644 --- a/qiskit/utils/deprecation.py +++ b/qiskit/utils/deprecation.py @@ -18,7 +18,7 @@ from typing import Any, Callable, ClassVar, Dict, Optional, Type -def deprecate_argument( +def deprecate_arg( name: str, *, since: str, @@ -108,7 +108,7 @@ def deprecate_arguments( *, since: Optional[str] = None, ): - """Deprecated in favor of `deprecate_argument` instead. + """Deprecated in favor of `deprecate_arg` instead. Args: kwarg_map: A dictionary of the old argument name to the new name. diff --git a/qiskit/visualization/circuit/_utils.py b/qiskit/visualization/circuit/_utils.py index 0edf80826bc6..27933755f6e2 100644 --- a/qiskit/visualization/circuit/_utils.py +++ b/qiskit/visualization/circuit/_utils.py @@ -31,7 +31,7 @@ from qiskit.circuit.tools import pi_check from qiskit.converters import circuit_to_dag from qiskit.utils import optionals as _optionals -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from ..exceptions import VisualizationError @@ -196,7 +196,7 @@ def get_bit_register(circuit, bit): return bit_loc.registers[0][0] if bit_loc.registers else None -@deprecate_argument("reverse_bits", since="0.22.0") +@deprecate_arg("reverse_bits", since="0.22.0") def get_bit_reg_index(circuit, bit, reverse_bits=None): """Get the register for a bit if there is one, and the index of the bit from the top of the circuit, or the index of the bit within a register. @@ -284,7 +284,7 @@ def get_wire_label(drawer, register, index, layout=None, cregbundle=True): return wire_label -@deprecate_argument("reverse_bits", since="0.22.0") +@deprecate_arg("reverse_bits", since="0.22.0") def get_condition_label_val(condition, circuit, cregbundle, reverse_bits=None): """Get the label and value list to display a condition diff --git a/qiskit/visualization/circuit/latex.py b/qiskit/visualization/circuit/latex.py index 28fd029045bd..b43933bc00fe 100644 --- a/qiskit/visualization/circuit/latex.py +++ b/qiskit/visualization/circuit/latex.py @@ -24,7 +24,7 @@ from qiskit.circuit.library.standard_gates import SwapGate, XGate, ZGate, RZZGate, U1Gate, PhaseGate from qiskit.circuit.measure import Measure from qiskit.circuit.tools.pi_check import pi_check -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from .qcstyle import load_style from ._utils import ( @@ -48,11 +48,11 @@ class QCircuitImage: Thanks to Eric Sabo for the initial implementation for Qiskit. """ - @deprecate_argument("gregs", since="0.20.0") - @deprecate_argument("cregs", since="0.20.0") - @deprecate_argument("layout", since="0.20.0") - @deprecate_argument("global_phase", since="0.20.0") - @deprecate_argument( + @deprecate_arg("gregs", since="0.20.0") + @deprecate_arg("cregs", since="0.20.0") + @deprecate_arg("layout", since="0.20.0") + @deprecate_arg("global_phase", since="0.20.0") + @deprecate_arg( "circuit", deprecation_description=( "Not setting the `circuit` argument in the `QCircuitImage` constructor`" diff --git a/qiskit/visualization/circuit/matplotlib.py b/qiskit/visualization/circuit/matplotlib.py index 305adae326f3..90d6971286bb 100644 --- a/qiskit/visualization/circuit/matplotlib.py +++ b/qiskit/visualization/circuit/matplotlib.py @@ -33,7 +33,7 @@ from qiskit.extensions import Initialize from qiskit.circuit.tools.pi_check import pi_check from qiskit.utils import optionals as _optionals -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from .qcstyle import load_style from ._utils import ( @@ -65,12 +65,12 @@ class MatplotlibDrawer: _mathmode_regex = re.compile(r"(? bool: return False -@deprecate_argument( +@deprecate_arg( "data", deprecation_description=( "Using plot_histogram() `data` argument with QuasiDistribution, ProbDistribution, or a " diff --git a/qiskit/visualization/state_visualization.py b/qiskit/visualization/state_visualization.py index 735a36769a2e..1b43d2815d7d 100644 --- a/qiskit/visualization/state_visualization.py +++ b/qiskit/visualization/state_visualization.py @@ -26,7 +26,7 @@ from qiskit.quantum_info.states.statevector import Statevector from qiskit.quantum_info.operators.symplectic import PauliList, SparsePauliOp from qiskit.quantum_info.states.densitymatrix import DensityMatrix -from qiskit.utils.deprecation import deprecate_argument +from qiskit.utils.deprecation import deprecate_arg from qiskit.utils import optionals as _optionals from qiskit.circuit.tools.pi_check import pi_check @@ -35,7 +35,7 @@ from .exceptions import VisualizationError -@deprecate_argument("rho", new_alias="state", since="0.15.1") +@deprecate_arg("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_state_hinton( state, title="", figsize=None, ax_real=None, ax_imag=None, *, rho=None, filename=None @@ -250,7 +250,7 @@ def plot_bloch_vector(bloch, title="", ax=None, figsize=None, coord_type="cartes return None -@deprecate_argument("rho", new_alias="state", since="0.15.1") +@deprecate_arg("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_bloch_multivector( state, title="", figsize=None, *, rho=None, reverse_bits=False, filename=None @@ -338,7 +338,7 @@ def plot_bloch_multivector( return fig.savefig(filename) -@deprecate_argument("rho", new_alias="state", since="0.15.1") +@deprecate_arg("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_state_city( state, @@ -595,7 +595,7 @@ def plot_state_city( return fig.savefig(filename) -@deprecate_argument("rho", new_alias="state", since="0.15.1") +@deprecate_arg("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call def plot_state_paulivec( state, title="", figsize=None, color=None, ax=None, *, rho=None, filename=None @@ -766,7 +766,7 @@ def phase_to_rgb(complex_number): return rgb -@deprecate_argument("rho", new_alias="state", since="0.15.1") +@deprecate_arg("rho", new_alias="state", since="0.15.1") @_optionals.HAS_MATPLOTLIB.require_in_call @_optionals.HAS_SEABORN.require_in_call def plot_state_qsphere( diff --git a/test/python/utils/test_deprecation.py b/test/python/utils/test_deprecation.py index 8aa8aff61a89..6886f866d8c7 100644 --- a/test/python/utils/test_deprecation.py +++ b/test/python/utils/test_deprecation.py @@ -16,7 +16,7 @@ from qiskit.utils.deprecation import ( _DeprecationMetadataEntry, deprecate_function, - deprecate_argument, + deprecate_arg, deprecate_arguments, ) @@ -25,17 +25,17 @@ class TestDeprecations(QiskitTestCase): """Test functions in ``utils.deprecation``.""" def test_deprecate_argument_metadata(self) -> None: - """Test that `@deprecate_argument` stores the correct metadata.""" + """Test that `@deprecate_arg` stores the correct metadata.""" - @deprecate_argument("arg1", since="9.99") - @deprecate_argument("arg2", pending=True, since="9.99") - @deprecate_argument( + @deprecate_arg("arg1", since="9.99") + @deprecate_arg("arg2", pending=True, since="9.99") + @deprecate_arg( "arg3", since="9.99", deprecation_description="Using the argument arg3", new_alias="new_arg3", ) - @deprecate_argument( + @deprecate_arg( "arg4", since="9.99", additional_msg="Instead, use foo.", @@ -131,16 +131,16 @@ def my_func() -> None: ) def test_deprecate_argument_runtime_warning(self) -> None: - """Test that `@deprecate_argument` warns whenever the arguments are used. + """Test that `@deprecate_arg` warns whenever the arguments are used. Also check these edge cases: * If `new_alias` is set, pass the old argument as the new alias. * If `predicate` is set, only warn if the predicate is True. """ - @deprecate_argument("arg1", since="9.99") - @deprecate_argument("arg2", new_alias="new_arg2", since="9.99") - @deprecate_argument("arg3", predicate=lambda arg3: arg3 == "deprecated value", since="9.99") + @deprecate_arg("arg1", since="9.99") + @deprecate_arg("arg2", new_alias="new_arg2", since="9.99") + @deprecate_arg("arg3", predicate=lambda arg3: arg3 == "deprecated value", since="9.99") def my_func(*, arg1: str = "a", new_arg2: str, arg3: str = "a") -> None: del arg1 del arg3