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

qiskit/pulse/utils.py

@@ -1,149 +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.
-
-"""Module for common pulse programming utilities."""
-from typing import List, Dict, Union, Sequence
-import warnings
-
-import numpy as np
-
-from qiskit.circuit import ParameterVector, Parameter
-from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.pulse.exceptions import UnassignedDurationError, QiskitError, PulseError
-
-
-def format_meas_map(meas_map: List[List[int]]) -> Dict[int, List[int]]:
-    """
-    Return a mapping from qubit label to measurement group given the nested list meas_map returned
-    by a backend configuration. (Qubits can not always be measured independently.) Sorts the
-    measurement group for consistency.
-
-    Args:
-        meas_map: Groups of qubits that get measured together, for example: [[0, 1], [2, 3, 4]]
-    Returns:
-        Measure map in map format
-    """
-    qubit_mapping = {}
-    for sublist in meas_map:
-        sublist.sort()
-        for q in sublist:
-            qubit_mapping[q] = sublist
-    return qubit_mapping
-
-
-def format_parameter_value(
-    operand: ParameterExpression,
-    decimal: int = 10,
-) -> Union[ParameterExpression, complex]:
-    """Convert ParameterExpression into the most suitable data type.
-
-    Args:
-        operand: Operand value in arbitrary data type including ParameterExpression.
-        decimal: Number of digit to round returned value.
-
-    Returns:
-        Value casted to non-parameter data type, when possible.
-    """
-    if isinstance(operand, ParameterExpression):
-        try:
-            operand = operand.numeric()
-        except TypeError:
-            # Unassigned expression
-            return operand
-
-    # Return integer before calling the numpy round function.
-    # The input value is multiplied by 10**decimals, rounds to an integer
-    # and divided by 10**decimals. For a large enough integer,
-    # this operation may introduce a rounding error in the float operations
-    # and accidentally returns a float number.
-    if isinstance(operand, int):
-        return operand
-
-    # Remove truncation error and convert the result into Python builtin type.
-    # Value could originally contain a rounding error, e.g. 1.00000000001
-    # which may occur during the parameter expression evaluation.
-    evaluated = np.round(operand, decimals=decimal).item()
-
-    if isinstance(evaluated, complex):
-        if np.isclose(evaluated.imag, 0.0):
-            evaluated = evaluated.real
-        else:
-            warnings.warn(
-                "Assignment of complex values to ParameterExpression in Qiskit Pulse objects is "
-                "now pending deprecation. This will align the Pulse module with other modules "
-                "where such assignment wasn't possible to begin with. The typical use case for complex "
-                "parameters in the module was the SymbolicPulse library. As of Qiskit-Terra "
-                "0.23.0 all library pulses were converted from complex amplitude representation"
-                " to real representation using two floats (amp,angle), as used in the "
-                "ScalableSymbolicPulse class. This eliminated the need for complex parameters. "
-                "Any use of complex parameters (and particularly custom-built pulses) should be "
-                "converted in a similar fashion to avoid the use of complex parameters.",
-                PendingDeprecationWarning,
-            )
-            return evaluated
-    # Type cast integer-like float into Python builtin integer, after rounding.
-    if evaluated.is_integer():
-        return int(evaluated)
-    return evaluated
-
-
-def instruction_duration_validation(duration: int):
-    """Validate instruction duration.
-
-    Args:
-        duration: Instruction duration value to validate.
-
-    Raises:
-        UnassignedDurationError: When duration is unassigned.
-        QiskitError: When invalid duration is assigned.
-    """
-    if isinstance(duration, ParameterExpression):
-        raise UnassignedDurationError(
-            f"Instruction duration {repr(duration)} is not assigned. "
-            "Please bind all durations to an integer value before playing in the Schedule, "
-            "or use ScheduleBlock to align instructions with unassigned duration."
-        )
-
-    if not isinstance(duration, (int, np.integer)) or duration < 0:
-        raise QiskitError(
-            f"Instruction duration must be a non-negative integer, got {duration} instead."
-        )
-
-
-def _validate_parameter_vector(parameter: ParameterVector, value):
-    """Validate parameter vector and its value."""
-    if not isinstance(value, Sequence):
-        raise PulseError(
-            f"Parameter vector '{parameter.name}' has length {len(parameter)},"
-            f" but was assigned to {value}."
-        )
-    if len(parameter) != len(value):
-        raise PulseError(
-            f"Parameter vector '{parameter.name}' has length {len(parameter)},"
-            f" but was assigned to {len(value)} values."
-        )
-
-
-def _validate_single_parameter(parameter: Parameter, value):
-    """Validate single parameter and its value."""
-    if not isinstance(value, (int, float, complex, ParameterExpression)):
-        raise PulseError(f"Parameter '{parameter.name}' is not assignable to {value}.")
-
-
-def _validate_parameter_value(parameter, value):
-    """Validate parameter and its value."""
-    if isinstance(parameter, ParameterVector):
-        _validate_parameter_vector(parameter, value)
-        return True
-    else:
-        _validate_single_parameter(parameter, value)
-        return False

