qiskit 1.3.0b1__cp39-abi3-win32.whl → 1.3.0rc2__cp39-abi3-win32.whl

qiskit/primitives/backend_sampler_v2.py

@@ -17,12 +17,13 @@ from __future__ import annotations
 import warnings
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Iterable
+from typing import Any, Iterable, Union
 
 import numpy as np
 from numpy.typing import NDArray
 
 from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
 from qiskit.primitives.backend_estimator import _run_circuits
 from qiskit.primitives.base import BaseSamplerV2
 from qiskit.primitives.containers import (
@@ -53,6 +54,11 @@ class Options:
     Default: None.
     """
 
+    run_options: dict[str, Any] | None = None
+    """A dictionary of options to pass to the backend's ``run()`` method.
+    Default: None (no option passed to backend's ``run`` method)
+    """
+
 
 @dataclass
 class _MeasureInfo:
@@ -62,6 +68,16 @@ class _MeasureInfo:
     start: int
 
 
+ResultMemory = Union[list[str], list[list[float]], list[list[list[float]]]]
+"""Type alias for possible level 2 and level 1 result memory formats. For level
+2, the format is a list of bit strings. For level 1, format can be either a
+list of I/Q pairs (list with two floats) for each memory slot if using
+``meas_return=avg`` or a list of of lists of I/Q pairs if using
+``meas_return=single`` with the outer list indexing shot number and the inner
+list indexing memory slot.
+"""
+
+
 class BackendSamplerV2(BaseSamplerV2):
     """Evaluates bitstrings for provided quantum circuits
 
@@ -91,6 +107,9 @@ class BackendSamplerV2(BaseSamplerV2):
     * ``seed_simulator``: The seed to use in the simulator. If None, a random seed will be used.
       Default: None.
 
+    * ``run_options``: A dictionary of options to pass through to the ``run()``
+      method of the wrapped :class:`~.BackendV2` instance.
+
     .. note::
 
         This class requires a backend that supports ``memory`` option.
@@ -165,19 +184,27 @@ class BackendSamplerV2(BaseSamplerV2):
         for circuits in bound_circuits:
             flatten_circuits.extend(np.ravel(circuits).tolist())
 
+        run_opts = self._options.run_options or {}
         # run circuits
         results, _ = _run_circuits(
             flatten_circuits,
             self._backend,
+            clear_metadata=False,
             memory=True,
             shots=shots,
             seed_simulator=self._options.seed_simulator,
+            **run_opts,
         )
         result_memory = _prepare_memory(results)
 
         # pack memory to an ndarray of uint8
         results = []
         start = 0
+        meas_level = (
+            None
+            if self._options.run_options is None
+            else self._options.run_options.get("meas_level")
+        )
         for pub, bound in zip(pubs, bound_circuits):
             meas_info, max_num_bytes = _analyze_circuit(pub.circuit)
             end = start + bound.size
@@ -189,6 +216,7 @@ class BackendSamplerV2(BaseSamplerV2):
                     meas_info,
                     max_num_bytes,
                     pub.circuit.metadata,
+                    meas_level,
                 )
             )
             start = end
@@ -197,28 +225,43 @@ class BackendSamplerV2(BaseSamplerV2):
 
     def _postprocess_pub(
         self,
-        result_memory: list[list[str]],
+        result_memory: list[ResultMemory],
         shots: int,
         shape: tuple[int, ...],
         meas_info: list[_MeasureInfo],
         max_num_bytes: int,
         circuit_metadata: dict,
+        meas_level: int | None,
     ) -> SamplerPubResult:
