qiskit 1.4.1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/providers/models/jobstatus.py

@@ -1,77 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2018.
-#
-# 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.
-
-"""Class for job status."""
-
-from qiskit.utils import deprecate_func
-
-
-class JobStatus:
-    """Model for JobStatus.
-
-    Attributes:
-        job_id (str): backend job_id.
-        status (str): status of the job.
-        status_msg (str): status message.
-    """
-
-    _data = {}
-
-    @deprecate_func(
-        since="1.4",
-        removal_timeline="in the 2.0 release",
-        additional_msg="The models in ``qiskit.providers.models`` and related objects are part "
-        "of the deprecated `BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
-        "workflow requires these representations it likely relies on deprecated functionality and "
-        "should be updated to use `BackendV2`.",
-        stacklevel=2,
-    )
-    def __init__(self, job_id, status, status_msg, **kwargs):
-        self._data = {}
-        self.job_id = job_id
-        self.status = status
-        self.status_msg = status_msg
-        self._data.update(kwargs)
-
-    @classmethod
-    def from_dict(cls, data):
-        """Create a new JobStatus object from a dictionary.
-
-        Args:
-            data (dict): A dictionary representing the JobStatus to create.
-                         It will be in the same format as output by
-                         :meth:`to_dict`.
-
-        Returns:
-            JobStatus: The ``JobStatus`` from the input dictionary.
-        """
-        return cls(**data)
-
-    def to_dict(self):
-        """Return a dictionary format representation of the JobStatus.
-
-        Returns:
-            dict: The dictionary form of the JobStatus.
-        """
-        out_dict = {
-            "job_id": self.job_id,
-            "status": self.status,
-            "status_msg": self.status_msg,
-        }
-        out_dict.update(self._data)
-        return out_dict
-
-    def __getattr__(self, name):
-        try:
-            return self._data[name]
-        except KeyError as ex:
-            raise AttributeError(f"Attribute {name} is not defined") from ex

qiskit/providers/models/pulsedefaults.py

