qiskit 1.4.2__cp39-abi3-win_amd64.whl → 2.0.0rc2__cp39-abi3-win_amd64.whl

qiskit/scheduler/lowering.py

@@ -1,187 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2020.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Lower gates to schedules. The relative timing within gates is respected. This
-module handles the translation, but does not handle timing.
-"""
-from collections import namedtuple
-from typing import Dict, List, Optional, Union
-
-from qiskit.circuit.barrier import Barrier
-from qiskit.circuit.delay import Delay
-from qiskit.circuit.duration import convert_durations_to_dt
-from qiskit.circuit.measure import Measure
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.exceptions import QiskitError
-from qiskit.pulse import Schedule
-from qiskit.pulse import instructions as pulse_inst
-from qiskit.pulse.channels import AcquireChannel, MemorySlot, DriveChannel
-from qiskit.pulse.exceptions import PulseError
-from qiskit.pulse.macros import measure
-from qiskit.scheduler.config import ScheduleConfig
-from qiskit.providers import BackendV1, BackendV2
-
-CircuitPulseDef = namedtuple(
-    "CircuitPulseDef",
-    ["schedule", "qubits"],  # The schedule which implements the quantum circuit command
-)  # The labels of the qubits involved in the command according to the circuit
-
-
-def lower_gates(
-    circuit: QuantumCircuit,
-    schedule_config: ScheduleConfig,
-    backend: Optional[Union[BackendV1, BackendV2]] = None,
-) -> List[CircuitPulseDef]:
-    """
-    Return a list of Schedules and the qubits they operate on, for each element encountered in the
-    input circuit.
-
-    Without concern for the final schedule, extract and return a list of Schedules and the qubits
-    they operate on, for each element encountered in the input circuit. Measures are grouped when
-    possible, so ``qc.measure(q0, c0)`` or ``qc.measure(q1, c1)`` will generate a synchronous
-    measurement pulse.
-
-    Args:
-        circuit: The quantum circuit to translate.
-        schedule_config: Backend specific parameters used for building the Schedule.
-        backend: Pass in the backend used to build the Schedule, the backend could be BackendV1
-                 or BackendV2
-
-    Returns:
-        A list of CircuitPulseDefs: the pulse definition for each circuit element.
-
-    Raises:
-        QiskitError: If circuit uses a command that isn't defined in config.inst_map.
-    """
-    from qiskit.pulse.transforms.base_transforms import target_qobj_transform
-
-    circ_pulse_defs = []
-
-    inst_map = schedule_config.inst_map
-    qubit_mem_slots = {}  # Map measured qubit index to classical bit index
-
-    # convert the unit of durations from SI to dt before lowering
-    circuit = convert_durations_to_dt(circuit, dt_in_sec=schedule_config.dt, inplace=False)
-
-    def get_measure_schedule(qubit_mem_slots: Dict[int, int]) -> CircuitPulseDef:
-        """Create a schedule to measure the qubits queued for measuring."""
-        sched = Schedule()
-        # Exclude acquisition on these qubits, since they are handled by the user calibrations
-        acquire_excludes = {}
-        if Measure().name in circuit.calibrations.keys():
-            qubits = tuple(sorted(qubit_mem_slots.keys()))
-            params = ()
-            for qubit in qubits:
-                try:
-                    meas_q = circuit.calibrations[Measure().name][((qubit,), params)]
-                    meas_q = target_qobj_transform(meas_q)
-                    acquire_q = meas_q.filter(channels=[AcquireChannel(qubit)])
-                    mem_slot_index = [
-                        chan.index for chan in acquire_q.channels if isinstance(chan, MemorySlot)
-                    ][0]
-                    if mem_slot_index != qubit_mem_slots[qubit]:
-                        raise KeyError(
-                            "The measurement calibration is not defined on "
-                            "the requested classical bits"
-                        )
-                    sched |= meas_q
-                    del qubit_mem_slots[qubit]
-                    acquire_excludes[qubit] = mem_slot_index
-                except KeyError:
-                    pass
-
-        if qubit_mem_slots:
-            qubits = list(qubit_mem_slots.keys())
-            qubit_mem_slots.update(acquire_excludes)
-            meas_sched = measure(
-                qubits=qubits,
-                backend=backend,
-                inst_map=inst_map,
-                meas_map=schedule_config.meas_map,
-                qubit_mem_slots=qubit_mem_slots,
-            )
-            meas_sched = target_qobj_transform(meas_sched)
-            meas_sched = meas_sched.exclude(
-                channels=[AcquireChannel(qubit) for qubit in acquire_excludes]
-            )
-            sched |= meas_sched
-        qubit_mem_slots.clear()
-        return CircuitPulseDef(
-            schedule=sched,
-            qubits=[chan.index for chan in sched.channels if isinstance(chan, AcquireChannel)],
-        )
-
-    qubit_indices = {bit: idx for idx, bit in enumerate(circuit.qubits)}
-    clbit_indices = {bit: idx for idx, bit in enumerate(circuit.clbits)}
-
-    for instruction in circuit.data:
-        inst_qubits = [qubit_indices[qubit] for qubit in instruction.qubits]
-
-        if any(q in qubit_mem_slots for q in inst_qubits):
-            # If we are operating on a qubit that was scheduled to be measured, process that first
-            circ_pulse_defs.append(get_measure_schedule(qubit_mem_slots))
-
-        if isinstance(instruction.operation, Barrier):
-            circ_pulse_defs.append(
-                CircuitPulseDef(schedule=instruction.operation, qubits=inst_qubits)
-            )
-        elif isinstance(instruction.operation, Delay):
-            sched = Schedule(name=instruction.operation.name)
-            for qubit in inst_qubits:
-                for channel in [DriveChannel]:
-                    sched += pulse_inst.Delay(
-                        duration=instruction.operation.duration, channel=channel(qubit)
-                    )
-            circ_pulse_defs.append(CircuitPulseDef(schedule=sched, qubits=inst_qubits))
-        elif isinstance(instruction.operation, Measure):
-            if len(inst_qubits) != 1 and len(instruction.clbits) != 1:
-                raise QiskitError(
-                    f"Qubit '{inst_qubits}' or classical bit '{instruction.clbits}' errored because the "
-                    "circuit Measure instruction only takes one of "
-                    "each."
-                )
-            qubit_mem_slots[inst_qubits[0]] = clbit_indices[instruction.clbits[0]]
-        else:
-            try:
-                gate_cals = circuit.calibrations[instruction.operation.name]
-                schedule = gate_cals[
-                    (
-                        tuple(inst_qubits),
-                        tuple(
-                            p if getattr(p, "parameters", None) else float(p)
-                            for p in instruction.operation.params
-                        ),
-                    )
-                ]
-                schedule = target_qobj_transform(schedule)
-                circ_pulse_defs.append(CircuitPulseDef(schedule=schedule, qubits=inst_qubits))
-                continue
-            except KeyError:
-                pass  # Calibration not defined for this operation
-
-            try:
-                schedule = inst_map.get(
-                    instruction.operation, inst_qubits, *instruction.operation.params
-                )
-                schedule = target_qobj_transform(schedule)
-                circ_pulse_defs.append(CircuitPulseDef(schedule=schedule, qubits=inst_qubits))
-            except PulseError as ex:
-                raise QiskitError(
-                    f"Operation '{instruction.operation.name}' on qubit(s) {inst_qubits} "
-                    "not supported by the backend command definition. Did you remember to "
-                    "transpile your input circuit for the same backend?"
-                ) from ex
-
-    if qubit_mem_slots:
-        circ_pulse_defs.append(get_measure_schedule(qubit_mem_slots))
-
-    return circ_pulse_defs

qiskit/scheduler/methods/__init__.py

@@ -1,15 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2019.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Scheduling methods."""
-
-from qiskit.scheduler.methods.basic import as_soon_as_possible, as_late_as_possible

