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

qiskit/circuit/quantumcircuit.py

@@ -47,7 +47,6 @@ from qiskit.circuit.gate import Gate
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.utils import deprecate_func
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 from . import _classical_resource_map
 from .controlflow import ControlFlowOp, _builder_utils
 from .controlflow.builder import CircuitScopeInterface, ControlFlowBuilderBlock
@@ -71,7 +70,6 @@ from .quantumcircuitdata import QuantumCircuitData, CircuitInstruction
 from .delay import Delay
 from .store import Store
 
-
 if typing.TYPE_CHECKING:
     import qiskit  # pylint: disable=cyclic-import
     from qiskit.transpiler.layout import TranspileLayout  # pylint: disable=cyclic-import
@@ -878,7 +876,7 @@ class QuantumCircuit:
 
        qc.count_ops()
 
-    .. code-block:: text
+    .. parsed-literal::
 
        OrderedDict([('cx', 8), ('h', 5), ('x', 3), ('swap', 3)])
 
@@ -1147,41 +1145,21 @@ class QuantumCircuit:
         for var, initial in declarations:
             self.add_var(var, initial)
 
-        self._duration = None
-        self._unit = "dt"
+        self.duration: int | float | None = None
+        """The total duration of the circuit, set by a scheduling transpiler pass.  Its unit is
+        specified by :attr:`unit`."""
+        self.unit = "dt"
+        """The unit that :attr:`duration` is specified in."""
         self.metadata = {} if metadata is None else metadata
         """Arbitrary user-defined metadata for the circuit.
-
+ 
         Qiskit will not examine the content of this mapping, but it will pass it through the
         transpiler and reattach it to the output, so you can track your own metadata."""
 
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
-    def duration(self):
-        """The total duration of the circuit, set by a scheduling transpiler pass.  Its unit is
-        specified by :attr:`unit`."""
-        return self._duration
-
-    @duration.setter
-    def duration(self, value: int | float | None):
-        self._duration = value
-
-    @property
-    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0", is_property=True)
-    def unit(self):
-        """The unit that :attr:`duration` is specified in."""
-        return self._unit
-
-    @unit.setter
-    def unit(self, value):
-        self._unit = value
-
     @classmethod
-    def _from_circuit_data(
-        cls, data: CircuitData, add_regs: bool = False, name: str | None = None
-    ) -> typing.Self:
+    def _from_circuit_data(cls, data: CircuitData, add_regs: bool = False) -> typing.Self:
         """A private constructor from rust space circuit data."""
-        out = QuantumCircuit(name=name)
+        out = QuantumCircuit()
 
         if data.num_qubits > 0:
             if add_regs:
@@ -1343,17 +1321,15 @@ class QuantumCircuit:
         return self._op_start_times
 
     @property
-    @deprecate_pulse_dependency(is_property=True)
     def calibrations(self) -> dict:
         """Return calibration dictionary.
 
         The custom pulse definition of a given gate is of the form
         ``{'gate_name': {(qubits, params): schedule}}``
         """
-        return self._calibrations_prop
+        return dict(self._calibrations)
 
     @calibrations.setter
-    @deprecate_pulse_dependency(is_property=True)
     def calibrations(self, calibrations: dict):
         """Set the circuit calibration data from a dictionary of calibration definition.
 
@@ -1361,37 +1337,18 @@ class QuantumCircuit:
             calibrations (dict): A dictionary of input in the format
                ``{'gate_name': {(qubits, gate_params): schedule}}``
         """
-        self._calibrations_prop = calibrations
-
-    @property
-    def _calibrations_prop(self) -> dict:
-        """An alternative private path to the `calibrations` property for
-        avoiding deprecation warnings."""
-        return dict(self._calibrations)
-
-    @_calibrations_prop.setter
-    def _calibrations_prop(self, calibrations: dict):
-        """An alternative private path to the `calibrations` property for
-        avoiding deprecation warnings."""
         self._calibrations = defaultdict(dict, calibrations)
 
-    @deprecate_pulse_dependency
     def has_calibration_for(self, instruction: CircuitInstruction | tuple):
         """Return True if the circuit has a calibration defined for the instruction context. In this
         case, the operation does not need to be translated to the device basis.
         """
