qiskit 1.3.3__cp39-abi3-win32.whl → 1.4.1__cp39-abi3-win32.whl

qiskit/VERSION.txt

@@ -1 +1 @@
-1.3.3
+1.4.1

qiskit/__init__.py

@@ -110,6 +110,7 @@ sys.modules["qiskit._accelerate.filter_op_nodes"] = _accelerate.filter_op_nodes
 sys.modules["qiskit._accelerate.twirling"] = _accelerate.twirling
 sys.modules["qiskit._accelerate.high_level_synthesis"] = _accelerate.high_level_synthesis
 sys.modules["qiskit._accelerate.remove_identity_equiv"] = _accelerate.remove_identity_equiv
+sys.modules["qiskit._accelerate.circuit_duration"] = _accelerate.circuit_duration
 
 from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
 

qiskit/circuit/bit.py

@@ -14,6 +14,7 @@
 Quantum bit and Classical bit objects.
 """
 import copy
+import warnings
 
 from qiskit.circuit.exceptions import CircuitError
 
@@ -57,6 +58,17 @@ class Bit:
             self._hash = hash((self._register, self._index))
             self._repr = f"{self.__class__.__name__}({self._register}, {self._index})"
 
+    def __init_subclass__(cls):
+        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
+        # them will be fixed, similar to if the classes had been marked as `final`.
+        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
+            warnings.warn(
+                "subclassing 'Bit' is not supported, and may not be possible in Qiskit 2.0",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return cls
+
     def __repr__(self):
         """Return the official string representing the bit."""
         if (self._register, self._index) == (None, None):

qiskit/circuit/classicalfunction/__init__.py

@@ -20,6 +20,10 @@ ClassicalFunction compiler (:mod:`qiskit.circuit.classicalfunction`)
 Overview
 ========
 
+.. warning::
+    
+    This module is deprecated as of Qiskit 1.4.0. It will be removed in the Qiskit 2.0 release.
+
 The classical function compiler provides the necessary tools to map a classical
 potentially irreversible functions into quantum circuits.  Below is a simple example of
 how to synthesize a simple boolean function defined using Python into a
@@ -111,7 +115,7 @@ Exceptions
    ClassicalFunctionCompilerTypeError
 
 """