-        """Converts the memory data into an array of bit arrays with the shape of the pub."""
-        arrays = {
-            item.creg_name: np.zeros(shape + (shots, item.num_bytes), dtype=np.uint8)
-            for item in meas_info
-        }
-        memory_array = _memory_array(result_memory, max_num_bytes)
-
-        for samples, index in zip(memory_array, np.ndindex(*shape)):
-            for item in meas_info:
-                ary = _samples_to_packed_array(samples, item.num_bits, item.start)
-                arrays[item.creg_name][index] = ary
-
-        meas = {
-            item.creg_name: BitArray(arrays[item.creg_name], item.num_bits) for item in meas_info
-        }
+        """Converts the memory data into a sampler pub result
+
+        For level 2 data, the memory data are stored in an array of bit arrays
+        with the shape of the pub. For level 1 data, the data are stored in a
+        complex numpy array.
+        """
+        if meas_level == 2 or meas_level is None:
+            arrays = {
+                item.creg_name: np.zeros(shape + (shots, item.num_bytes), dtype=np.uint8)
+                for item in meas_info
+            }
+            memory_array = _memory_array(result_memory, max_num_bytes)
+
+            for samples, index in zip(memory_array, np.ndindex(*shape)):
+                for item in meas_info:
+                    ary = _samples_to_packed_array(samples, item.num_bits, item.start)
+                    arrays[item.creg_name][index] = ary
+
+            meas = {
+                item.creg_name: BitArray(arrays[item.creg_name], item.num_bits)
+                for item in meas_info
+            }
+        elif meas_level == 1:
+            raw = np.array(result_memory)
+            cplx = raw[..., 0] + 1j * raw[..., 1]
+            cplx = np.reshape(cplx, (*shape, *cplx.shape[1:]))
+            meas = {item.creg_name: cplx for item in meas_info}
+        else:
+            raise QiskitError(f"Unsupported meas_level: {meas_level}")
         return SamplerPubResult(
             DataBin(**meas, shape=shape),
             metadata={"shots": shots, "circuit_metadata": circuit_metadata},
@@ -248,7 +291,7 @@ def _analyze_circuit(circuit: QuantumCircuit) -> tuple[list[_MeasureInfo], int]:
     return meas_info, _min_num_bytes(max_num_bits)
 
 
-def _prepare_memory(results: list[Result]) -> list[list[str]]:
+def _prepare_memory(results: list[Result]) -> list[ResultMemory]:
     """Joins splitted results if exceeding max_experiments"""
     lst = []
     for res in results:

qiskit/primitives/base/base_estimator.py

@@ -92,7 +92,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
         # calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
         job = estimator.run([psi1], [H1], [theta1])
         job_result = job.result() # It will block until the job finishes.
-        print(f"The primitive-job finished with result {job_result}"))
+        print(f"The primitive-job finished with result {job_result}")
 
         # calculate [ <psi1(theta1)|H1|psi1(theta1)>,
         #             <psi2(theta2)|H2|psi2(theta2)>,
@@ -144,7 +144,7 @@ class BaseEstimatorV1(BasePrimitive, Generic[T]):
 
         .. code-block:: python
 
-            values = parameter_values[i].
+            values = parameter_values[i]
 
         Args:
             circuits: one or more circuit objects.

qiskit/primitives/containers/data_bin.py

@@ -34,14 +34,22 @@ class DataBin(ShapedMixin):
 
     .. code-block:: python
 
+        import numpy as np
+        from qiskit.primitives import DataBin, BitArray
+
         data = DataBin(
-            alpha=BitArray.from_bitstrings(["0010"]),
+            alpha=BitArray.from_samples(["0010"]),
             beta=np.array([1.2])
         )
 
         print("alpha data:", data.alpha)
         print("beta data:", data.beta)
 
+    .. code-block::
+
+        alpha data: BitArray(<shape=(), num_shots=1, num_bits=2>)
+        beta data: [1.2]
+
     """
 
     __slots__ = ("_data", "_shape")

qiskit/primitives/statevector_sampler.py

@@ -287,6 +287,6 @@ def _final_measurement_mapping(circuit: QuantumCircuit) -> dict[tuple[ClassicalR
 
 def _has_control_flow(circuit: QuantumCircuit) -> bool:
     return any(
-        isinstance((op := instruction.operation), ControlFlowOp) or op.condition
+        isinstance((op := instruction.operation), ControlFlowOp) or op._condition
         for instruction in circuit
     )

qiskit/primitives/utils.py

@@ -82,7 +82,7 @@ def init_observable(observable: BaseOperator | str) -> SparsePauliOp:
     since="1.2",
     additional_msg="Use ``QuantumCircuit.layout`` and ``SparsePauliOp.apply_layout`` "
     + "to adjust an operator for a layout. Otherwise, use ``mthree.utils.final_measurement_mapping``. "
-    + "See https://qiskit-extensions.github.io/mthree/apidocs/utils.html for details.",
+    + "See <https://qiskit.github.io/qiskit-addon-mthree/apidocs/utils> for details.",
 )
 def final_measurement_mapping(circuit: QuantumCircuit) -> dict[int, int]:
     """Return the final measurement mapping for the circuit.