-
-        return self._has_calibration_for(instruction)
-
-    def _has_calibration_for(self, instruction: CircuitInstruction | tuple):
-        """An alternative private path to the `has_calibration_for` method for
-        avoiding deprecation warnings."""
         if isinstance(instruction, CircuitInstruction):
             operation = instruction.operation
             qubits = instruction.qubits
         else:
             operation, qubits, _ = instruction
-        if not self._calibrations_prop or operation.name not in self._calibrations_prop:
+        if not self.calibrations or operation.name not in self.calibrations:
             return False
         qubits = tuple(self.qubits.index(qubit) for qubit in qubits)
         params = []
@@ -1401,7 +1358,7 @@ class QuantumCircuit:
             else:
                 params.append(p)
         params = tuple(params)
-        return (qubits, params) in self._calibrations_prop[operation.name]
+        return (qubits, params) in self.calibrations[operation.name]
 
     @property
     def metadata(self) -> dict:
@@ -1537,7 +1494,7 @@ class QuantumCircuit:
 
             input:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌───┐
                 q_0: ┤ H ├─────■──────
@@ -1547,7 +1504,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                                  ┌───┐
                 q_0: ─────■──────┤ H ├
@@ -1581,7 +1538,7 @@ class QuantumCircuit:
 
             input:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌───┐
                 a_0: ┤ H ├──■─────────────────
@@ -1597,7 +1554,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                                          ┌───┐
                 b_0: ────────────────────┤ X ├
@@ -1651,7 +1608,7 @@ class QuantumCircuit:
 
             input:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌───┐
                 q_0: ┤ H ├─────■──────
@@ -1661,7 +1618,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                                   ┌───┐
                 q_0: ──────■──────┤ H ├
@@ -1903,7 +1860,7 @@ class QuantumCircuit:
 
                 >>> lhs.compose(rhs, qubits=[3, 2], inplace=True)
 
-            .. code-block:: text
+            .. parsed-literal::
 
                             ┌───┐                   ┌─────┐                ┌───┐
                 lqr_1_0: ───┤ H ├───    rqr_0: ──■──┤ Tdg ├    lqr_1_0: ───┤ H ├───────────────
@@ -2042,7 +1999,7 @@ class QuantumCircuit:
                 )
             edge_map.update(zip(other.clbits, dest._cbit_argument_conversion(clbits)))
 
-        for gate, cals in other._calibrations_prop.items():
+        for gate, cals in other.calibrations.items():
             dest._calibrations[gate].update(cals)
 
         dest.duration = None
@@ -2104,14 +2061,14 @@ class QuantumCircuit:
                 is_control_flow = isinstance(n_op, ControlFlowOp)
                 if (
                     not is_control_flow
-                    and (condition := getattr(n_op, "_condition", None)) is not None
+                    and (condition := getattr(n_op, "condition", None)) is not None
                 ):
                     n_op = n_op.copy() if n_op is op and copy else n_op
                     n_op.condition = variable_mapper.map_condition(condition)
                 elif is_control_flow:
                     n_op = n_op.replace_blocks(recurse_block(block) for block in n_op.blocks)
                     if isinstance(n_op, (IfElseOp, WhileLoopOp)):
-                        n_op.condition = variable_mapper.map_condition(n_op._condition)
+                        n_op.condition = variable_mapper.map_condition(n_op.condition)
                     elif isinstance(n_op, SwitchCaseOp):
                         n_op.target = variable_mapper.map_target(n_op.target)
                 elif isinstance(n_op, Store):
@@ -2151,10 +2108,10 @@ class QuantumCircuit:
 
         Remember that in the little-endian convention the leftmost operation will be at the bottom
         of the circuit. See also
-        `the docs <https://docs.quantum.ibm.com/guides/construct-circuits>`__
+        `the docs <https://docs.quantum.ibm.com/build/circuit-construction>`__
         for more information.
 
-        .. code-block:: text
+        .. parsed-literal::
 
                  ┌────────┐        ┌─────┐          ┌─────┐
             q_0: ┤ bottom ├ ⊗ q_0: ┤ top ├  = q_0: ─┤ top ├──