qiskit/scheduler/methods/basic.py

@@ -1,140 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2019.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""
-The most straightforward scheduling methods: scheduling **as early** or **as late** as possible.
-"""
-from collections import defaultdict
-from typing import List, Optional, Union
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.barrier import Barrier
-from qiskit.pulse.schedule import Schedule
-
-from qiskit.scheduler.config import ScheduleConfig
-from qiskit.scheduler.lowering import lower_gates
-from qiskit.providers import BackendV1, BackendV2
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-
-@deprecate_pulse_dependency(moving_to_dynamics=True)
-def as_soon_as_possible(
-    circuit: QuantumCircuit,
-    schedule_config: ScheduleConfig,
-    backend: Optional[Union[BackendV1, BackendV2]] = None,
-) -> Schedule:
-    """
-    Return the pulse Schedule which implements the input circuit using an "as soon as possible"
-    (asap) scheduling policy.
-
-    Circuit instructions are first each mapped to equivalent pulse
-    Schedules according to the command definition given by the schedule_config. Then, this circuit
-    instruction-equivalent Schedule is appended at the earliest time at which all qubits involved
-    in the instruction are available.
-
-    Args:
-        circuit: The quantum circuit to translate.
-        schedule_config: Backend specific parameters used for building the Schedule.
-        backend: A backend used to build the Schedule, the backend could be BackendV1
-                 or BackendV2.
-
-    Returns:
-        A schedule corresponding to the input ``circuit`` with pulses occurring as early as
-        possible.
-    """
-    qubit_time_available = defaultdict(int)
-
-    def update_times(inst_qubits: List[int], time: int = 0) -> None:
-        """Update the time tracker for all inst_qubits to the given time."""
-        for q in inst_qubits:
-            qubit_time_available[q] = time
-
-    start_times = []
-    circ_pulse_defs = lower_gates(circuit, schedule_config, backend)
-    for circ_pulse_def in circ_pulse_defs:
-        start_time = max(qubit_time_available[q] for q in circ_pulse_def.qubits)
-        stop_time = start_time
-        if not isinstance(circ_pulse_def.schedule, Barrier):
-            stop_time += circ_pulse_def.schedule.duration
-
-        start_times.append(start_time)
-        update_times(circ_pulse_def.qubits, stop_time)
-
-    timed_schedules = [
-        (time, cpd.schedule)
-        for time, cpd in zip(start_times, circ_pulse_defs)
-        if not isinstance(cpd.schedule, Barrier)
-    ]
-    schedule = Schedule.initialize_from(circuit)
-    for time, inst in timed_schedules:
-        schedule.insert(time, inst, inplace=True)
-    return schedule
-
-
-@deprecate_pulse_dependency(moving_to_dynamics=True)
-def as_late_as_possible(
-    circuit: QuantumCircuit,
-    schedule_config: ScheduleConfig,
-    backend: Optional[Union[BackendV1, BackendV2]] = None,
-) -> Schedule:
-    """
-    Return the pulse Schedule which implements the input circuit using an "as late as possible"
-    (alap) scheduling policy.
-
-    Circuit instructions are first each mapped to equivalent pulse
-    Schedules according to the command definition given by the schedule_config. Then, this circuit
-    instruction-equivalent Schedule is appended at the latest time that it can be without allowing
-    unnecessary time between instructions or allowing instructions with common qubits to overlap.
-
-    This method should improves the outcome fidelity over ASAP scheduling, because we may
-    maximize the time that the qubit remains in the ground state.
-
-    Args:
-        circuit: The quantum circuit to translate.
-        schedule_config: Backend specific parameters used for building the Schedule.
-        backend: A backend used to build the Schedule, the backend could be BackendV1
-                 or BackendV2.
-
-    Returns:
-        A schedule corresponding to the input ``circuit`` with pulses occurring as late as
-        possible.
-    """
-    qubit_time_available = defaultdict(int)
-
-    def update_times(inst_qubits: List[int], time: int = 0) -> None:
-        """Update the time tracker for all inst_qubits to the given time."""
-        for q in inst_qubits:
-            qubit_time_available[q] = time
-
-    rev_stop_times = []
-    circ_pulse_defs = lower_gates(circuit, schedule_config, backend)
-    for circ_pulse_def in reversed(circ_pulse_defs):
-        start_time = max(qubit_time_available[q] for q in circ_pulse_def.qubits)
-        stop_time = start_time
-        if not isinstance(circ_pulse_def.schedule, Barrier):
-            stop_time += circ_pulse_def.schedule.duration
-
-        rev_stop_times.append(stop_time)
-        update_times(circ_pulse_def.qubits, stop_time)
-
-    last_stop = max(t for t in qubit_time_available.values()) if qubit_time_available else 0
-    start_times = [last_stop - t for t in reversed(rev_stop_times)]
-
-    timed_schedules = [
-        (time, cpd.schedule)
-        for time, cpd in zip(start_times, circ_pulse_defs)
-        if not isinstance(cpd.schedule, Barrier)
-    ]
-    schedule = Schedule.initialize_from(circuit)
-    for time, inst in timed_schedules:
-        schedule.insert(time, inst, inplace=True)
-    return schedule

qiskit/scheduler/schedule_circuit.py

@@ -1,69 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2019.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""QuantumCircuit to Pulse scheduler."""
-from typing import Optional, Union
-
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.exceptions import QiskitError
-
-from qiskit.pulse.schedule import Schedule
-from qiskit.scheduler.config import ScheduleConfig
-from qiskit.scheduler.methods import as_soon_as_possible, as_late_as_possible
-from qiskit.providers import BackendV1, BackendV2
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-
-@deprecate_pulse_dependency(moving_to_dynamics=True)
-def schedule_circuit(
-    circuit: QuantumCircuit,
-    schedule_config: ScheduleConfig,
-    method: Optional[str] = None,
-    backend: Optional[Union[BackendV1, BackendV2]] = None,
-) -> Schedule:
-    """
-    Basic scheduling pass from a circuit to a pulse Schedule, using the backend. If no method is
-    specified, then a basic, as late as possible scheduling pass is performed, i.e. pulses are
-    scheduled to occur as late as possible.
-
-    Supported methods:
-
-        * ``'as_soon_as_possible'``: Schedule pulses greedily, as early as possible on a
-          qubit resource. (alias: ``'asap'``)
-        * ``'as_late_as_possible'``: Schedule pulses late-- keep qubits in the ground state when
-          possible. (alias: ``'alap'``)
-
-    Args:
-        circuit: The quantum circuit to translate.
-        schedule_config: Backend specific parameters used for building the Schedule.
-        method: The scheduling pass method to use.
-        backend: A backend used to build the Schedule, the backend could be BackendV1
-                 or BackendV2.
-
-    Returns:
-        Schedule corresponding to the input circuit.
-
-    Raises:
-        QiskitError: If method isn't recognized.
-    """
-    methods = {
-        "as_soon_as_possible": as_soon_as_possible,
-        "asap": as_soon_as_possible,
-        "as_late_as_possible": as_late_as_possible,
-        "alap": as_late_as_possible,
-    }
-    if method is None:
-        method = "as_late_as_possible"
-    try:
-        return methods[method](circuit, schedule_config, backend)
-    except KeyError as ex:
-        raise QiskitError(f"Scheduling method {method} isn't recognized.") from ex