qiskit/providers/__init__.py

@@ -160,7 +160,7 @@ steps for writing a provider are:
    interacting with a running job.
 
 For a simple example of a provider, see the
-`qiskit-aqt-provider <https://github.com/Qiskit-Partners/qiskit-aqt-provider>`__
+`qiskit-aqt-provider <https://github.com/qiskit-community/qiskit-aqt-provider>`__
 
 Provider
 --------
@@ -307,7 +307,7 @@ Custom Basis Gates
 
            def _define(self):
                qc = QuantumCircuit(1)
-               q.ry(np.pi / 2, 0)
+               qc.ry(np.pi / 2, 0)
                self.definition = qc
 
    The key thing to ensure is that for any custom gates in your Backend's basis set
@@ -664,7 +664,7 @@ that abstract away the mechanics of getting the best result efficiently, to
 concentrate on higher level applications using these outputs.
 
 For example, if your backends were well suited to leverage
-`mthree <https://github.com/Qiskit-Partners/mthree/>`__ measurement
+`mthree <https://github.com/Qiskit/qiskit-addon-mthree>`__ measurement
 mitigation to improve the quality of the results, you could implement a
 provider-specific :class:`~.Sampler` implementation that leverages the
 ``M3Mitigation`` class internally to run the circuits and return

qiskit/providers/backend.py

@@ -24,6 +24,7 @@ from qiskit.providers.provider import Provider
 from qiskit.providers.models.backendstatus import BackendStatus
 from qiskit.circuit.gate import Instruction
 from qiskit.utils import deprecate_func
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
 class Backend:
@@ -485,10 +486,16 @@ class BackendV2(Backend, ABC):
         raise NotImplementedError
 
     @property
+    @deprecate_pulse_dependency(is_property=True)
     def instruction_schedule_map(self):
         """Return the :class:`~qiskit.pulse.InstructionScheduleMap` for the
         instructions defined in this backend's target."""