qiskit/qobj/__init__.py

@@ -1,75 +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.
-
-"""
-=========================
-Qobj (:mod:`qiskit.qobj`)
-=========================
-
-.. currentmodule:: qiskit.qobj
-
-Base
-====
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   QobjExperimentHeader
-   QobjHeader
-
-Qasm
-====
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   QasmQobj
-   QasmQobjInstruction
-   QasmQobjExperimentConfig
-   QasmQobjExperiment
-   QasmQobjConfig
-   QasmExperimentCalibrations
-   GateCalibration
-
-Pulse
-=====
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   PulseQobj
-   PulseQobjInstruction
-   PulseQobjExperimentConfig
-   PulseQobjExperiment
-   PulseQobjConfig
-   QobjMeasurementOption
-   PulseLibraryItem
-"""
-
-from qiskit.qobj.common import QobjExperimentHeader
-from qiskit.qobj.common import QobjHeader
-
-from qiskit.qobj.pulse_qobj import PulseQobj
-from qiskit.qobj.pulse_qobj import PulseQobjInstruction
-from qiskit.qobj.pulse_qobj import PulseQobjExperimentConfig
-from qiskit.qobj.pulse_qobj import PulseQobjExperiment
-from qiskit.qobj.pulse_qobj import PulseQobjConfig
-from qiskit.qobj.pulse_qobj import QobjMeasurementOption
-from qiskit.qobj.pulse_qobj import PulseLibraryItem
-
-from qiskit.qobj.qasm_qobj import GateCalibration
-from qiskit.qobj.qasm_qobj import QasmExperimentCalibrations
-from qiskit.qobj.qasm_qobj import QasmQobj
-from qiskit.qobj.qasm_qobj import QasmQobjInstruction
-from qiskit.qobj.qasm_qobj import QasmQobjExperiment
-from qiskit.qobj.qasm_qobj import QasmQobjConfig
-from qiskit.qobj.qasm_qobj import QasmQobjExperimentConfig

qiskit/qobj/common.py