qiskit/scheduler/sequence.py

@@ -1,104 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2020.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""
-Mapping a scheduled QuantumCircuit to a pulse Schedule.
-"""
-from collections import defaultdict
-
-from typing import Optional, Union
-from qiskit.circuit.barrier import Barrier
-from qiskit.circuit.measure import Measure
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.exceptions import QiskitError
-from qiskit.pulse.schedule import Schedule
-from qiskit.pulse.transforms import pad
-from qiskit.scheduler.config import ScheduleConfig
-from qiskit.scheduler.lowering import lower_gates
-from qiskit.providers import BackendV1, BackendV2
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
-
-
-@deprecate_pulse_dependency(moving_to_dynamics=True)
-def sequence(
-    scheduled_circuit: QuantumCircuit,
-    schedule_config: ScheduleConfig,
-    backend: Optional[Union[BackendV1, BackendV2]] = None,
-) -> Schedule:
-    """
-    Return the pulse Schedule which implements the input scheduled circuit.
-
-    Assume all measurements are done at once at the last of the circuit.
-    Schedules according to the command definition given by the schedule_config.
-
-    Args:
-        scheduled_circuit: The scheduled quantum circuit to translate.
-        schedule_config: Backend specific parameters used for building the Schedule.
-        backend: A backend used to build the Schedule, the backend could be BackendV1
-                 or BackendV2
-
-    Returns:
-        A schedule corresponding to the input ``circuit``.
-
-    Raises:
-        QiskitError: If invalid scheduled circuit is supplied.
-    """
-    circ_pulse_defs = lower_gates(scheduled_circuit, schedule_config, backend)
-
-    # find the measurement start time (assume measurement once)
-    def _meas_start_time():
-        _qubit_time_available = defaultdict(int)
-        for instruction in scheduled_circuit.data:
-            if isinstance(instruction.operation, Measure):
-                return _qubit_time_available[instruction.qubits[0]]
-            for q in instruction.qubits:
-                _qubit_time_available[q] += instruction.operation.duration
-        return None
-
-    meas_time = _meas_start_time()
-
-    # restore start times
-    qubit_time_available = {}
-    start_times = []
-    out_circ_pulse_defs = []
-    for circ_pulse_def in circ_pulse_defs:
-        active_qubits = [q for q in circ_pulse_def.qubits if q in qubit_time_available]
-
-        start_time = max((qubit_time_available[q] for q in active_qubits), default=0)
-
-        for q in active_qubits:
-            if qubit_time_available[q] != start_time:
-                # print(q, ":", qubit_time_available[q], "!=", start_time)
-                raise QiskitError("Invalid scheduled circuit.")
-
-        stop_time = start_time
-        if not isinstance(circ_pulse_def.schedule, Barrier):
-            stop_time += circ_pulse_def.schedule.duration
-
-        delay_overlaps_meas = False
-        for q in circ_pulse_def.qubits:
-            qubit_time_available[q] = stop_time
-            if (
-                meas_time is not None
-                and circ_pulse_def.schedule.name == "delay"
-                and stop_time > meas_time
-            ):
-                qubit_time_available[q] = meas_time
-                delay_overlaps_meas = True
-        # skip to delays overlapping measures and barriers
-        if not delay_overlaps_meas and not isinstance(circ_pulse_def.schedule, Barrier):
-            start_times.append(start_time)
-            out_circ_pulse_defs.append(circ_pulse_def)
-
-    timed_schedules = [(time, cpd.schedule) for time, cpd in zip(start_times, out_circ_pulse_defs)]
-    sched = Schedule(*timed_schedules, name=scheduled_circuit.name)
-    return pad(sched)

qiskit/transpiler/passes/calibration/__init__.py

@@ -1,17 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2021
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Module containing transpiler calibration passes."""
-
-from .pulse_gate import PulseGates
-from .rzx_builder import RZXCalibrationBuilder, RZXCalibrationBuilderNoEcho
-from .rx_builder import RXCalibrationBuilder