-        return self.target.instruction_schedule_map()
+        return self._instruction_schedule_map
+
+    @property
+    def _instruction_schedule_map(self):
+        """An alternative private path to be used internally to avoid pulse deprecation warnings."""
+        return self.target._get_instruction_schedule_map()
 
     def qubit_properties(
         self, qubit: Union[int, List[int]]
@@ -524,6 +531,7 @@ class BackendV2(Backend, ABC):
             return self.target.qubit_properties[qubit]
         return [self.target.qubit_properties[q] for q in qubit]
 
+    @deprecate_pulse_dependency
     def drive_channel(self, qubit: int):
         """Return the drive channel for the given qubit.
 
@@ -539,6 +547,7 @@ class BackendV2(Backend, ABC):
         """
         raise NotImplementedError
 
+    @deprecate_pulse_dependency
     def measure_channel(self, qubit: int):
         """Return the measure stimulus channel for the given qubit.
 
@@ -554,6 +563,7 @@ class BackendV2(Backend, ABC):
         """
         raise NotImplementedError
 
+    @deprecate_pulse_dependency
     def acquire_channel(self, qubit: int):
         """Return the acquisition channel for the given qubit.
 
@@ -569,6 +579,7 @@ class BackendV2(Backend, ABC):
         """
         raise NotImplementedError
 
+    @deprecate_pulse_dependency
     def control_channel(self, qubits: Iterable[int]):
         """Return the secondary drive channel for the given qubit
 

qiskit/providers/backend_compat.py

@@ -25,10 +25,13 @@ 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.deprecate_pulse import deprecate_pulse_arg, deprecate_pulse_dependency
+
 
 logger = logging.getLogger(__name__)
 
 
+@deprecate_pulse_arg("defaults")
 def convert_to_target(
     configuration: BackendConfiguration,
     properties: BackendProperties = None,
@@ -46,7 +49,7 @@ def convert_to_target(
     Args:
         configuration: Backend configuration as ``BackendConfiguration``
         properties: Backend property dictionary or ``BackendProperties``
-        defaults: Backend pulse defaults dictionary or ``PulseDefaults``
+        defaults: DEPRECATED. Backend pulse defaults dictionary or ``PulseDefaults``
         custom_name_mapping: A name mapping must be supplied for the operation
             not included in Qiskit Standard Gate name mapping, otherwise the operation
             will be dropped in the resulting ``Target`` object.
@@ -56,7 +59,20 @@ def convert_to_target(
     Returns:
         A ``Target`` instance.
     """
+    return _convert_to_target(
+        configuration, properties, defaults, custom_name_mapping, add_delay, filter_faulty
+    )
+
 
+def _convert_to_target(
+    configuration: BackendConfiguration,
+    properties: BackendProperties = None,
+    defaults: PulseDefaults = None,
+    custom_name_mapping: Optional[Dict[str, Any]] = None,
+    add_delay: bool = True,
+    filter_faulty: bool = True,
+):
+    """An alternative private path to avoid pulse deprecations"""
     # importing packages where they are needed, to avoid cyclic-import.
     # pylint: disable=cyclic-import
     from qiskit.transpiler.target import (
@@ -265,7 +281,7 @@ def convert_to_target(
 
                 entry = inst_sched_map._get_calibration_entry(name, qubits)
                 try:
-                    prop_name_map[name][qubits].calibration = entry
+                    prop_name_map[name][qubits]._calibration_prop = entry
                 except AttributeError:
                     # if instruction properties are "None", add entry
                     prop_name_map[name].update({qubits: InstructionProperties(None, None, entry)})
@@ -410,7 +426,7 @@ class BackendV2Converter(BackendV2):
         :rtype: Target
         """
         if self._target is None:
-            self._target = convert_to_target(
+            self._target = _convert_to_target(
                 configuration=self._config,
                 properties=self._properties,
                 defaults=self._defaults,
@@ -436,15 +452,19 @@ class BackendV2Converter(BackendV2):
     def meas_map(self) -> List[List[int]]:
         return self._config.meas_map
 
+    @deprecate_pulse_dependency
     def drive_channel(self, qubit: int):
         return self._config.drive(qubit)
 
+    @deprecate_pulse_dependency
     def measure_channel(self, qubit: int):
         return self._config.measure(qubit)
 
+    @deprecate_pulse_dependency
     def acquire_channel(self, qubit: int):
         return self._config.acquire(qubit)
 
+    @deprecate_pulse_dependency
     def control_channel(self, qubits: Iterable[int]):
         return self._config.control(qubits)
 

qiskit/providers/basic_provider/basic_simulator.py

@@ -48,6 +48,7 @@ from qiskit.providers.options import Options
 from qiskit.qobj import QasmQobj, QasmQobjConfig, QasmQobjExperiment
 from qiskit.result import Result
 from qiskit.transpiler import Target
+from qiskit.utils.deprecation import deprecate_func
 
 from .basic_provider_job import BasicProviderJob
 from .basic_provider_tools import single_gate_matrix
@@ -212,6 +213,14 @@ class BasicSimulator(BackendV2):
                 )
         return target
 
+    @deprecate_func(
+        since="1.3.0",
+        removal_timeline="in Qiskit 2.0.0",
+        additional_msg="The `BackendConfiguration` class is part of the deprecated `BackendV1` "
+        "workflow, and no longer necessary for `BackendV2`. The individual configuration elements "
+        "can be retrieved directly from the backend or from the contained `Target` instance "
+        "(`backend.target)`).",
+    )
     def configuration(self) -> BackendConfiguration:
         """Return the simulator backend configuration.
 
@@ -248,7 +257,7 @@ class BasicSimulator(BackendV2):
                 backend_name=self.name,
                 backend_version=self.backend_version,
                 n_qubits=self.num_qubits,
-                basis_gates=self.target.operation_names,
+                basis_gates=list(self.target.operation_names),
                 gates=gates,
                 local=True,
                 simulator=True,
@@ -532,7 +541,8 @@ class BasicSimulator(BackendV2):
                     "initial_statevector": np.array([1, 0, 0, 1j]) / math.sqrt(2),
                 }
         """
-        # TODO: replace assemble with new run flow
+        # TODO: replace assemble with new run flow. If this is not achieved before 2.0,
+        # see removal note on `def _assemble`, L192 of qiskit/compiler/assembler.py
         from qiskit.compiler.assembler import _assemble
 
         out_options = {}

qiskit/providers/fake_provider/fake_pulse_backend.py

@@ -14,6 +14,8 @@
 Fake backend abstract class for mock backends supporting OpenPulse.
 """
 
+import warnings
+
 from qiskit.exceptions import QiskitError
 from qiskit.providers.models.backendconfiguration import PulseBackendConfiguration
 from qiskit.providers.models.pulsedefaults import PulseDefaults
@@ -30,7 +32,10 @@ class FakePulseBackend(FakeQasmBackend):
     def defaults(self):
         """Returns a snapshot of device defaults"""
         if not self._defaults:
-            self._set_defaults_from_json()
+            with warnings.catch_warnings():
+                warnings.simplefilter(action="ignore", category=DeprecationWarning)
+                # Filter deprecation warnings emitted from Qiskit Pulse
+                self._set_defaults_from_json()
         return self._defaults
 
     def _set_defaults_from_json(self):

qiskit/providers/fake_provider/generic_backend_v2.py

@@ -42,6 +42,7 @@ from qiskit.qobj.converters.pulse_instruction import QobjToInstructionConverter
 from qiskit.pulse.calibration_entries import PulseQobjDef
 from qiskit.providers.models.pulsedefaults import MeasurementKernel, Discriminator
 from qiskit.qobj.pulse_qobj import QobjMeasurementOption
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency, deprecate_pulse_arg
 
 # Noise default values/ranges for duration and error of supported
 # instructions. There are two possible formats:
@@ -518,6 +519,8 @@ class GenericBackendV2(BackendV2):
     transpilation.
     """
 
+    @deprecate_pulse_arg("pulse_channels")
+    @deprecate_pulse_arg("calibrate_instructions")
     def __init__(
         self,
         num_qubits: int,
@@ -560,7 +563,7 @@ class GenericBackendV2(BackendV2):
             control_flow: Flag to enable control flow directives on the target
                 (defaults to False).
 
-            calibrate_instructions: Instruction calibration settings, this argument
+            calibrate_instructions: DEPRECATED. Instruction calibration settings, this argument
                 supports both boolean and :class:`.InstructionScheduleMap` as
                 input types, and is ``None`` by default:
 
@@ -578,7 +581,7 @@ class GenericBackendV2(BackendV2):
 
             seed: Optional seed for generation of default values.
 
-            pulse_channels: If true, sets default pulse channel information on the backend.
+            pulse_channels: DEPRECATED. If true, sets default pulse channel information on the backend.
 
             noise_info: If true, associates gates and qubits with default noise information.
         """
@@ -648,14 +651,17 @@ class GenericBackendV2(BackendV2):
         return self._target.concurrent_measurements
 
     def _build_default_channels(self) -> None:
-        channels_map = {
-            "acquire": {(i,): [pulse.AcquireChannel(i)] for i in range(self.num_qubits)},
-            "drive": {(i,): [pulse.DriveChannel(i)] for i in range(self.num_qubits)},
-            "measure": {(i,): [pulse.MeasureChannel(i)] for i in range(self.num_qubits)},
-            "control": {
-                (edge): [pulse.ControlChannel(i)] for i, edge in enumerate(self._coupling_map)
-            },
-        }
+        with warnings.catch_warnings():
+            warnings.simplefilter(action="ignore", category=DeprecationWarning)
+            # Prevent pulse deprecation warnings from being emitted
+            channels_map = {
+                "acquire": {(i,): [pulse.AcquireChannel(i)] for i in range(self.num_qubits)},
+                "drive": {(i,): [pulse.DriveChannel(i)] for i in range(self.num_qubits)},
+                "measure": {(i,): [pulse.MeasureChannel(i)] for i in range(self.num_qubits)},
+                "control": {
+                    (edge): [pulse.ControlChannel(i)] for i, edge in enumerate(self._coupling_map)
+                },
+            }
         setattr(self, "channels_map", channels_map)
 
     def _get_noise_defaults(self, name: str, num_qubits: int) -> tuple:
@@ -867,27 +873,33 @@ class GenericBackendV2(BackendV2):
             duration, error = (
                 noise_params
                 if len(noise_params) == 2
-                else (self._rng.uniform(*noise_params[:2]), self._rng.uniform(*noise_params[2:]))
-            )
-            if (
-                calibration_inst_map is not None
-                and instruction.name not in ["reset", "delay"]
-                and qarg in calibration_inst_map.qubits_with_instruction(instruction.name)
-            ):
-                # Do NOT call .get method. This parses Qobj immediately.
-                # This operation is computationally expensive and should be bypassed.
-                calibration_entry = calibration_inst_map._get_calibration_entry(
-                    instruction.name, qargs
+                else (
+                    self._rng.uniform(*noise_params[:2]),
+                    self._rng.uniform(*noise_params[2:]),
                 )
-            else:
-                calibration_entry = None
-            if duration is not None and len(noise_params) > 2:
-                # Ensure exact conversion of duration from seconds to dt
-                dt = _QUBIT_PROPERTIES["dt"]
-                rounded_duration = round(duration / dt) * dt
-                # Clamp rounded duration to be between min and max values
-                duration = max(noise_params[0], min(rounded_duration, noise_params[1]))
-            props.update({qargs: InstructionProperties(duration, error, calibration_entry)})
+            )
+            with warnings.catch_warnings():
+                warnings.simplefilter(action="ignore", category=DeprecationWarning)
+                # Prevent pulse deprecations from being emitted
+                if (
+                    calibration_inst_map is not None
+                    and instruction.name not in ["reset", "delay"]
+                    and qarg in calibration_inst_map.qubits_with_instruction(instruction.name)
+                ):
+                    # Do NOT call .get method. This parses Qobj immediately.
+                    # This operation is computationally expensive and should be bypassed.
+                    calibration_entry = calibration_inst_map._get_calibration_entry(
+                        instruction.name, qargs
+                    )
+                else:
+                    calibration_entry = None
+                if duration is not None and len(noise_params) > 2:
+                    # Ensure exact conversion of duration from seconds to dt
+                    dt = _QUBIT_PROPERTIES["dt"]
+                    rounded_duration = round(duration / dt) * dt
+                    # Clamp rounded duration to be between min and max values
+                    duration = max(noise_params[0], min(rounded_duration, noise_params[1]))
+                props.update({qargs: InstructionProperties(duration, error, calibration_entry)})
         self._target.add_instruction(instruction, props)
 
         # The "measure" instruction calibrations need to be added qubit by qubit, once the
@@ -990,6 +1002,7 @@ class GenericBackendV2(BackendV2):
         else:
             return BasicSimulator._default_options()
 
+    @deprecate_pulse_dependency
     def drive_channel(self, qubit: int):
         drive_channels_map = getattr(self, "channels_map", {}).get("drive", {})
         qubits = (qubit,)
@@ -997,6 +1010,7 @@ class GenericBackendV2(BackendV2):
             return drive_channels_map[qubits][0]
         return None
 
+    @deprecate_pulse_dependency
     def measure_channel(self, qubit: int):
         measure_channels_map = getattr(self, "channels_map", {}).get("measure", {})
         qubits = (qubit,)
@@ -1004,6 +1018,7 @@ class GenericBackendV2(BackendV2):
             return measure_channels_map[qubits][0]
         return None
 
+    @deprecate_pulse_dependency
     def acquire_channel(self, qubit: int):
         acquire_channels_map = getattr(self, "channels_map", {}).get("acquire", {})
         qubits = (qubit,)
@@ -1011,6 +1026,7 @@ class GenericBackendV2(BackendV2):
             return acquire_channels_map[qubits][0]
         return None
 
+    @deprecate_pulse_dependency
     def control_channel(self, qubits: Iterable[int]):
         control_channels_map = getattr(self, "channels_map", {}).get("control", {})
         qubits = tuple(qubits)

qiskit/providers/models/pulsedefaults.py

@@ -18,6 +18,7 @@ from typing import Any, Dict, List
 from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap, PulseQobjDef
 from qiskit.qobj import PulseLibraryItem, PulseQobjInstruction
 from qiskit.qobj.converters import QobjToInstructionConverter
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
 class MeasurementKernel:
@@ -169,6 +170,7 @@ class PulseDefaults:
 
     _data = {}
 
+    @deprecate_pulse_dependency
     def __init__(
         self,
         qubit_freq_est: List[float],