@@ -1,305 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 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.
-
-
-"""Model and schema for pulse defaults."""
-import warnings
-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:
-    """Class representing a Measurement Kernel."""
-
-    def __init__(self, name, params):
-        """Initialize a MeasurementKernel object
-
-        Args:
-            name (str): The name of the measurement kernel
-            params: The parameters of the measurement kernel
-        """
-        self.name = name
-        self.params = params
-
-    def to_dict(self):
-        """Return a dictionary format representation of the MeasurementKernel.
-
-        Returns:
-            dict: The dictionary form of the MeasurementKernel.
-        """
-        return {"name": self.name, "params": self.params}
-
-    @classmethod
-    def from_dict(cls, data):
-        """Create a new MeasurementKernel object from a dictionary.
-
-        Args:
-            data (dict): A dictionary representing the MeasurementKernel
-                         to create. It will be in the same format as output by
-                         :meth:`to_dict`.
-
-        Returns:
-            MeasurementKernel: The MeasurementKernel from the input dictionary.
-        """
-        return cls(**data)
-
-
-class Discriminator:
-    """Class representing a Discriminator."""
-
-    def __init__(self, name, params):
-        """Initialize a Discriminator object
-
-        Args:
-            name (str): The name of the discriminator
-            params: The parameters of the discriminator
-        """
-        self.name = name
-        self.params = params
-
-    def to_dict(self):
-        """Return a dictionary format representation of the Discriminator.
-
-        Returns:
-            dict: The dictionary form of the Discriminator.
-        """
-        return {"name": self.name, "params": self.params}
-
-    @classmethod
-    def from_dict(cls, data):
-        """Create a new Discriminator object from a dictionary.
-
-        Args:
-            data (dict): A dictionary representing the Discriminator
-                         to create. It will be in the same format as output by
-                         :meth:`to_dict`.
-
-        Returns:
-            Discriminator: The Discriminator from the input dictionary.
-        """
-        return cls(**data)
-
-
-class Command:
-    """Class representing a Command.
-
-    Attributes:
-        name: Pulse command name.
-    """
-
-    _data = {}
-
-    def __init__(self, name: str, qubits=None, sequence=None, **kwargs):
-        """Initialize a Command object
-
-        Args:
-            name (str): The name of the command
-            qubits: The qubits for the command
-            sequence (PulseQobjInstruction): The sequence for the Command
-            kwargs: Optional additional fields
-        """
-        self._data = {}
-        self.name = name
-        if qubits is not None:
-            self.qubits = qubits
-        if sequence is not None:
-            self.sequence = sequence
-        self._data.update(kwargs)
-
-    def __getattr__(self, name):
-        try:
-            return self._data[name]
-        except KeyError as ex:
-            raise AttributeError(f"Attribute {name} is not defined") from ex
-
-    def to_dict(self):
-        """Return a dictionary format representation of the Command.
-
-        Returns:
-            dict: The dictionary form of the Command.
-        """
-        out_dict = {"name": self.name}
-        if hasattr(self, "qubits"):
-            out_dict["qubits"] = self.qubits
-        if hasattr(self, "sequence"):
-            out_dict["sequence"] = [x.to_dict() for x in self.sequence]
-        out_dict.update(self._data)
-        return out_dict
-
-    @classmethod
-    def from_dict(cls, data):
-        """Create a new Command object from a dictionary.
-
-        Args:
-            data (dict): A dictionary representing the ``Command``
-                         to create. It will be in the same format as output by
-                         :meth:`to_dict`.
-
-        Returns:
-            Command: The ``Command`` from the input dictionary.
-        """
-        # Pulse command data is nested dictionary.
-        # To avoid deepcopy and avoid mutating the source object, create new dict here.
-        in_data = {}
-        for key, value in data.items():
-            if key == "sequence":
-                in_data[key] = list(map(PulseQobjInstruction.from_dict, value))
-            else:
-                in_data[key] = value
-        return cls(**in_data)
-
-
-class PulseDefaults:
-    """Description of default settings for Pulse systems. These are instructions or settings that
-    may be good starting points for the Pulse user. The user may modify these defaults for custom
-    scheduling.
-    """
-
-    _data = {}
-
-    @deprecate_pulse_dependency
-    def __init__(
-        self,
-        qubit_freq_est: List[float],
-        meas_freq_est: List[float],
-        buffer: int,
-        pulse_library: List[PulseLibraryItem],
-        cmd_def: List[Command],
-        meas_kernel: MeasurementKernel = None,
-        discriminator: Discriminator = None,
-        **kwargs: Dict[str, Any],
-    ):
-        """
-        Validate and reformat transport layer inputs to initialize.
-        Args:
-            qubit_freq_est: Estimated qubit frequencies in GHz.
-            meas_freq_est: Estimated measurement cavity frequencies in GHz.
-            buffer: Default buffer time (in units of dt) between pulses.
-            pulse_library: Pulse name and sample definitions.
-            cmd_def: Operation name and definition in terms of Commands.
-            meas_kernel: The measurement kernels
-            discriminator: The discriminators
-            **kwargs: Other attributes for the super class.
-        """
-        self._data = {}
-        self.buffer = buffer
-        self.qubit_freq_est = [freq * 1e9 for freq in qubit_freq_est]
-        """Qubit frequencies in Hertz."""
-        self.meas_freq_est = [freq * 1e9 for freq in meas_freq_est]
-        """Measurement frequencies in Hertz."""
-        self.pulse_library = pulse_library
-        self.cmd_def = cmd_def
-        self.instruction_schedule_map = InstructionScheduleMap()
-        self.converter = QobjToInstructionConverter(pulse_library)
-
-        for inst in cmd_def:
-            entry = PulseQobjDef(converter=self.converter, name=inst.name)
-            entry.define(inst.sequence, user_provided=False)
-            self.instruction_schedule_map._add(
-                instruction_name=inst.name,
-                qubits=tuple(inst.qubits),
-                entry=entry,
-            )
-
-        if meas_kernel is not None:
-            self.meas_kernel = meas_kernel
-        if discriminator is not None:
-            self.discriminator = discriminator
-
-        self._data.update(kwargs)
-
-    def __getattr__(self, name):
-        try:
-            return self._data[name]
-        except KeyError as ex:
-            raise AttributeError(f"Attribute {name} is not defined") from ex
-
-    def to_dict(self):
-        """Return a dictionary format representation of the PulseDefaults.
-        Returns:
-            dict: The dictionary form of the PulseDefaults.
-        """
-        out_dict = {
-            "qubit_freq_est": self.qubit_freq_est,
-            "meas_freq_est": self.qubit_freq_est,
-            "buffer": self.buffer,
-            "pulse_library": [x.to_dict() for x in self.pulse_library],
-            "cmd_def": [x.to_dict() for x in self.cmd_def],
-        }
-        if hasattr(self, "meas_kernel"):
-            out_dict["meas_kernel"] = self.meas_kernel.to_dict()
-        if hasattr(self, "discriminator"):
-            out_dict["discriminator"] = self.discriminator.to_dict()
-        for key, value in self.__dict__.items():
-            if key not in [
-                "qubit_freq_est",
-                "meas_freq_est",
-                "buffer",
-                "pulse_library",
-                "cmd_def",
-                "meas_kernel",
-                "discriminator",
-                "converter",
-                "instruction_schedule_map",
-            ]:
-                out_dict[key] = value
-        out_dict.update(self._data)
-
-        out_dict["qubit_freq_est"] = [freq * 1e-9 for freq in self.qubit_freq_est]
-        out_dict["meas_freq_est"] = [freq * 1e-9 for freq in self.meas_freq_est]
-        return out_dict
-
-    @classmethod
-    def from_dict(cls, data):
-        """Create a new PulseDefaults object from a dictionary.
-
-        Args:
-            data (dict): A dictionary representing the PulseDefaults
-                         to create. It will be in the same format as output by
-                         :meth:`to_dict`.
-        Returns:
-            PulseDefaults: The PulseDefaults from the input dictionary.
-        """
-        schema = {
-            "pulse_library": PulseLibraryItem,  # The class PulseLibraryItem is deprecated
-            "cmd_def": Command,
-            "meas_kernel": MeasurementKernel,
-            "discriminator": Discriminator,
-        }
-
-        # Pulse defaults data is nested dictionary.
-        # To avoid deepcopy and avoid mutating the source object, create new dict here.
-        in_data = {}
-        for key, value in data.items():
-            if key in schema:
-                with warnings.catch_warnings():
-                    # The class PulseLibraryItem is deprecated
-                    warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
-                    if isinstance(value, list):
-                        in_data[key] = list(map(schema[key].from_dict, value))
-                    else:
-                        in_data[key] = schema[key].from_dict(value)
-            else:
-                in_data[key] = value
-
-        return cls(**in_data)
-
-    def __str__(self):
-        qubit_freqs = [freq / 1e9 for freq in self.qubit_freq_est]
-        meas_freqs = [freq / 1e9 for freq in self.meas_freq_est]
-        qfreq = f"Qubit Frequencies [GHz]\n{qubit_freqs}"
-        mfreq = f"Measurement Frequencies [GHz]\n{meas_freqs} "
-        return f"<{self.__class__.__name__}({str(self.instruction_schedule_map)}{qfreq}\n{mfreq})>"