qiskit/transpiler/passes/calibration/base_builder.py

@@ -1,79 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2022.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Calibration builder base class."""
-
-from abc import abstractmethod
-from typing import List, Union
-
-from qiskit.circuit import Instruction as CircuitInst
-from qiskit.dagcircuit import DAGCircuit
-from qiskit.pulse import Schedule, ScheduleBlock
-from qiskit.pulse.calibration_entries import CalibrationPublisher
-from qiskit.transpiler.basepasses import TransformationPass
-
-from .exceptions import CalibrationNotAvailable
-
-
-class CalibrationBuilder(TransformationPass):
-    """Abstract base class to inject calibrations into circuits."""
-
-    @abstractmethod
-    def supported(self, node_op: CircuitInst, qubits: List) -> bool:
-        """Determine if a given node supports the calibration.
-
-        Args:
-            node_op: Target instruction object.
-            qubits: Integer qubit indices to check.
-
-        Returns:
-            Return ``True`` is calibration can be provided.
-        """
-
-    @abstractmethod
-    def get_calibration(self, node_op: CircuitInst, qubits: List) -> Union[Schedule, ScheduleBlock]:
-        """Gets the calibrated schedule for the given instruction and qubits.
-
-        Args:
-            node_op: Target instruction object.
-            qubits: Integer qubit indices to check.
-
-        Returns:
-            Return Schedule of target gate instruction.
-        """
-
-    def run(self, dag: DAGCircuit) -> DAGCircuit:
-        """Run the calibration adder pass on `dag`.
-
-        Args:
-            dag: DAG to schedule.
-
-        Returns:
-            A DAG with calibrations added to it.
-        """
-        for node in dag.gate_nodes():
-            qubits = [dag.find_bit(q).index for q in node.qargs]
-
-            if self.supported(node.op, qubits) and not dag.has_calibration_for(node):
-                # calibration can be provided and no user-defined calibration is already provided
-                try:
-                    schedule = self.get_calibration(node.op, qubits)
-                except CalibrationNotAvailable:
-                    # Fail in schedule generation. Just ignore.
-                    continue
-                publisher = schedule.metadata.get("publisher", CalibrationPublisher.QISKIT)
-
-                # add calibration if it is not backend default
-                if publisher != CalibrationPublisher.BACKEND_PROVIDER:
-                    dag.add_calibration(gate=node.op, qubits=qubits, schedule=schedule)
-
-        return dag

qiskit/transpiler/passes/calibration/builders.py

@@ -1,20 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2021.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Calibration creators."""
-
-# TODO This import path will be deprecated.
-
-# pylint: disable=unused-import
-from .pulse_gate import PulseGates
-from .rzx_builder import RZXCalibrationBuilder, RZXCalibrationBuilderNoEcho
-from .rx_builder import RXCalibrationBuilder

qiskit/transpiler/passes/calibration/exceptions.py

@@ -1,22 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2022.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Exception for errors raised by the calibration pass module."""
-from qiskit.exceptions import QiskitError
-
-
-class CalibrationNotAvailable(QiskitError):
-    """Raised when calibration generation fails.
-
-    .. note::
-        This error is meant to caught by CalibrationBuilder and ignored.
-    """