@@ -2735,10 +2692,7 @@ class QuantumCircuit:
         """
         if isinstance(name_or_param, str):
             return self.get_parameter(name_or_param, None) is not None
-        return (
-            isinstance(name_or_param, Parameter)
-            and self.get_parameter(name_or_param.name, None) == name_or_param
-        )
+        return self.get_parameter(name_or_param.name) == name_or_param
 
     @typing.overload
     def get_var(self, name: str, default: T) -> Union[expr.Var, T]: ...
@@ -3257,33 +3211,40 @@ class QuantumCircuit:
 
     def decompose(
         self,
-        gates_to_decompose: (
-            str | Type[Instruction] | Sequence[str | Type[Instruction]] | None
-        ) = None,
+        gates_to_decompose: Type[Gate] | Sequence[Type[Gate]] | Sequence[str] | str | None = None,
         reps: int = 1,
-    ) -> typing.Self:
-        """Call a decomposition pass on this circuit, to decompose one level (shallow decompose).
+    ) -> "QuantumCircuit":
+        """Call a decomposition pass on this circuit,
+        to decompose one level (shallow decompose).
 
         Args:
-            gates_to_decompose: Optional subset of gates to decompose. Can be a gate type, such as
-                ``HGate``, or a gate name, such as "h", or a gate label, such as "My H Gate", or a
-                list of any combination of these. If a gate name is entered, it will decompose all
-                gates with that name, whether the gates have labels or not. Defaults to all gates in
-                the circuit.
-            reps: Optional number of times the circuit should be decomposed.
+            gates_to_decompose (type or str or list(type, str)): Optional subset of gates
+                to decompose. Can be a gate type, such as ``HGate``, or a gate name, such
+                as 'h', or a gate label, such as 'My H Gate', or a list of any combination
+                of these. If a gate name is entered, it will decompose all gates with that
+                name, whether the gates have labels or not. Defaults to all gates in circuit.
+            reps (int): Optional number of times the circuit should be decomposed.
                 For instance, ``reps=2`` equals calling ``circuit.decompose().decompose()``.
+                can decompose specific gates specific time
 
         Returns:
             QuantumCircuit: a circuit one level decomposed
         """
         # pylint: disable=cyclic-import
         from qiskit.transpiler.passes.basis.decompose import Decompose
+        from qiskit.transpiler.passes.synthesis import HighLevelSynthesis
         from qiskit.converters.circuit_to_dag import circuit_to_dag
         from qiskit.converters.dag_to_circuit import dag_to_circuit
 
         dag = circuit_to_dag(self, copy_operations=True)
 
-        pass_ = Decompose(gates_to_decompose, apply_synthesis=True)
+        if gates_to_decompose is None:
+            # We should not rewrite the circuit using HLS when we have gates_to_decompose,
+            # or else HLS will rewrite all objects with available plugins (e.g., Cliffords,
+            # PermutationGates, and now also MCXGates)
+            dag = HighLevelSynthesis().run(dag)
+
+        pass_ = Decompose(gates_to_decompose)
         for _ in range(reps):
             dag = pass_.run(dag)
 
@@ -3525,7 +3486,7 @@ class QuantumCircuit:
 
         for instruction in self._data:
             objects = set(itertools.chain(instruction.qubits, instruction.clbits))
-            if (condition := getattr(instruction.operation, "_condition", None)) is not None:
+            if (condition := getattr(instruction.operation, "condition", None)) is not None:
                 objects.update(_builder_utils.condition_resources(condition).clbits)
                 if isinstance(condition, expr.Expr):
                     update_from_expr(objects, condition)
@@ -3628,7 +3589,7 @@ class QuantumCircuit:
             else:
                 args = instruction.qubits + instruction.clbits
                 num_qargs = len(args) + (
-                    1 if getattr(instruction.operation, "_condition", None) else 0
+                    1 if getattr(instruction.operation, "condition", None) else 0
                 )
 
             if num_qargs >= 2 and not getattr(instruction.operation, "_directive", False):
@@ -3754,13 +3715,39 @@ class QuantumCircuit:
                 f"invalid name for a circuit: '{name}'. The name must be a string or 'None'."
             )
         cpy = _copy.copy(self)