qiskit/providers/provider.py

@@ -1,95 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2023.
-#
-# 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.
-
-"""Base class for a provider."""
-
-from abc import ABC, abstractmethod
-
-from qiskit.providers.exceptions import QiskitBackendNotFoundError
-from qiskit.utils import deprecate_func
-
-
-class Provider:
-    """Base common type for all versioned Provider abstract classes.
-
-    Note this class should not be inherited from directly, it is intended
-    to be used for type checking. When implementing a provider you should use
-    the versioned abstract classes as the parent class and not this class
-    directly.
-    """
-
-    version = 0
-
-    @deprecate_func(
-        since=1.1,
-        additional_msg="The abstract Provider and ProviderV1 classes are deprecated and will be "
-        "removed in 2.0. You can just remove it as the parent class and a `get_backend` "
-        "method that returns the backends from `self.backend`.",
-    )
-    def __init__(self):
-        pass
-
-
-class ProviderV1(Provider, ABC):
-    """Base class for a Backend Provider."""
-
-    version = 1
-
-    @deprecate_func(
-        since=1.1,
-        additional_msg="The abstract Provider and ProviderV1 classes are deprecated and will  be "
-        "removed in 2.0. You can just remove it as the parent class and a `get_backend` "
-        "method that returns the backends from `self.backend`.",
-    )
-    def get_backend(self, name=None, **kwargs):
-        """Return a single backend matching the specified filtering.
-
-        Args:
-            name (str): name of the backend.
-            **kwargs: dict used for filtering.
-
-        Returns:
-            Backend: a backend matching the filtering.
-
-        Raises:
-            QiskitBackendNotFoundError: if no backend could be found or
-                more than one backend matches the filtering criteria.
-        """
-        backends = self.backends(name, **kwargs)
-        if len(backends) > 1:
-            raise QiskitBackendNotFoundError("More than one backend matches the criteria")
-        if not backends:
-            raise QiskitBackendNotFoundError("No backend matches the criteria")
-
-        return backends[0]
-
-    @abstractmethod
-    def backends(self, name=None, **kwargs):
-        """Return a list of backends matching the specified filtering.
-
-        Args:
-            name (str): name of the backend.
-            **kwargs: dict used for filtering.
-
-        Returns:
-            list[Backend]: a list of Backends that match the filtering
-                criteria.
-        """
-        pass
-
-    def __eq__(self, other):
-        """Equality comparison.
-
-        By default, it is assumed that two `Providers` from the same class are
-        equal. Subclassed providers can override this behavior.
-        """
-        return type(self).__name__ == type(other).__name__