@@ -1,81 +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.
-
-"""Module providing definitions of common Qobj classes."""
-from types import SimpleNamespace
-
-from qiskit.utils import deprecate_func
-
-
-class QobjDictField(SimpleNamespace):
-    """A class used to represent a dictionary field in Qobj
-
-    Exists as a backwards compatibility shim around a dictionary for Qobjs
-    previously constructed using marshmallow.
-    """
-
-    @deprecate_func(
-        since="1.2",
-        removal_timeline="in the 2.0 release",
-        additional_msg="The `Qobj` class and related functionality are part of the deprecated "
-        "`BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
-        "workflow requires `Qobj` it likely relies on deprecated functionality and "
-        "should be updated to use `BackendV2`.",
-    )
-    def __init__(self, **kwargs):
-        """Instantiate a new Qobj dict field object.
-
-        Args:
-            kwargs: arbitrary keyword arguments that can be accessed as
-                attributes of the object.
-        """
-        self.__dict__.update(kwargs)
-
-    def to_dict(self):
-        """Return a dictionary format representation of the OpenQASM 2 Qobj.
-
-        Returns:
-            dict: The dictionary form of the QobjHeader.
-        """
-        return self.__dict__
-
-    @classmethod
-    def from_dict(cls, data):
-        """Create a new QobjHeader object from a dictionary.
-
-        Args:
-            data (dict): A dictionary representing the QobjHeader to create. It
-                will be in the same format as output by :func:`to_dict`.
-
-        Returns:
-            QobjDictFieldr: The QobjDictField from the input dictionary.
-        """
-
-        return cls(**data)
-
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            if self.__dict__ == other.__dict__:
-                return True
-        return False
-
-
-class QobjHeader(QobjDictField):
-    """A class used to represent a dictionary header in Qobj objects."""
-
-    pass
-
-
-class QobjExperimentHeader(QobjHeader):
-    """A class representing a header dictionary for a Qobj Experiment."""
-
-    pass

qiskit/qobj/converters/__init__.py

@@ -1,18 +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.
-
-"""
-Helper modules to convert qiskit frontend object to proper qobj model.
-"""
-
-from .pulse_instruction import InstructionToQobjConverter, QobjToInstructionConverter
-from .lo_config import LoConfigConverter

qiskit/qobj/converters/lo_config.py