-
-        _copy_metadata(self, cpy, vars_mode)
+        # copy registers correctly, in copy.copy they are only copied via reference
+        cpy.qregs = self.qregs.copy()
+        cpy.cregs = self.cregs.copy()
+        cpy._builder_api = _OuterCircuitScopeInterface(cpy)
+        cpy._ancillas = self._ancillas.copy()
+        cpy._qubit_indices = self._qubit_indices.copy()
+        cpy._clbit_indices = self._clbit_indices.copy()
+
+        if vars_mode == "alike":
+            # Note that this causes the local variables to be uninitialised, because the stores are
+            # not copied.  This can leave the circuit in a potentially dangerous state for users if
+            # they don't re-add initializer stores.
+            cpy._vars_local = self._vars_local.copy()
+            cpy._vars_input = self._vars_input.copy()
+            cpy._vars_capture = self._vars_capture.copy()
+        elif vars_mode == "captures":
+            cpy._vars_local = {}
+            cpy._vars_input = {}
+            cpy._vars_capture = {var.name: var for var in self.iter_vars()}
+        elif vars_mode == "drop":
+            cpy._vars_local = {}
+            cpy._vars_input = {}
+            cpy._vars_capture = {}
+        else:  # pragma: no cover
+            raise ValueError(f"unknown vars_mode: '{vars_mode}'")
 
         cpy._data = CircuitData(
             self._data.qubits, self._data.clbits, global_phase=self._data.global_phase
         )
 
+        cpy._calibrations = _copy.deepcopy(self._calibrations)
+        cpy._metadata = _copy.deepcopy(self._metadata)
+
         if name:
             cpy.name = name
         return cpy
@@ -3876,7 +3863,7 @@ class QuantumCircuit:
                circuit.draw()
 
 
-            .. code-block:: text
+            .. parsed-literal::
 
                       ┌───┐┌─┐
                    q: ┤ H ├┤M├
@@ -4350,57 +4337,30 @@ class QuantumCircuit:
 
         if isinstance(parameters, collections.abc.Mapping):
             raw_mapping = parameters if flat_input else self._unroll_param_dict(parameters)
-            if strict and (
-                extras := [
-                    parameter for parameter in raw_mapping if not self.has_parameter(parameter)
-                ]
-            ):
+            our_parameters = self._data.unsorted_parameters()
+            if strict and (extras := raw_mapping.keys() - our_parameters):
                 raise CircuitError(
                     f"Cannot bind parameters ({', '.join(str(x) for x in extras)}) not present in"
                     " the circuit."
                 )
-
-            def create_mapping_view():
-                return raw_mapping
-
-            target._data.assign_parameters_mapping(raw_mapping)
+            parameter_binds = _ParameterBindsDict(raw_mapping, our_parameters)
+            target._data.assign_parameters_mapping(parameter_binds)
         else:
-            # This should be a cache retrieval, since we warmed the cache.  We need to keep hold of
-            # what the parameters were before anything is assigned, because we assign parameters in
-            # the calibrations (which aren't tracked in the internal parameter table) after, which
-            # would change what we create.  We don't make the full Python-space mapping object of
-            # parameters to values eagerly because 99.9% of the time we don't need it, and it's
-            # relatively expensive to do for large numbers of parameters.
-            initial_parameters = target._data.parameters
-
-            def create_mapping_view():
-                return dict(zip(initial_parameters, parameters))
-
+            parameter_binds = _ParameterBindsSequence(target._data.parameters, parameters)
             target._data.assign_parameters_iterable(parameters)
 
         # Finally, assign the parameters inside any of the calibrations.  We don't track these in
-        # the `ParameterTable`, so we manually reconstruct things.  We lazily construct the mapping
-        # `{parameter: bound_value}` the first time we encounter a binding (we have to scan for
-        # this, because calibrations don't use a parameter-table lookup), rather than always paying
-        # the cost - most circuits don't have parametric calibrations, and it's expensive.
-        mapping_view = None
-
+        # the `ParameterTable`, so we manually reconstruct things.
         def map_calibration(qubits, parameters, schedule):
-            # All calls to this function should share the same `{Parameter: bound_value}` mapping,
-            # which we only want to lazily construct a single time.
-            nonlocal mapping_view
-            if mapping_view is None:
-                mapping_view = create_mapping_view()
-
             modified = False
             new_parameters = list(parameters)
             for i, parameter in enumerate(new_parameters):
                 if not isinstance(parameter, ParameterExpression):
                     continue
-                if not (contained := parameter.parameters & mapping_view.keys()):
+                if not (contained := parameter.parameters & parameter_binds.mapping.keys()):
                     continue
                 for to_bind in contained:
-                    parameter = parameter.assign(to_bind, mapping_view[to_bind])
+                    parameter = parameter.assign(to_bind, parameter_binds.mapping[to_bind])
                 if not parameter.parameters:
                     parameter = parameter.numeric()
                     if isinstance(parameter, complex):