qiskit/pulse/__init__.py

@@ -1,158 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 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.
-
-r"""
-===========================
-Pulse (:mod:`qiskit.pulse`)
-===========================
-
-.. currentmodule:: qiskit.pulse
-
-Qiskit-Pulse is a pulse-level quantum programming kit. This lower level of
-programming offers the user more control than programming with
-:py:class:`~qiskit.circuit.QuantumCircuit`\ s.
-
-Extracting the greatest performance from quantum hardware requires real-time
-pulse-level instructions. Pulse answers that need: it enables the quantum
-physicist *user* to specify the exact time dynamics of an experiment.
-It is especially powerful for error mitigation techniques.
-
-The input is given as arbitrary, time-ordered signals (see: :ref:`Instructions <pulse-insts>`)
-scheduled in parallel over multiple virtual hardware or simulator resources
-(see: :ref:`Channels <pulse-channels>`). The system also allows the user to recover the
-time dynamics of the measured output.
-
-This is sufficient to allow the quantum physicist to explore and correct for
-noise in a quantum system.
-
-.. automodule:: qiskit.pulse.instructions
-.. automodule:: qiskit.pulse.library
-.. automodule:: qiskit.pulse.channels
-.. automodule:: qiskit.pulse.schedule
-.. automodule:: qiskit.pulse.transforms
-.. automodule:: qiskit.pulse.builder
-
-.. currentmodule:: qiskit.pulse
-
-Configuration
-=============
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   InstructionScheduleMap
-
-Exceptions
-==========
-
-.. autoexception:: PulseError
-.. autoexception:: BackendNotSet
-.. autoexception:: NoActiveBuilder
-.. autoexception:: UnassignedDurationError
-.. autoexception:: UnassignedReferenceError
-"""
-
-# Builder imports.
-from qiskit.pulse.builder import (
-    # Construction methods.
-    active_backend,
-    build,
-    num_qubits,
-    qubit_channels,
-    samples_to_seconds,
-    seconds_to_samples,
-    # Instructions.
-    acquire,
-    barrier,
-    call,
-    delay,
-    play,
-    reference,
-    set_frequency,
-    set_phase,
-    shift_frequency,
-    shift_phase,
-    snapshot,
-    # Channels.
-    acquire_channel,
-    control_channels,
-    drive_channel,
-    measure_channel,
-    # Contexts.
-    align_equispaced,
-    align_func,
-    align_left,
-    align_right,
-    align_sequential,
-    frequency_offset,
-    phase_offset,
-    # Macros.
-    macro,
-    measure,
-    measure_all,
-    delay_qubits,
-)
-from qiskit.pulse.channels import (
-    AcquireChannel,
-    ControlChannel,
-    DriveChannel,
-    MeasureChannel,
-    MemorySlot,
-    RegisterSlot,
-    SnapshotChannel,
-)
-from qiskit.pulse.configuration import (
-    Discriminator,
-    Kernel,
-    LoConfig,
-    LoRange,
-)
-from qiskit.pulse.exceptions import (
-    PulseError,
-    BackendNotSet,
-    NoActiveBuilder,
-    UnassignedDurationError,
-    UnassignedReferenceError,
-)
-from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
-from qiskit.pulse.instructions import (
-    Acquire,
-    Delay,
-    Instruction,
-    Play,
-    SetFrequency,
-    SetPhase,
-    ShiftFrequency,
-    ShiftPhase,
-    Snapshot,
-)
-from qiskit.pulse.library import (
-    Constant,
-    Drag,
-    Gaussian,
-    GaussianSquare,
-    GaussianSquareDrag,
-    gaussian_square_echo,
-    Sin,
-    Cos,
-    Sawtooth,
-    Triangle,
-    Square,
-    GaussianDeriv,
-    Sech,
-    SechDeriv,
-    SymbolicPulse,
-    ScalableSymbolicPulse,
-    Waveform,
-)
-from qiskit.pulse.library.samplers.decorators import functional_pulse
-from qiskit.pulse.schedule import Schedule, ScheduleBlock