@@ -1,177 +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.
-
-"""Helper class used to convert a user LO configuration into a list of frequencies."""
-
-from qiskit.pulse.channels import DriveChannel, MeasureChannel
-from qiskit.pulse.configuration import LoConfig
-from qiskit.exceptions import QiskitError
-from qiskit.utils import deprecate_func
-
-
-class LoConfigConverter:
-    """This class supports to convert LoConfig into ~`lo_freq` attribute of configs.
-    The format of LO frequency setup can be easily modified by replacing
-    ``get_qubit_los`` and ``get_meas_los`` to align with your backend.
-    """
-
-    @deprecate_func(
-        since="1.2",
-        removal_timeline="in the 2.0 release",
-        additional_msg="The `Qobj` class and related functionality are part of the deprecated "
-        "`BackendV1` workflow,  and no longer necessary for `BackendV2`. If a user "
-        "workflow requires `Qobj` it likely relies on deprecated functionality and "
-        "should be updated to use `BackendV2`.",
-    )
-    def __init__(
-        self,
-        qobj_model,
-        qubit_lo_freq=None,
-        meas_lo_freq=None,
-        qubit_lo_range=None,
-        meas_lo_range=None,
-        **run_config,
-    ):
-        """Create new converter.
-
-        Args:
-            qobj_model (Union[PulseQobjExperimentConfig, QasmQobjExperimentConfig): qobj model for
-                experiment config.
-            qubit_lo_freq (Optional[List[float]]): List of default qubit LO frequencies in Hz.
-            meas_lo_freq (Optional[List[float]]): List of default meas LO frequencies in Hz.
-            qubit_lo_range (Optional[List[List[float]]]): List of qubit LO ranges,
-                each of form ``[range_min, range_max]`` in Hz.
-            meas_lo_range (Optional[List[List[float]]]): List of measurement LO ranges,
-                each of form ``[range_min, range_max]`` in Hz.
-            n_qubits (int): Number of qubits in the system.
-            run_config (dict): experimental configuration.
-        """
-        self.qobj_model = qobj_model
-        self.qubit_lo_freq = qubit_lo_freq
-        self.meas_lo_freq = meas_lo_freq
-        self.run_config = run_config
-        self.n_qubits = self.run_config.get("n_qubits", None)
-
-        self.default_lo_config = LoConfig()
-
-        if qubit_lo_range:
-            for i, lo_range in enumerate(qubit_lo_range):
-                self.default_lo_config.add_lo_range(DriveChannel(i), lo_range)
-
-        if meas_lo_range:
-            for i, lo_range in enumerate(meas_lo_range):
-                self.default_lo_config.add_lo_range(MeasureChannel(i), lo_range)
-
-    def __call__(self, user_lo_config):
-        """Return experiment config w/ LO values property configured.
-
-        Args:
-            user_lo_config (LoConfig): A dictionary of LOs to format.
-
-        Returns:
-            Union[PulseQobjExperimentConfig, QasmQobjExperimentConfig]: Qobj experiment config.
-        """
-        lo_config = {}
-
-        q_los = self.get_qubit_los(user_lo_config)
-        if q_los:
-            lo_config["qubit_lo_freq"] = [freq / 1e9 for freq in q_los]
-
-        m_los = self.get_meas_los(user_lo_config)
-        if m_los:
-            lo_config["meas_lo_freq"] = [freq / 1e9 for freq in m_los]
-
-        return self.qobj_model(**lo_config)
-
-    def get_qubit_los(self, user_lo_config):
-        """Set experiment level qubit LO frequencies. Use default values from job level if
-        experiment level values not supplied. If experiment level and job level values not supplied,
-        raise an error. If configured LO frequency is the same as default, this method returns
-        ``None``.
-
-        Args:
-            user_lo_config (LoConfig): A dictionary of LOs to format.
-
-        Returns:
-            List[float]: A list of qubit LOs.
-
-        Raises:
-            QiskitError: When LO frequencies are missing and no default is set at job level.
-        """
-        _q_los = None
-
-        # try to use job level default values
-        if self.qubit_lo_freq:
-            _q_los = self.qubit_lo_freq.copy()
-        # otherwise initialize list with ``None`` entries
-        elif self.n_qubits:
-            _q_los = [None] * self.n_qubits
-
-        # fill experiment level LO's
-        if _q_los:
-            for channel, lo_freq in user_lo_config.qubit_los.items():
-                self.default_lo_config.check_lo(channel, lo_freq)
-                _q_los[channel.index] = lo_freq
-
-            if _q_los == self.qubit_lo_freq:
-                return None
-
-            # if ``None`` remains in LO's, indicates default not provided and user value is missing
-            # raise error
-            if None in _q_los:
-                raise QiskitError(
-                    "Invalid experiment level qubit LO's. Must either pass values "
-                    "for all drive channels or pass 'default_qubit_los'."
-                )
-
-        return _q_los
-
-    def get_meas_los(self, user_lo_config):
-        """Set experiment level meas LO frequencies. Use default values from job level if experiment
-        level values not supplied. If experiment level and job level values not supplied, raise an
-        error. If configured LO frequency is the same as default, this method returns ``None``.
-
-        Args:
-            user_lo_config (LoConfig): A dictionary of LOs to format.
-
-        Returns:
-            List[float]: A list of measurement LOs.
-
-        Raises:
-            QiskitError: When LO frequencies are missing and no default is set at job level.
-        """
-        _m_los = None
-        # try to use job level default values
-        if self.meas_lo_freq:
-            _m_los = self.meas_lo_freq.copy()
-        # otherwise initialize list with ``None`` entries
-        elif self.n_qubits:
-            _m_los = [None] * self.n_qubits
-
-        # fill experiment level LO's
-        if _m_los:
-            for channel, lo_freq in user_lo_config.meas_los.items():
-                self.default_lo_config.check_lo(channel, lo_freq)
-                _m_los[channel.index] = lo_freq
-
-            if _m_los == self.meas_lo_freq:
-                return None
-
-            # if ``None`` remains in LO's, indicates default not provided and user value is missing
-            # raise error
-            if None in _m_los:
-                raise QiskitError(
-                    "Invalid experiment level measurement LO's. Must either pass "
-                    "values for all measurement channels or pass 'default_meas_los'."
-                )
-
-        return _m_los