@@ -4408,7 +4368,7 @@ class QuantumCircuit:
                 new_parameters[i] = parameter
                 modified = True
             if modified:
-                schedule.assign_parameters(mapping_view)
+                schedule.assign_parameters(parameter_binds.mapping)
             return (qubits, tuple(new_parameters)), schedule
 
         target._calibrations = defaultdict(
@@ -5731,7 +5691,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌─────────────────────────────────────┐
                 q_0: ┤ State Preparation(0.70711,-0.70711) ├
@@ -5754,7 +5714,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌─────────────────────────┐
                 q_0: ┤0                        ├
@@ -5775,7 +5735,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌───────────────────────────────────────────┐
                 q_0: ┤0                                          ├
@@ -5846,7 +5806,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌──────────────────────────────┐
                 q_0: ┤ Initialize(0.70711,-0.70711) ├
@@ -5869,7 +5829,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌──────────────────┐
                 q_0: ┤0                 ├
@@ -5890,7 +5850,7 @@ class QuantumCircuit:
 
             output:
 
-            .. code-block:: text
+            .. parsed-literal::
 
                      ┌────────────────────────────────────┐
                 q_0: ┤0                                   ├
@@ -6506,7 +6466,6 @@ class QuantumCircuit:
             ContinueLoopOp(self.num_qubits, self.num_clbits), self.qubits, self.clbits, copy=False
         )
 