-
+from qiskit.utils.deprecation import deprecate_func
 from .classicalfunction import ClassicalFunction
 from .exceptions import (
     ClassicalFunctionParseError,
@@ -121,6 +125,14 @@ from .exceptions import (
 from .boolean_expression import BooleanExpression
 
 
+@deprecate_func(
+    since="1.4",
+    removal_timeline="in Qiskit 2.0",
+    additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+    "bit-flip oracle by applying Hadamard gates on the target "
+    "qubit before and after the instruction, and conditioning."
+    "the instruction on the target qubit.",
+)
 def classical_function(func):
     """
     Parses and type checks the callable ``func`` to compile it into an ``ClassicalFunction``

qiskit/circuit/classicalfunction/boolean_expression.py

@@ -15,15 +15,24 @@
 from os.path import basename, isfile
 from typing import Callable, Optional
 
+from qiskit.utils.deprecation import deprecate_func
 from qiskit.circuit import QuantumCircuit
 from qiskit.utils.optionals import HAS_TWEEDLEDUM
 from .classical_element import ClassicalElement
 
 
-@HAS_TWEEDLEDUM.require_in_instance
 class BooleanExpression(ClassicalElement):
     """The Boolean Expression gate."""
 
+    @HAS_TWEEDLEDUM.require_in_instance
+    @deprecate_func(
+        since="1.4",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+        "bit-flip oracle by applying Hadamard gates on the target "
+        "qubit before and after the instruction, and conditioning."
+        "the instruction on the target qubit.",
+    )
     def __init__(self, expression: str, name: str = None, var_order: list = None) -> None:
         """
         Args:

qiskit/circuit/classicalfunction/classicalfunction.py

@@ -15,6 +15,7 @@
 import ast
 from typing import Callable, Optional
 
+from qiskit.utils.deprecation import deprecate_func
 from qiskit.circuit import QuantumCircuit, QuantumRegister
 from qiskit.exceptions import QiskitError
 from qiskit.utils.optionals import HAS_TWEEDLEDUM
@@ -23,10 +24,18 @@ from .classical_function_visitor import ClassicalFunctionVisitor
 from .utils import tweedledum2qiskit
 
 
-@HAS_TWEEDLEDUM.require_in_instance
 class ClassicalFunction(ClassicalElement):
     """Represent a classical function and its logic network."""
 
+    @HAS_TWEEDLEDUM.require_in_instance
+    @deprecate_func(
+        since="1.4",
+        removal_timeline="in Qiskit 2.0",
+        additional_msg="Use `PhaseOracle` instead, which can be turned into a "
+        "bit-flip oracle by applying Hadamard gates on the target "
+        "qubit before and after the instruction, and conditioning."
+        "the instruction on the target qubit.",
+    )
     def __init__(self, source, name=None):
         """Creates a ``ClassicalFunction`` from Python source code in ``source``.
 

qiskit/circuit/classicalfunction/exceptions.py

@@ -10,7 +10,13 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Exceptions for ClassicalFunction compiler"""
+"""Exceptions for ClassicalFunction compiler
+
+.. warning::
+    
+    This module is deprecated as of qiskit 1.4.0 version. It will be removed in the Qiskit 2.0 release.
+
+"""
 
 from qiskit.exceptions import QiskitError
 

qiskit/circuit/instruction.py

@@ -64,14 +64,20 @@ class Instruction(Operation):
     def __init__(self, name, num_qubits, num_clbits, params, duration=None, unit="dt", label=None):
         """Create a new instruction.
 
+        .. deprecated:: 1.3
+           The parameters ``duration`` and ``unit`` are deprecated since
+           Qiskit 1.3, and they will be removed in 2.0 or later.
+           An instruction's duration is defined in a backend's Target object.
+
         Args:
             name (str): instruction name
             num_qubits (int): instruction's qubit width
             num_clbits (int): instruction's clbit width
             params (list[int|float|complex|str|ndarray|list|ParameterExpression]):
                 list of parameters
-            duration (int or float): instruction's duration. it must be integer if ``unit`` is 'dt'
-            unit (str): time unit of duration
+            duration (int|float): (DEPRECATED) instruction's duration. it must be
+                an integer if ``unit`` is ``'dt'``
+            unit (str): (DEPRECATED) time unit of duration
             label (str or None): An optional label for identifying the instruction.
 
         Raises:

qiskit/circuit/library/generalized_gates/mcmt.py

@@ -49,7 +49,7 @@ class MCMT(QuantumCircuit):
     :class:`~qiskit.circuit.library.MCMTVChain`.
     """
 
-    @deprecate_func(since="1.3", additional_msg="Use MCMTGate instead.", pending=True)
+    @deprecate_func(since="1.4", additional_msg="Use MCMTGate instead.")
     def __init__(
         self,
         gate: Gate | Callable[[QuantumCircuit, circuit.Qubit, circuit.Qubit], circuit.Instruction],
@@ -76,7 +76,7 @@ class MCMT(QuantumCircuit):
             warnings.warn(
                 "Passing a callable to MCMT is pending deprecation since Qiskit 1.3. Pass a "
                 "gate instance or the gate name instead, e.g. pass 'h' instead of QuantumCircuit.h.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             gate = gate.__name__
@@ -84,7 +84,7 @@ class MCMT(QuantumCircuit):
             warnings.warn(
                 "Passing a QuantumCircuit is pending deprecation since Qiskit 1.3. Pass a gate "
                 "or turn the circuit into a gate using the ``to_gate`` method, instead.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             gate = gate.to_gate()
@@ -158,9 +158,8 @@ class MCMTVChain(MCMT):
     """
 
     @deprecate_func(
-        since="1.3",
+        since="1.4",
         additional_msg="Use MCMTGate with the V-chain synthesis plugin instead.",
-        pending=True,
     )
     def __init__(
         self,
@@ -277,7 +276,7 @@ class MCMTGate(ControlledGate):
             warnings.warn(
                 "Passing a controlled gate to MCMT is pending deprecation since Qiskit 1.3. Pass a "
                 "single-qubit gate instance or the gate name instead, e.g. pass 'h' instead of 'ch'.",
-                category=PendingDeprecationWarning,
+                category=DeprecationWarning,
                 stacklevel=2,
             )
             base_gate = gate.base_gate

qiskit/circuit/library/phase_oracle.py

@@ -63,31 +63,38 @@ class PhaseOracle(QuantumCircuit):
             var_order(list): A list with the order in which variables will be created.
                (default: by appearance)
         """
-        from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
-        from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
+        # ignore deprecation warning for BooleanExpression; implementation is changing in 2.0
+        import warnings
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
+            from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
 
-        if not isinstance(expression, ClassicalElement):
-            expression = BooleanExpression(expression, var_order=var_order)
+            if not isinstance(expression, ClassicalElement):
+                expression = BooleanExpression(expression, var_order=var_order)
 
-        self.boolean_expression = expression
+            self.boolean_expression = expression
 
-        if synthesizer is None:
+            if synthesizer is None:
 
-            def synthesizer(boolean_expression):
-                from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
-                from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
+                def synthesizer(boolean_expression):
+                    from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
+                    from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
 
-                truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
-                    output_bit=0
-                )
-                tweedledum_circuit = pkrm_synth(truth_table, {"pkrm_synth": {"phase_esop": True}})
-                return tweedledum2qiskit(tweedledum_circuit)
+                    truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
+                        output_bit=0
+                    )
+                    tweedledum_circuit = pkrm_synth(
+                        truth_table, {"pkrm_synth": {"phase_esop": True}}
+                    )
+                    return tweedledum2qiskit(tweedledum_circuit)
 
-        oracle = expression.synth(synthesizer=synthesizer)
+            oracle = expression.synth(synthesizer=synthesizer)
 
-        super().__init__(oracle.num_qubits, name="Phase Oracle")
+            super().__init__(oracle.num_qubits, name="Phase Oracle")
 
-        self.compose(oracle, inplace=True, copy=False)
+            self.compose(oracle, inplace=True, copy=False)
 
     def evaluate_bitstring(self, bitstring: str) -> bool:
         """Evaluate the oracle on a bitstring.

qiskit/circuit/quantumcircuit.py

@@ -40,6 +40,7 @@ from typing import (
 import numpy as np
 from qiskit._accelerate.circuit import CircuitData
 from qiskit._accelerate.circuit import StandardGate
+from qiskit._accelerate.circuit_duration import compute_estimated_duration
 from qiskit.exceptions import QiskitError
 from qiskit.utils.multiprocessing import is_main_process
 from qiskit.circuit.instruction import Instruction
@@ -156,6 +157,8 @@ class QuantumCircuit:
     :attr:`data`              List of individual :class:`CircuitInstruction`\\ s that make up the
                               circuit.
     :attr:`duration`          Total duration of the circuit, added by scheduling transpiler passes.
+                              This attribute is deprecated and :meth:`.estimate_duration` should
+                              be used instead.
 
     :attr:`layout`            Hardware layout and routing information added by the transpiler.
     :attr:`num_ancillas`      The number of ancilla qubits in the circuit.
@@ -903,8 +906,9 @@ class QuantumCircuit:
 
     If a :class:`QuantumCircuit` has been scheduled as part of a transpilation pipeline, the timing
     information for individual qubits can be accessed.  The whole-circuit timing information is
-    available through the :attr:`duration`, :attr:`unit` and :attr:`op_start_times` attributes.
+    available through the :meth:`estimate_duration` method and :attr:`op_start_times` attribute.
 
+    .. automethod:: estimate_duration
     .. automethod:: qubit_duration
     .. automethod:: qubit_start_time
     .. automethod:: qubit_stop_time
@@ -6651,6 +6655,65 @@ class QuantumCircuit:
         else:
             return 0  # If there are no instructions over bits
 
+    def estimate_duration(self, target, unit: str = "s") -> int | float:
+        """Estimate the duration of a scheduled circuit
+
+        This method computes the estimate of the circuit duration by finding
+        the longest duration path in the circuit based on the durations
+        provided by a given target. This method only works for simple circuits
+        that have no control flow or other classical feed-forward operations.
+
+        Args:
+            target (Target): The :class:`.Target` instance that contains durations for
+                the instructions if the target is missing duration data for any of the
+                instructions in the circuit an :class:`.QiskitError` will be raised. This
+                should be the same target object used as the target for transpilation.
+            unit: The unit to return the duration in. This defaults to "s" for seconds
+                but this can be a supported SI prefix for seconds returns. For example
+                setting this to "n" will return in unit of nanoseconds. Supported values
+                of this type are "f", "p", "n", "u", "µ", "m", "k", "M", "G", "T", and
+                "P". Additionally, a value of "dt" is also accepted to output an integer
+                in units of "dt". For this to function "dt" must be specified in the
+                ``target``.
+
+        Returns:
+            The estimated duration for the execution of a single shot of the circuit in
+            the specified unit.
+
+        Raises:
+            QiskitError: If the circuit is not scheduled or contains other
+                details that prevent computing an estimated duration from
+                (such as parameterized delay).
+        """
+        from qiskit.converters import circuit_to_dag
+
+        dur = compute_estimated_duration(circuit_to_dag(self), target)
+        if unit == "s":
+            return dur
+        if unit == "dt":
+            from qiskit.circuit.duration import duration_in_dt  # pylint: disable=cyclic-import
+
+            return duration_in_dt(dur, target.dt)
+
+        prefix_dict = {
+            "f": 1e-15,
+            "p": 1e-12,
+            "n": 1e-9,
+            "u": 1e-6,
+            "µ": 1e-6,
+            "m": 1e-3,
+            "k": 1e3,
+            "M": 1e6,
+            "G": 1e9,
+            "T": 1e12,
+            "P": 1e15,
+        }
+        if unit not in prefix_dict:
+            raise QiskitError(
+                f"Specified unit: {unit} is not a valid/supported SI prefix, 's', or 'dt'"
+            )
+        return dur / prefix_dict[unit]
+
 
 class _OuterCircuitScopeInterface(CircuitScopeInterface):
     # This is an explicit interface-fulfilling object friend of QuantumCircuit that acts as its

qiskit/circuit/register.py

@@ -17,7 +17,9 @@ Base register reference object.
 """
 
 from __future__ import annotations
+
 import itertools
+import warnings
 import numpy as np
 
 from qiskit.circuit.exceptions import CircuitError
@@ -125,6 +127,17 @@ class Register:
             # until first access.
             self._bit_indices = None
 
+    def __init_subclass__(cls):
+        # In Qiskit 2.0, `Bit` and `Register` will move to Rust space, and the allowable types of
+        # them will be fixed, similar to if the classes had been marked as `final`.
+        if cls.__module__.split(".", 2)[0] != __name__.split(".", 2)[0]:
+            warnings.warn(
+                "subclassing 'Register' is not supported, and may not be possible in Qiskit 2.0",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return cls
+
     @property
     def name(self):
         """Get the register name."""

qiskit/compiler/assembler.py

@@ -261,14 +261,22 @@ def _assemble(
 
     # assemble either circuits or schedules
     if all(isinstance(exp, QuantumCircuit) for exp in experiments):
-        run_config = _parse_circuit_args(
-            parameter_binds,
-            backend,
-            meas_level,
-            meas_return,
-            parametric_pulses,
-            **run_config_common_dict,
-        )
+        with warnings.catch_warnings():
+            # Internally calls deprecated BasicSimulator.configuration()`
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=r".+\.basic_provider\.basic_simulator\.BasicSimulator\.configuration.+",
+                module="qiskit",
+            )
+            run_config = _parse_circuit_args(
+                parameter_binds,
+                backend,
+                meas_level,
+                meas_return,
+                parametric_pulses,
+                **run_config_common_dict,
+            )
 
         # If circuits are parameterized, bind parameters and remove from run_config
         bound_experiments, run_config = _expand_parameters(

qiskit/dagcircuit/dagdependency_v2.py

@@ -13,6 +13,7 @@
 """_DAGDependencyV2 class for representing non-commutativity in a circuit.
 """
 
+import itertools
 import math
 from collections import OrderedDict, defaultdict, namedtuple
 from typing import Dict, List, Generator, Any
@@ -344,7 +345,6 @@ class _DAGDependencyV2:
             op=operation,
             qargs=qargs,
             cargs=cargs,
-            dag=self,
         )
         new_node._node_id = self._multi_graph.add_node(new_node)
         self._update_edges()
@@ -459,7 +459,9 @@ class _DAGDependencyV2:
         """
 
         def _key(x):
-            return x.sort_key
+            return ",".join(
+                f"{self.find_bit(q).index:04d}" for q in itertools.chain(x.qargs, x.cargs)
+            )
 
         if key is None:
             key = _key

qiskit/passmanager/passmanager.py

@@ -14,6 +14,7 @@
 from __future__ import annotations
 
 import logging
+import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterable
 from itertools import chain
@@ -29,6 +30,8 @@ from .compilation_status import PropertySet, WorkflowStatus, PassManagerState
 
 logger = logging.getLogger(__name__)
 
+_MISSING = object()
+
 
 class BasePassManager(ABC):
     """Pass manager base class."""
@@ -174,6 +177,8 @@ class BasePassManager(ABC):
         in_programs: Any | list[Any],
         callback: Callable = None,
         num_processes: int = None,
+        *,
+        property_set: object = _MISSING,
         **kwargs,
     ) -> Any:
         """Run all the passes on the specified ``in_programs``.
@@ -211,12 +216,25 @@ class BasePassManager(ABC):
                 execution is enabled. This argument overrides ``num_processes`` in the user
                 configuration file, and the ``QISKIT_NUM_PROCS`` environment variable. If set
                 to ``None`` the system default or local user configuration will be used.
-
+            property_set: Currently a key that will be interpreted as all other arbitrary
+                ``kwargs``.  In Qiskit 2.0, this will instead seed the :class:`.PropertySet` of the
+                compilation (but does not do so in this version).
             kwargs: Arbitrary arguments passed to the compiler frontend and backend.
 
         Returns:
             The transformed program(s).
         """
+        if property_set is not _MISSING:
+            warnings.warn(
+                "From Qiskit 2.0, 'property_set' will be a reserved keyword argument of"
+                " 'BasePassManager.run', and not passed on to the conversion functions."
+                " This subclass of 'BasePassManager' needs to use a different keyword argument"
+                " for passing on this data.",
+                FutureWarning,
+                stacklevel=2,
+            )
+            kwargs["property_set"] = property_set
+
         if not self._tasks and not kwargs and callback is None:
             return in_programs
 

qiskit/primitives/backend_estimator_v2.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import math
+import warnings
 from collections import defaultdict
 from collections.abc import Iterable
 from dataclasses import dataclass
@@ -131,12 +132,28 @@ class BackendEstimatorV2(BaseEstimatorV2):
         options: dict | None = None,
     ):
         """
+        .. deprecated:: 1.4
+            The method ``BackendEstimatorV2.__init__`` will stop supporting inputs of type
+            :class:`.BackendV1` in the `backend` parameter in a future release no
+            earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should
+            move to :class:`.BackendV2`.
+
         Args:
             backend: The backend to run the primitive on.
             options: The options to control the default precision (``default_precision``),
                 the operator grouping (``abelian_grouping``), and
                 the random seed for the simulator (``seed_simulator``).
         """
+
+        if not isinstance(backend, BackendV2):
+            warnings.warn(
+                "The method `BackendEstimatorV2.__init__` will stop supporting inputs of "
+                f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
+                "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
+                "should move to `BackendV2`.",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
         self._backend = backend
         self._options = Options(**options) if options else Options()
 

qiskit/primitives/backend_sampler_v2.py

@@ -123,11 +123,26 @@ class BackendSamplerV2(BaseSamplerV2):
         options: dict | None = None,
     ):
         """
+        .. deprecated:: 1.4
+            The method ``BackendSamplerV2.__init__`` will stop supporting inputs of type
+            :class:`.BackendV1` in the `backend` parameter in a future release no
+            earlier than 2.0. :class:`.BackendV1` is deprecated and implementations should
+            move to :class:`.BackendV2`.
+
         Args:
             backend: The backend to run the primitive on.
             options: The options to control the default shots (``default_shots``) and
                 the random seed for the simulator (``seed_simulator``).
         """
+        if not isinstance(backend, BackendV2):
+            warnings.warn(
+                "The method `BackendSamplerV2.__init__` will stop supporting inputs of "
+                f"type `BackendV1` ( {backend} ) in the `backend` parameter in a future "
+                "release no earlier than 2.0. `BackendV1` is deprecated and implementations "
+                "should move to `BackendV2`.",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
         self._backend = backend
         self._options = Options(**options) if options else Options()
 

qiskit/providers/backend_compat.py

@@ -25,6 +25,7 @@ from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 from qiskit.providers.models.pulsedefaults import PulseDefaults
 from qiskit.providers.options import Options
 from qiskit.providers.exceptions import BackendPropertyError
+from qiskit.utils import deprecate_func
 from qiskit.utils.deprecate_pulse import deprecate_pulse_arg, deprecate_pulse_dependency
 
 
@@ -59,9 +60,19 @@ def convert_to_target(
     Returns:
         A ``Target`` instance.
     """
-    return _convert_to_target(
-        configuration, properties, defaults, custom_name_mapping, add_delay, filter_faulty
-    )
+    # If a deprecated error is raised during the conversion, we should not return the
+    # deprecation warning to the user,as it is not actionable for them.
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            category=DeprecationWarning,
+            message=".*``qiskit.providers.exceptions.BackendPropertyError``",
+            module="qiskit",
+        )
+        target = _convert_to_target(
+            configuration, properties, defaults, custom_name_mapping, add_delay, filter_faulty
+        )
+    return target
 
 
 def _convert_to_target(
@@ -368,6 +379,12 @@ class BackendV2Converter(BackendV2):
         )
     """
 
+    @deprecate_func(
+        since="1.4",
+        removal_timeline="in the 2.0 release",
+        additional_msg="Since ``BackendV1`` is deprecated, this conversion tool from BackendV1 to "
+        "BackendV2 is going to be removed with BackendV1.",
+    )
     def __init__(
         self,
         backend: BackendV1,
@@ -426,14 +443,32 @@ class BackendV2Converter(BackendV2):
         :rtype: Target
         """
         if self._target is None:
-            self._target = _convert_to_target(
-                configuration=self._config,
-                properties=self._properties,
-                defaults=self._defaults,
-                custom_name_mapping=self._name_mapping,
-                add_delay=self._add_delay,
-                filter_faulty=self._filter_faulty,
-            )
+            # If a deprecated error is raised during the conversion,
+            # we should not return the deprecation warning to the user,
+            # as it is not actionable for them.
+            with warnings.catch_warnings():
+                warnings.filterwarnings(
+                    "ignore",
+                    category=DeprecationWarning,
+                    message=".*``qiskit.providers.exceptions.BackendPropertyError``",
+                    module="qiskit",
+                )
+                # convert_to_target is deprecated along BackendV2Converter
+                # They both need to be removed at the same time
+                warnings.filterwarnings(
+                    "ignore",
+                    category=DeprecationWarning,
+                    message=r".+qiskit\.providers\.backend_compat\.convert_to_target.+",
+                    module="qiskit",
+                )
+                self._target = _convert_to_target(
+                    configuration=self._config,
+                    properties=self._properties,
+                    defaults=self._defaults,
+                    custom_name_mapping=self._name_mapping,
+                    add_delay=self._add_delay,
+                    filter_faulty=self._filter_faulty,
+                )
         return self._target
 
     @property