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

qiskit/transpiler/preset_passmanagers/generate_preset_pass_manager.py

@@ -17,13 +17,7 @@ Preset pass manager generation function
 import copy
 import warnings
 
-from qiskit.circuit.controlflow import (
-    CONTROL_FLOW_OP_NAMES,
-    IfElseOp,
-    WhileLoopOp,
-    ForLoopOp,
-    SwitchCaseOp,
-)
+from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping
 from qiskit.circuit.quantumregister import Qubit
 from qiskit.providers.backend import Backend
@@ -35,8 +29,6 @@ from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.passmanager_config import PassManagerConfig
 from qiskit.transpiler.target import Target, target_to_backend_properties
 from qiskit.transpiler.timing_constraints import TimingConstraints
-from qiskit.utils import deprecate_arg
-from qiskit.utils.deprecate_pulse import deprecate_pulse_arg
 
 from .level0 import level_0_pass_manager
 from .level1 import level_1_pass_manager
@@ -44,33 +36,6 @@ from .level2 import level_2_pass_manager
 from .level3 import level_3_pass_manager
 
 
-@deprecate_arg(
-    name="instruction_durations",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined instruction durations with "
-    "`Target.from_configuration(..., instruction_durations=...)`",
-)
-@deprecate_arg(
-    name="timing_constraints",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined timing constraints with "
-    "`Target.from_configuration(..., timing_constraints=...)`",
-)
-@deprecate_arg(
-    name="backend_properties",
-    since="1.3",
-    package_name="Qiskit",
-    removal_timeline="in Qiskit 2.0",
-    additional_msg="The `target` parameter should be used instead. You can build a `Target` instance "
-    "with defined properties with Target.from_configuration(..., backend_properties=...)",
-)
-@deprecate_pulse_arg("inst_map", predicate=lambda inst_map: inst_map is not None)
 def generate_preset_pass_manager(
     optimization_level=2,
     backend=None,
@@ -157,7 +122,7 @@ def generate_preset_pass_manager(
             and ``backend_properties``.
         basis_gates (list): List of basis gate names to unroll to
             (e.g: ``['u1', 'u2', 'u3', 'cx']``).
-        inst_map (InstructionScheduleMap): DEPRECATED. Mapping object that maps gates to schedules.
+        inst_map (InstructionScheduleMap): Mapping object that maps gates to schedules.
             If any user defined calibration is found in the map and this is used in a
             circuit, transpiler attaches the custom gate definition to the circuit.
             This enables one to flexibly override the low-level instruction
@@ -318,7 +283,6 @@ def generate_preset_pass_manager(
     _skip_target = (
         target is None
         and backend is None
-        # Note: instruction_durations is deprecated and will be removed in 2.0 (no need for alternative)
         and (basis_gates is None or coupling_map is None or instruction_durations is not None)
     )
 
@@ -343,31 +307,23 @@ def generate_preset_pass_manager(
             # Only parse backend properties when the target isn't skipped to
             # preserve the former behavior of transpile.
             backend_properties = _parse_backend_properties(backend_properties, backend)
-            with warnings.catch_warnings():
-                # TODO: inst_map will be removed in 2.0
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*``inst_map`` is deprecated as of Qiskit 1.3.*",
-                    module="qiskit",
-                )
-                # Build target from constraints.
-                target = Target.from_configuration(
-                    basis_gates=basis_gates,
-                    num_qubits=backend.num_qubits if backend is not None else None,
-                    coupling_map=coupling_map,
-                    # If the instruction map has custom gates, do not give as config, the information
-                    # will be added to the target with update_from_instruction_schedule_map
-                    inst_map=inst_map if inst_map and not inst_map.has_custom_gate() else None,
-                    backend_properties=backend_properties,
-                    instruction_durations=instruction_durations,
-                    concurrent_measurements=(
-                        backend.target.concurrent_measurements if backend is not None else None
-                    ),
-                    dt=dt,
-                    timing_constraints=timing_constraints,
-                    custom_name_mapping=name_mapping,
-                )
+            # Build target from constraints.
+            target = Target.from_configuration(
+                basis_gates=basis_gates,
+                num_qubits=backend.num_qubits if backend is not None else None,
+                coupling_map=coupling_map,
+                # If the instruction map has custom gates, do not give as config, the information
+                # will be added to the target with update_from_instruction_schedule_map
+                inst_map=inst_map if inst_map and not inst_map.has_custom_gate() else None,
+                backend_properties=backend_properties,
+                instruction_durations=instruction_durations,
+                concurrent_measurements=(
+                    backend.target.concurrent_measurements if backend is not None else None
+                ),
+                dt=dt,
+                timing_constraints=timing_constraints,
+                custom_name_mapping=name_mapping,
+            )
 
     # Update target with custom gate information. Note that this is an exception to the priority
     # order (target > loose constraints), added to handle custom gates for scheduling passes.
@@ -383,7 +339,7 @@ def generate_preset_pass_manager(
         if instruction_durations is None:
             instruction_durations = target.durations()
         if inst_map is None:
-            inst_map = target._get_instruction_schedule_map()
+            inst_map = target.instruction_schedule_map()
         if timing_constraints is None:
             timing_constraints = target.timing_constraints()
         if backend_properties is None:
@@ -427,41 +383,30 @@ def generate_preset_pass_manager(
         "qubits_initially_zero": qubits_initially_zero,
     }
 
-    with warnings.catch_warnings():
-        # inst_map is deprecated in the PassManagerConfig initializer
-        warnings.filterwarnings(
-            "ignore",
-            category=DeprecationWarning,
-            message=".*argument ``inst_map`` is deprecated as of Qiskit 1.3",
-        )
-        if backend is not None:
-            pm_options["_skip_target"] = _skip_target
-            pm_config = PassManagerConfig.from_backend(backend, **pm_options)
-        else:
-            pm_config = PassManagerConfig(**pm_options)
-        if optimization_level == 0:
-            pm = level_0_pass_manager(pm_config)
-        elif optimization_level == 1:
-            pm = level_1_pass_manager(pm_config)
-        elif optimization_level == 2:
-            pm = level_2_pass_manager(pm_config)
-        elif optimization_level == 3:
-            pm = level_3_pass_manager(pm_config)
-        else:
-            raise ValueError(f"Invalid optimization level {optimization_level}")
+    if backend is not None:
+        pm_options["_skip_target"] = _skip_target
+        pm_config = PassManagerConfig.from_backend(backend, **pm_options)
+    else:
+        pm_config = PassManagerConfig(**pm_options)
+    if optimization_level == 0:
+        pm = level_0_pass_manager(pm_config)
+    elif optimization_level == 1:
+        pm = level_1_pass_manager(pm_config)
+    elif optimization_level == 2:
+        pm = level_2_pass_manager(pm_config)
+    elif optimization_level == 3:
+        pm = level_3_pass_manager(pm_config)
+    else:
+        raise ValueError(f"Invalid optimization level {optimization_level}")
     return pm
 
 
 def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
+    name_mapping = {}
     standard_gates = get_standard_gate_name_mapping()
-    # Add control flow gates by default to basis set and name mapping
+    # Add control flow gates by default to basis set
     default_gates = {"measure", "delay", "reset"}.union(CONTROL_FLOW_OP_NAMES)
-    name_mapping = {
-        "if_else": IfElseOp,
-        "while_loop": WhileLoopOp,
-        "for_loop": ForLoopOp,
-        "switch_case": SwitchCaseOp,
-    }
+
     try:
         instructions = set(basis_gates)
         for name in default_gates:
@@ -476,16 +421,7 @@ def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
             return None, name_mapping, skip_target
 
         for inst in instructions:
-            if inst not in standard_gates and inst not in default_gates:
-                warnings.warn(
-                    category=DeprecationWarning,
-                    message=f"Providing non-standard gates ({inst}) through the ``basis_gates`` "
-                    "argument is deprecated for both ``transpile`` and ``generate_preset_pass_manager`` "
-                    "as of Qiskit 1.3.0. "
-                    "It will be removed in Qiskit 2.0. The ``target`` parameter should be used instead. "
-                    "You can build a target instance using ``Target.from_configuration()`` and provide "
-                    "custom gate definitions with the ``custom_name_mapping`` argument.",
-                )
+            if inst not in standard_gates or inst not in default_gates:
                 skip_target = True
                 break
 
@@ -498,18 +434,7 @@ def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
 
     # Check for custom instructions before removing calibrations
     for inst in instructions:
-        if inst not in standard_gates and inst not in default_gates:
-            if inst not in backend.operation_names:
-                # do not raise warning when the custom instruction comes from the backend
-                # (common case with BasicSimulator)
-                warnings.warn(
-                    category=DeprecationWarning,
-                    message="Providing custom gates through the ``basis_gates`` argument is deprecated "
-                    "for both ``transpile`` and ``generate_preset_pass_manager`` as of Qiskit 1.3.0. "
-                    "It will be removed in Qiskit 2.0. The ``target`` parameter should be used instead. "
-                    "You can build a target instance using ``Target.from_configuration()`` and provide"
-                    "custom gate definitions with the ``custom_name_mapping`` argument.",
-                )
+        if inst not in standard_gates or inst not in default_gates:
             skip_target = True
             break
 
@@ -527,22 +452,14 @@ def _parse_basis_gates(basis_gates, backend, inst_map, skip_target):
 def _parse_inst_map(inst_map, backend):
     # try getting inst_map from user, else backend
     if inst_map is None and backend is not None:
-        inst_map = backend.target._get_instruction_schedule_map()
+        inst_map = backend.target.instruction_schedule_map()
     return inst_map
 
 
 def _parse_backend_properties(backend_properties, backend):
     # try getting backend_props from user, else backend
     if backend_properties is None and backend is not None:
-        with warnings.catch_warnings():
-            # filter target_to_backend_properties warning
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*``qiskit.transpiler.target.target_to_backend_properties\\(\\)``.*",
-                module="qiskit",
-            )
-            backend_properties = target_to_backend_properties(backend.target)
+        backend_properties = target_to_backend_properties(backend.target)
     return backend_properties
 
 

qiskit/transpiler/preset_passmanagers/plugin.py

@@ -145,7 +145,7 @@ subclass as a setuptools entry point in the package metadata. This can be done
 an ``entry-points`` table in ``pyproject.toml`` for the plugin package with the necessary entry
 points under the appropriate namespace for the stage your plugin is for. You can see the list of
 stages, entry points, and expectations from the stage in :ref:`stage_table`.  For example,
-continuing from the example plugin above:
+continuing from the example plugin above::
 
 .. code-block:: toml
 

qiskit/transpiler/target.py

@@ -57,7 +57,6 @@ from qiskit.exceptions import QiskitError
 from qiskit.providers.backend import QubitProperties  # pylint: disable=unused-import
 from qiskit.providers.models.backendproperties import BackendProperties
 from qiskit.utils import deprecate_func
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency, deprecate_pulse_arg
 
 logger = logging.getLogger(__name__)
 
@@ -87,7 +86,6 @@ class InstructionProperties(BaseInstructionProperties):
             cls, duration, error
         )
 
-    @deprecate_pulse_arg("calibration", predicate=lambda cals: cals is not None)
     def __init__(
         self,
         duration: float | None = None,  # pylint: disable=unused-argument
@@ -101,14 +99,13 @@ class InstructionProperties(BaseInstructionProperties):
                 specified set of qubits
             error: The average error rate for the instruction on the specified
                 set of qubits.
-            calibration: DEPRECATED. The pulse representation of the instruction.
+            calibration: The pulse representation of the instruction.
         """
         super().__init__()
         self._calibration: CalibrationEntry | None = None
-        self._calibration_prop = calibration
+        self.calibration = calibration
 
     @property
-    @deprecate_pulse_dependency(is_property=True)
     def calibration(self):
         """The pulse representation of the instruction.
 
@@ -136,24 +133,12 @@ class InstructionProperties(BaseInstructionProperties):
             use own definition to compile the circuit down to the execution format.
 
         """
-        return self._calibration_prop
-
-    @calibration.setter
-    @deprecate_pulse_dependency(is_property=True)
-    def calibration(self, calibration: Schedule | ScheduleBlock | CalibrationEntry):
-        self._calibration_prop = calibration
-
-    @property
-    def _calibration_prop(self):
         if self._calibration is None:
             return None
-        with warnings.catch_warnings():
-            warnings.simplefilter(action="ignore", category=DeprecationWarning)
-            # Clean this alternative path from deprecation warning emitted by `get_schedule`
-            return self._calibration.get_schedule()
+        return self._calibration.get_schedule()
 
-    @_calibration_prop.setter
-    def _calibration_prop(self, calibration: Schedule | ScheduleBlock | CalibrationEntry):
+    @calibration.setter
+    def calibration(self, calibration: Schedule | ScheduleBlock | CalibrationEntry):
         if isinstance(calibration, (Schedule, ScheduleBlock)):
             new_entry = ScheduleDef()
             new_entry.define(calibration, user_provided=True)
@@ -168,11 +153,11 @@ class InstructionProperties(BaseInstructionProperties):
         )
 
     def __getstate__(self) -> tuple:
-        return (super().__getstate__(), self._calibration_prop, self._calibration)
+        return (super().__getstate__(), self.calibration, self._calibration)
 
     def __setstate__(self, state: tuple):
         super().__setstate__(state[0])
-        self._calibration_prop = state[1]
+        self.calibration = state[1]
         self._calibration = state[2]
 
 
@@ -462,7 +447,6 @@ class Target(BaseTarget):
         self._instruction_durations = None
         self._instruction_schedule_map = None
 
-    @deprecate_pulse_dependency
     def update_from_instruction_schedule_map(self, inst_map, inst_name_map=None, error_dict=None):
         """Update the target from an instruction schedule map.
 
@@ -620,7 +604,6 @@ class Target(BaseTarget):
             self.granularity, self.min_length, self.pulse_alignment, self.acquire_alignment
         )
 
-    @deprecate_pulse_dependency
     def instruction_schedule_map(self):
         """Return an :class:`~qiskit.pulse.InstructionScheduleMap` for the
         instructions in the target with a pulse schedule defined.
@@ -629,17 +612,9 @@ class Target(BaseTarget):
             InstructionScheduleMap: The instruction schedule map for the
             instructions in this target with a pulse schedule defined.
         """
-        return self._get_instruction_schedule_map()
-
-    def _get_instruction_schedule_map(self):
         if self._instruction_schedule_map is not None:
             return self._instruction_schedule_map
-        with warnings.catch_warnings():
-            warnings.simplefilter(action="ignore", category=DeprecationWarning)
-            # `InstructionScheduleMap` is deprecated in Qiskit 1.3 but we want this alternative
-            # path to be clean of deprecation warnings
-            out_inst_schedule_map = InstructionScheduleMap()
-
+        out_inst_schedule_map = InstructionScheduleMap()
         for instruction, qargs in self._gate_map.items():
             for qarg, properties in qargs.items():
                 # Directly getting CalibrationEntry not to invoke .get_schedule().
@@ -651,7 +626,6 @@ class Target(BaseTarget):
         self._instruction_schedule_map = out_inst_schedule_map
         return out_inst_schedule_map
 
-    @deprecate_pulse_dependency
     def has_calibration(
         self,
         operation_name: str,
@@ -666,13 +640,6 @@ class Target(BaseTarget):
         Returns:
             Returns ``True`` if the calibration is supported and ``False`` if it isn't.
         """
-        return self._has_calibration(operation_name, qargs)
-
-    def _has_calibration(
-        self,
-        operation_name: str,
-        qargs: tuple[int, ...],
-    ) -> bool:
         qargs = tuple(qargs)
         if operation_name not in self._gate_map:
             return False
@@ -680,7 +647,6 @@ class Target(BaseTarget):
             return False
         return getattr(self._gate_map[operation_name][qargs], "_calibration", None) is not None
 
-    @deprecate_pulse_dependency
     def get_calibration(
         self,
         operation_name: str,
@@ -702,16 +668,7 @@ class Target(BaseTarget):
         Returns:
             Calibrated pulse schedule of corresponding instruction.
         """
-        return self._get_calibration(operation_name, qargs, *args, *kwargs)
-
-    def _get_calibration(
-        self,
-        operation_name: str,
-        qargs: tuple[int, ...],
-        *args: ParameterValueType,
-        **kwargs: ParameterValueType,
-    ) -> Schedule | ScheduleBlock:
-        if not self._has_calibration(operation_name, qargs):
+        if not self.has_calibration(operation_name, qargs):
             raise KeyError(
                 f"Calibration of instruction {operation_name} for qubit {qargs} is not defined."
             )
@@ -970,7 +927,6 @@ class Target(BaseTarget):
         super().__setstate__(state["base"])
 
     @classmethod
-    @deprecate_pulse_arg("inst_map")
     def from_configuration(
         cls,
         basis_gates: list[str],
@@ -1009,7 +965,7 @@ class Target(BaseTarget):
             coupling_map: The coupling map representing connectivity constraints
                 on the backend. If specified all gates from ``basis_gates`` will
                 be supported on all qubits (or pairs of qubits).
-            inst_map: DEPRECATED. The instruction schedule map representing the pulse
+            inst_map: The instruction schedule map representing the pulse
                :class:`~.Schedule` definitions for each instruction. If this
                is specified ``coupling_map`` must be specified. The
                ``coupling_map`` is used as the source of truth for connectivity
@@ -1156,16 +1112,9 @@ class Target(BaseTarget):
                     if error is None and duration is None and calibration is None:
                         gate_properties[(qubit,)] = None
                     else:
-                        with warnings.catch_warnings():
-                            warnings.filterwarnings(
-                                "ignore",
-                                category=DeprecationWarning,
-                                message=".*``calibration`` is deprecated as of Qiskit 1.3.*",
-                                module="qiskit",
-                            )
-                            gate_properties[(qubit,)] = InstructionProperties(
-                                duration=duration, error=error, calibration=calibration
-                            )
+                        gate_properties[(qubit,)] = InstructionProperties(
+                            duration=duration, error=error, calibration=calibration
+                        )
                 target.add_instruction(name_mapping[gate], properties=gate_properties, name=gate)
             edges = list(coupling_map.get_edges())
             for gate in two_qubit_gates:
@@ -1205,16 +1154,9 @@ class Target(BaseTarget):
                     if error is None and duration is None and calibration is None:
                         gate_properties[edge] = None
                     else:
-                        with warnings.catch_warnings():
-                            warnings.filterwarnings(
-                                "ignore",
-                                category=DeprecationWarning,
-                                message=".*``calibration`` is deprecated as of Qiskit 1.3.*",
-                                module="qiskit",
-                            )
-                            gate_properties[edge] = InstructionProperties(
-                                duration=duration, error=error, calibration=calibration
-                            )
+                        gate_properties[edge] = InstructionProperties(
+                            duration=duration, error=error, calibration=calibration
+                        )
                 target.add_instruction(name_mapping[gate], properties=gate_properties, name=gate)
             for gate in global_ideal_variable_width_gates:
                 target.add_instruction(name_mapping[gate], name=gate)

qiskit/visualization/circuit/_utils.py

@@ -503,7 +503,7 @@ def _get_gate_span(qubits, node):
     # type of op must be the only op in the layer
     if isinstance(node.op, ControlFlowOp):
         span = qubits
-    elif node.cargs or getattr(node, "condition", None):
+    elif node.cargs or getattr(node.op, "condition", None):
         span = qubits[min_index : len(qubits)]
     else:
         span = qubits[min_index : max_index + 1]
@@ -582,7 +582,7 @@ class _LayerSpooler(list):
             curr_index = index
             last_insertable_index = -1
             index_stop = -1
-            if (condition := getattr(node, "condition", None)) is not None:
+            if (condition := getattr(node.op, "condition", None)) is not None:
                 index_stop = max(
                     (self.measure_map[bit] for bit in condition_resources(condition).clbits),
                     default=index_stop,

qiskit/visualization/circuit/circuit_visualization.py

@@ -191,12 +191,11 @@ def circuit_drawer(
         .. plot::
             :include-source:
 
-            from qiskit import QuantumCircuit
-            from qiskit.visualization import circuit_drawer
+            from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
             qc = QuantumCircuit(1, 1)
             qc.h(0)
             qc.measure(0, 0)
-            circuit_drawer(qc, output="mpl", style={"backgroundcolor": "#EEEEEE"})
+            qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})
     """
     image = None
     expr_len = max(expr_len, 0)

qiskit/visualization/circuit/matplotlib.py

@@ -135,7 +135,7 @@ class MatplotlibDrawer:
 
         self._initial_state = initial_state
         self._global_phase = self._circuit.global_phase
-        self._calibrations = self._circuit._calibrations_prop
+        self._calibrations = self._circuit.calibrations
         self._expr_len = expr_len
         self._cregbundle = cregbundle
 

qiskit/visualization/dag_visualization.py

@@ -81,7 +81,7 @@ def dag_drawer(dag, scale=0.7, filename=None, style="color"):
     ``rustworkx`` package to draw the DAG.
 
     Args:
-        dag (DAGCircuit or DAGDependency): The dag to draw.
+        dag (DAGCircuit): The dag to draw.
         scale (float): scaling factor
         filename (str): file path to save image to (format inferred from name)
         style (str): 'plain': B&W graph

qiskit/visualization/pass_manager_visualization.py

@@ -58,12 +58,23 @@ def pass_manager_drawer(pass_manager, filename=None, style=None, raw=False):
     Example:
         .. code-block::
 
+             %matplotlib inline
             from qiskit import QuantumCircuit
-            from qiskit.transpiler import generate_preset_pass_manager
+            from qiskit.compiler import transpile
+            from qiskit.transpiler import PassManager
             from qiskit.visualization import pass_manager_drawer
+            from qiskit.transpiler.passes import Unroller
 
-            pm = generate_preset_pass_manager(optimization_level=0)
-            pass_manager_drawer(pm)
+            circ = QuantumCircuit(3)
+            circ.ccx(0, 1, 2)
+            circ.draw()
+
+            pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])
+            pm = PassManager(pass_)
+            new_circ = pm.run(circ)
+            new_circ.draw(output='mpl')
+
+            pass_manager_drawer(pm, "passmanager.jpg")
     """
     import pydot
 

qiskit/visualization/pulse_v2/interface.py

@@ -28,11 +28,9 @@ from qiskit.visualization.exceptions import VisualizationError
 from qiskit.visualization.pulse_v2 import core, device_info, stylesheet, types
 from qiskit.exceptions import MissingOptionalLibraryError
 from qiskit.utils import deprecate_arg
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
-@deprecate_pulse_dependency(moving_to_dynamics=True)
-@deprecate_arg("show_barrier", new_alias="plot_barrier", since="1.1.0", pending=True)
+@deprecate_arg("show_barriers", new_alias="plot_barriers", since="1.1.0", pending=True)
 def draw(
     program: Union[Waveform, SymbolicPulse, Schedule, ScheduleBlock],
     style: Optional[Dict[str, Any]] = None,

qiskit/visualization/timeline/core.py

@@ -58,7 +58,6 @@ from enum import Enum
 import numpy as np
 
 from qiskit import circuit
-from qiskit.transpiler.target import Target
 from qiskit.visualization.exceptions import VisualizationError
 from qiskit.visualization.timeline import drawings, types
 from qiskit.visualization.timeline.stylesheet import QiskitTimelineStyle
@@ -139,13 +138,11 @@ class DrawerCanvas:
         self._collections[data.data_key] = data
 
     # pylint: disable=cyclic-import
-    def load_program(self, program: circuit.QuantumCircuit, target: Target | None = None):
+    def load_program(self, program: circuit.QuantumCircuit):
         """Load quantum circuit and create drawing..
 
         Args:
             program: Scheduled circuit object to draw.
-            target: The target the circuit is scheduled for. This contains backend information
-                including the instruction durations used in scheduling.
 
         Raises:
            VisualizationError: When circuit is not scheduled.
@@ -183,30 +180,10 @@ class DrawerCanvas:
             for bit_pos, bit in enumerate(bits):
                 if not isinstance(instruction.operation, not_gate_like):
                     # Generate draw object for gates
-                    if target is not None:
-                        duration = None
-                        op_props = target.get(instruction.operation.name)
-                        if op_props is not None:
-                            inst_props = op_props.get(tuple(instruction.qubits))
-                            if inst_props is not None:
-                                duration = inst_props.getattr("duration")
-
-                        if duration is None:
-                            # Warn here because an incomplete target isn't obvious most of the time
-                            warnings.warn(
-                                "Target doesn't contain a duration for "
-                                f"{instruction.operation.name} on {bit_pos}, this will error in "
-                                "Qiskit 2.0.",
-                                DeprecationWarning,
-                                stacklevel=3,
-                            )
-                            duration = instruction.operation.duration
-                    else:
-                        duration = instruction.operation.duration
                     gate_source = types.ScheduledGate(
                         t0=t0,
                         operand=instruction.operation,
-                        duration=duration,
+                        duration=instruction.operation.duration,
                         bits=bits,
                         bit_position=bit_pos,
                     )

qiskit/visualization/timeline/interface.py

@@ -20,10 +20,8 @@ the configured canvas is passed to one of the plotter APIs to generate a visuali
 """
 
 from typing import Optional, Dict, Any, List, Tuple
-import warnings
 
 from qiskit import circuit
-from qiskit.transpiler.target import Target
 from qiskit.exceptions import MissingOptionalLibraryError
 from qiskit.visualization.exceptions import VisualizationError
 from qiskit.visualization.timeline import types, core, stylesheet
@@ -45,7 +43,6 @@ def draw(
     plotter: Optional[str] = types.Plotter.MPL.value,
     axis: Optional[Any] = None,
     filename: Optional[str] = None,
-    target: Optional[Target] = None,
     *,
     show_idle: Optional[bool] = None,
     show_barriers: Optional[bool] = None,
@@ -84,7 +81,6 @@ def draw(
             the plotters uses given `axis` instead of internally initializing a figure object.
             This object format depends on the plotter. See plotters section for details.
         filename: If provided the output image is dumped into a file under the filename.
-        target: The target for the backend the timeline is being generated for.
         show_idle: DEPRECATED.
         show_barriers: DEPRECATED.
 
@@ -365,14 +361,6 @@ def draw(
     temp_style = stylesheet.QiskitTimelineStyle()
     temp_style.update(style or stylesheet.IQXStandard())
 
-    if target is None:
-        warnings.warn(
-            "Target is not specified. In Qiskit 2.0.0 this will be required to get the duration of "
-            "instructions.",
-            PendingDeprecationWarning,
-            stacklevel=2,
-        )
-
     # update control properties
     if idle_wires is not None:
         temp_style["formatter.control.show_idle"] = idle_wires