-    @deprecate_pulse_dependency
     def add_calibration(
         self,
         gate: Union[Gate, str],
@@ -6732,6 +6691,42 @@ def _validate_expr(circuit_scope: CircuitScopeInterface, node: expr.Expr) -> exp
     return node
 
 
+class _ParameterBindsDict:
+    __slots__ = ("mapping", "allowed_keys")
+
+    def __init__(self, mapping, allowed_keys):
+        self.mapping = mapping
+        self.allowed_keys = allowed_keys
+
+    def items(self):
+        """Iterator through all the keys in the mapping that we care about.  Wrapping the main
+        mapping allows us to avoid reconstructing a new 'dict', but just use the given 'mapping'
+        without any copy / reconstruction."""
+        for parameter, value in self.mapping.items():
+            if parameter in self.allowed_keys:
+                yield parameter, value
+
+
+class _ParameterBindsSequence:
+    __slots__ = ("parameters", "values", "mapping_cache")
+
+    def __init__(self, parameters, values):
+        self.parameters = parameters
+        self.values = values
+        self.mapping_cache = None
+
+    def items(self):
+        """Iterator through all the keys in the mapping that we care about."""
+        return zip(self.parameters, self.values)
+
+    @property
+    def mapping(self):
+        """Cached version of a mapping.  This is only generated on demand."""
+        if self.mapping_cache is None:
+            self.mapping_cache = dict(zip(self.parameters, self.values))
+        return self.mapping_cache
+
+
 def _bit_argument_conversion(specifier, bit_sequence, bit_set, type_) -> list[Bit]:
     """Get the list of bits referred to by the specifier ``specifier``.
 
@@ -6796,34 +6791,3 @@ def _bit_argument_conversion_scalar(specifier, bit_sequence, bit_set, type_):
         else f"Invalid bit index: '{specifier}' of type '{type(specifier)}'"
     )
     raise CircuitError(message)
-
-
-def _copy_metadata(original, cpy, vars_mode):
-    # copy registers correctly, in copy.copy they are only copied via reference
-    cpy.qregs = original.qregs.copy()
-    cpy.cregs = original.cregs.copy()
-    cpy._builder_api = _OuterCircuitScopeInterface(cpy)
-    cpy._ancillas = original._ancillas.copy()
-    cpy._qubit_indices = original._qubit_indices.copy()
-    cpy._clbit_indices = original._clbit_indices.copy()
-
-    if vars_mode == "alike":
-        # Note that this causes the local variables to be uninitialised, because the stores are
-        # not copied.  This can leave the circuit in a potentially dangerous state for users if
-        # they don't re-add initializer stores.
-        cpy._vars_local = original._vars_local.copy()
-        cpy._vars_input = original._vars_input.copy()
-        cpy._vars_capture = original._vars_capture.copy()
-    elif vars_mode == "captures":
-        cpy._vars_local = {}
-        cpy._vars_input = {}
-        cpy._vars_capture = {var.name: var for var in original.iter_vars()}
-    elif vars_mode == "drop":
-        cpy._vars_local = {}
-        cpy._vars_input = {}
-        cpy._vars_capture = {}
-    else:  # pragma: no cover
-        raise ValueError(f"unknown vars_mode: '{vars_mode}'")
-
-    cpy._calibrations = _copy.deepcopy(original._calibrations)
-    cpy._metadata = _copy.deepcopy(original._metadata)

qiskit/circuit/singleton.py

@@ -251,7 +251,6 @@ from __future__ import annotations
 
 import functools
 
-from qiskit.utils import deprecate_func
 from .instruction import Instruction
 from .gate import Gate
 from .controlledgate import ControlledGate, _ctrl_state_to_int
@@ -490,7 +489,6 @@ class _SingletonInstructionOverrides(Instruction):
         instruction._params = _frozenlist(instruction._params)
         return instruction
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
     def c_if(self, classical, val):
         return self.to_mutable().c_if(classical, val)
 

qiskit/circuit/store.py

@@ -16,7 +16,6 @@ from __future__ import annotations
 
 import typing
 
-from qiskit.utils import deprecate_func
 from .exceptions import CircuitError
 from .classical import expr, types
 from .instruction import Instruction
@@ -89,7 +88,6 @@ class Store(Instruction):
         """Get the r-value :class:`~.expr.Expr` node that is being written into the l-value."""
         return self.params[1]
 
-    @deprecate_func(since="1.3.0", removal_timeline="in 2.0.0")
     def c_if(self, classical, val):
         """:meta hidden:"""
         raise NotImplementedError(

qiskit/compiler/assembler.py

@@ -189,16 +189,6 @@ def assemble(
     )
 
 
-# Note for future: this method is used in `BasicSimulator` and may need to be kept past the
-# `assemble` removal deadline (2.0). If it is kept (potentially in a different location),
-# we will need an alternative for the backend.configuration() access that currently takes
-# place in L566 (`parse_circuit_args`) and L351 (`parse_common_args`)
-# because backend.configuration() is also set for removal in 2.0.
-# The ultimate goal will be to move away from relying on any kind of `assemble` implementation
-# because of how tightly coupled it is to these legacy data structures. But as a transition step,
-# given that we would only have to support the subcase of `BasicSimulator`, we could probably just
-# inline the relevant config values that are already hardcoded in the basic simulator configuration
-# generator.
 def _assemble(
     experiments: Union[
         QuantumCircuit,
@@ -239,7 +229,7 @@ def _assemble(
     experiments = experiments if isinstance(experiments, list) else [experiments]
     pulse_qobj = any(isinstance(exp, (ScheduleBlock, Schedule, Instruction)) for exp in experiments)
     with warnings.catch_warnings():
-        # The Qobj class is deprecated, the backend.configuration() method is too
+        # The Qobj is deprecated
         warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
         qobj_id, qobj_header, run_config_common_dict = _parse_common_args(
             backend,
@@ -564,12 +554,9 @@ def _parse_circuit_args(
     run_config_dict = {"parameter_binds": parameter_binds, **run_config}
     if parametric_pulses is None:
         if backend:
-            with warnings.catch_warnings():
-                # TODO (2.0): See comment on L192 regarding backend.configuration removal
-                warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-                run_config_dict["parametric_pulses"] = getattr(
-                    backend.configuration(), "parametric_pulses", []
-                )
+            run_config_dict["parametric_pulses"] = getattr(
+                backend.configuration(), "parametric_pulses", []
+            )
         else:
             run_config_dict["parametric_pulses"] = []
     else:

qiskit/compiler/scheduler.py

@@ -26,7 +26,6 @@ from qiskit.providers.backend import Backend
 from qiskit.scheduler.config import ScheduleConfig
 from qiskit.scheduler.schedule_circuit import schedule_circuit
 from qiskit.utils.parallel import parallel_map
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 logger = logging.getLogger(__name__)
 
@@ -36,7 +35,6 @@ def _log_schedule_time(start_time, end_time):
     logger.info(log_msg)
 
 
-@deprecate_pulse_dependency(moving_to_dynamics=True)
 def schedule(
     circuits: Union[QuantumCircuit, List[QuantumCircuit]],
     backend: Optional[Backend] = None,