qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/providers/models/backendproperties.py

@@ -0,0 +1,517 @@
+# 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.
+
+"""Backend Properties classes."""
+
+import copy
+import datetime
+from typing import Any, Iterable, Tuple, Union, Dict
+import dateutil.parser
+
+from qiskit.providers.exceptions import BackendPropertyError
+from qiskit.utils import deprecate_func
+from qiskit.utils.units import apply_prefix
+
+PropertyT = Tuple[Any, datetime.datetime]
+
+
+class Nduv:
+    """Class representing name-date-unit-value
+
+    Attributes:
+        date: date.
+        name: name.
+        unit: unit.
+        value: value.
+    """
+
+    def __init__(self, date, name, unit, value):
+        """Initialize a new name-date-unit-value object
+
+        Args:
+            date (datetime.datetime): Date field
+            name (str): Name field
+            unit (str): Nduv unit
+            value (float): The value of the Nduv
+        """
+        self.date = date
+        self.name = name
+        self.unit = unit
+        self.value = value
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a new Nduv object from a dictionary.
+
+        Args:
+            data (dict): A dictionary representing the Nduv to create.
+                         It will be in the same format as output by
+                         :func:`to_dict`.
+
+        Returns:
+            Nduv: The Nduv from the input dictionary.
+        """
+        return cls(**data)
+
+    def to_dict(self):
+        """Return a dictionary format representation of the object.
+
+        Returns:
+            dict: The dictionary form of the Nduv.
+        """
+        out_dict = {
+            "date": self.date,
+            "name": self.name,
+            "unit": self.unit,
+            "value": self.value,
+        }
+        return out_dict
+
+    def __eq__(self, other):
+        if isinstance(other, Nduv):
+            if self.to_dict() == other.to_dict():
+                return True
+        return False
+
+    def __repr__(self):
+        return f"Nduv({repr(self.date)}, {self.name}, {self.unit}, {self.value})"
+
+
+class GateProperties:
+    """Class representing a gate's properties
+
+    Attributes:
+        qubits: qubits.
+        gate: gate.
+        parameters: parameters.
+    """
+
+    _data = {}
+
+    def __init__(self, qubits, gate, parameters, **kwargs):
+        """Initialize a new :class:`GateProperties` object
+
+        Args:
+            qubits (list): A list of integers representing qubits
+            gate (str): The gates name
+            parameters (list): List of :class:`Nduv` objects for the
+                name-date-unit-value for the gate
+            kwargs: Optional additional fields
+        """
+        self._data = {}
+        self.qubits = qubits
+        self.gate = gate
+        self.parameters = parameters
+        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
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a new Gate object from a dictionary.
+
+        Args:
+            data (dict): A dictionary representing the Gate to create.
+                         It will be in the same format as output by
+                         :func:`to_dict`.
+
+        Returns:
+            GateProperties: The Nduv from the input dictionary.
+        """
+        in_data = {}
+        for key, value in data.items():
+            if key == "parameters":
+                in_data[key] = list(map(Nduv.from_dict, value))
+            else:
+                in_data[key] = value
+        return cls(**in_data)
+
+    def to_dict(self):
+        """Return a dictionary format representation of the BackendStatus.
+
+        Returns:
+            dict: The dictionary form of the Gate.
+        """
+        out_dict = {}
+        out_dict["qubits"] = self.qubits
+        out_dict["gate"] = self.gate
+        out_dict["parameters"] = [x.to_dict() for x in self.parameters]
+        out_dict.update(self._data)
+        return out_dict
+
+    def __eq__(self, other):
+        if isinstance(other, GateProperties):
+            if self.to_dict() == other.to_dict():
+                return True
+        return False
+
+
+# Backwards compatibility.
+Gate = GateProperties
+
+
+class BackendProperties:
+    """Class representing backend properties
+
+    This holds backend properties measured by the provider. All properties
+    which are provided optionally. These properties may describe qubits, gates,
+    or other general properties of the backend.
+    """
+
+    _data = {}
+
+    @deprecate_func(
+        since="1.2",
+        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=3,
+    )
+    def __init__(
+        self, backend_name, backend_version, last_update_date, qubits, gates, general, **kwargs
+    ):
+        """Initialize a BackendProperties instance.
+
+        Args:
+            backend_name (str): Backend name.
+            backend_version (str): Backend version in the form X.Y.Z.
+            last_update_date (datetime.datetime or str): Last date/time that a property was
+                updated. If specified as a ``str``, it must be in ISO format.
+            qubits (list): System qubit parameters as a list of lists of
+                           :class:`Nduv` objects
+            gates (list): System gate parameters as a list of :class:`GateProperties`
+                          objects
+            general (list): General parameters as a list of :class:`Nduv`
+                            objects
+            kwargs: optional additional fields
+        """
+        self._data = {}
+        self.backend_name = backend_name
+        self.backend_version = backend_version
+        if isinstance(last_update_date, str):
+            last_update_date = dateutil.parser.isoparse(last_update_date)
+        self.last_update_date = last_update_date
+        self.general = general
+        self.qubits = qubits
+        self.gates = gates
+
+        self._qubits = {}
+        for qubit, props in enumerate(qubits):
+            formatted_props = {}
+            for prop in props:
+                value = self._apply_prefix(prop.value, prop.unit)
+                formatted_props[prop.name] = (value, prop.date)
+                self._qubits[qubit] = formatted_props
+
+        self._gates = {}
+        for gate in gates:
+            if gate.gate not in self._gates:
+                self._gates[gate.gate] = {}
+            formatted_props = {}
+            for param in gate.parameters:
+                value = self._apply_prefix(param.value, param.unit)
+                formatted_props[param.name] = (value, param.date)
+            self._gates[gate.gate][tuple(gate.qubits)] = formatted_props
+        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
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a new BackendProperties object from a dictionary.
+
+        Args:
+            data (dict): A dictionary representing the BackendProperties to create.  It will be in
+                the same format as output by :meth:`to_dict`.
+
+        Returns:
+            BackendProperties: The BackendProperties from the input dictionary.
+        """
+        in_data = copy.copy(data)
+        backend_name = in_data.pop("backend_name")
+        backend_version = in_data.pop("backend_version")
+        last_update_date = in_data.pop("last_update_date")
+        qubits = []
+        for qubit in in_data.pop("qubits"):
+            nduvs = []
+            for nduv in qubit:
+                nduvs.append(Nduv.from_dict(nduv))
+            qubits.append(nduvs)
+        gates = [GateProperties.from_dict(x) for x in in_data.pop("gates")]
+        general = [Nduv.from_dict(x) for x in in_data.pop("general")]
+
+        return cls(
+            backend_name, backend_version, last_update_date, qubits, gates, general, **in_data
+        )
+
+    def to_dict(self):
+        """Return a dictionary format representation of the BackendProperties.
+
+        Returns:
+            dict: The dictionary form of the BackendProperties.
+        """
+        out_dict = {
+            "backend_name": self.backend_name,
+            "backend_version": self.backend_version,
+            "last_update_date": self.last_update_date,
+        }
+        out_dict["qubits"] = []
+        for qubit in self.qubits:
+            qubit_props = []
+            for item in qubit:
+                qubit_props.append(item.to_dict())
+            out_dict["qubits"].append(qubit_props)
+        out_dict["gates"] = [x.to_dict() for x in self.gates]
+        out_dict["general"] = [x.to_dict() for x in self.general]
+        out_dict.update(self._data)
+        return out_dict
+
+    def __eq__(self, other):
+        if isinstance(other, BackendProperties):
+            if self.to_dict() == other.to_dict():
+                return True
+        return False
+
+    def gate_property(
+        self,
+        gate: str,
+        qubits: Union[int, Iterable[int]] = None,
+        name: str = None,
+    ) -> Union[
+        Dict[Tuple[int, ...], Dict[str, PropertyT]],
+        Dict[str, PropertyT],
+        PropertyT,
+    ]:
+        """
+        Return the property of the given gate.
+
+        Args:
+            gate: Name of the gate.
+            qubits: The qubit to find the property for.
+            name: Optionally used to specify which gate property to return.
+
+        Returns:
+            Gate property as a tuple of the value and the time it was measured.
+
+        Raises:
+            BackendPropertyError: If the property is not found or name is
+                                  specified but qubit is not.
+        """
+        try:
+            result = self._gates[gate]
+            if qubits is not None:
+                if isinstance(qubits, int):
+                    qubits = (qubits,)
+                result = result[tuple(qubits)]
+                if name:
+                    result = result[name]
+            elif name:
+                raise BackendPropertyError(f"Provide qubits to get {name} of {gate}")
+        except KeyError as ex:
+            raise BackendPropertyError(f"Could not find the desired property for {gate}") from ex
+        return result
+
+    def faulty_qubits(self):
+        """Return a list of faulty qubits."""
+        faulty = []
+        for qubit in self._qubits:
+            if not self.is_qubit_operational(qubit):
+                faulty.append(qubit)
+        return faulty
+
+    def faulty_gates(self):
+        """Return a list of faulty gates."""
+        faulty = []
+        for gate in self.gates:
+            if not self.is_gate_operational(gate.gate, gate.qubits):
+                faulty.append(gate)
+        return faulty
+
+    def is_gate_operational(self, gate: str, qubits: Union[int, Iterable[int]] = None) -> bool:
+        """
+        Return the operational status of the given gate.
+
+        Args:
+            gate: Name of the gate.
+            qubits: The qubit to find the operational status for.
+
+        Returns:
+            bool: Operational status of the given gate. True if the gate is operational,
+            False otherwise.
+        """
+        properties = self.gate_property(gate, qubits)
+        if "operational" in properties:
+            return bool(properties["operational"][0])
+        return True  # if property operational not existent, then True.
+
+    def gate_error(self, gate: str, qubits: Union[int, Iterable[int]]) -> float:
+        """
+        Return gate error estimates from backend properties.
+
+        Args:
+            gate: The gate for which to get the error.
+            qubits: The specific qubits for the gate.
+
+        Returns:
+            Gate error of the given gate and qubit(s).
+        """
+        return self.gate_property(gate, qubits, "gate_error")[0]  # Throw away datetime at index 1
+
+    def gate_length(self, gate: str, qubits: Union[int, Iterable[int]]) -> float:
+        """
+        Return the duration of the gate in units of seconds.
+
+        Args:
+            gate: The gate for which to get the duration.
+            qubits: The specific qubits for the gate.
+
+        Returns:
+            Gate length of the given gate and qubit(s).
+        """
+        return self.gate_property(gate, qubits, "gate_length")[0]  # Throw away datetime at index 1
+
+    def qubit_property(
+        self,
+        qubit: int,
+        name: str = None,
+    ) -> Union[
+        Dict[str, PropertyT],
+        PropertyT,
+    ]:
+        """
+        Return the property of the given qubit.
+
+        Args:
+            qubit: The property to look for.
+            name: Optionally used to specify within the hierarchy which property to return.
+
+        Returns:
+            Qubit property as a tuple of the value and the time it was measured.
+
+        Raises:
+            BackendPropertyError: If the property is not found.
+        """
+        try:
+            result = self._qubits[qubit]
+            if name is not None:
+                result = result[name]
+        except KeyError as ex:
+            formatted_name = "y '" + name + "'" if name else "ies"
+            raise BackendPropertyError(
+                f"Couldn't find the propert{formatted_name} for qubit {qubit}."
+            ) from ex
+        return result
+
+    def t1(self, qubit: int) -> float:  # pylint: disable=invalid-name
+        """
+        Return the T1 time of the given qubit.
+
+        Args:
+            qubit: Qubit for which to return the T1 time of.
+
+        Returns:
+            T1 time of the given qubit.
+        """
+        return self.qubit_property(qubit, "T1")[0]  # Throw away datetime at index 1
+
+    def t2(self, qubit: int) -> float:  # pylint: disable=invalid-name
+        """
+        Return the T2 time of the given qubit.
+
+        Args:
+            qubit: Qubit for which to return the T2 time of.
+
+        Returns:
+            T2 time of the given qubit.
+        """
+        return self.qubit_property(qubit, "T2")[0]  # Throw away datetime at index 1
+
+    def frequency(self, qubit: int) -> float:
+        """
+        Return the frequency of the given qubit.
+
+        Args:
+            qubit: Qubit for which to return frequency of.
+
+        Returns:
+            Frequency of the given qubit.
+        """
+        return self.qubit_property(qubit, "frequency")[0]  # Throw away datetime at index 1
+
+    def readout_error(self, qubit: int) -> float:
+        """
+        Return the readout error of the given qubit.
+
+        Args:
+            qubit: Qubit for which to return the readout error of.
+
+        Return:
+            Readout error of the given qubit.
+        """
+        return self.qubit_property(qubit, "readout_error")[0]  # Throw away datetime at index 1
+
+    def readout_length(self, qubit: int) -> float:
+        """
+        Return the readout length [sec] of the given qubit.
+
+        Args:
+            qubit: Qubit for which to return the readout length of.
+
+        Return:
+            Readout length of the given qubit.
+        """
+        return self.qubit_property(qubit, "readout_length")[0]  # Throw away datetime at index 1
+
+    def is_qubit_operational(self, qubit: int) -> bool:
+        """
+        Return the operational status of the given qubit.
+
+        Args:
+            qubit: Qubit for which to return operational status of.
+
+        Returns:
+            Operational status of the given qubit.
+        """
+        properties = self.qubit_property(qubit)
+        if "operational" in properties:
+            return bool(properties["operational"][0])
+        return True  # if property operational not existent, then True.
+
+    def _apply_prefix(self, value: float, unit: str) -> float:
+        """
+        Given a SI unit prefix and value, apply the prefix to convert to
+        standard SI unit.
+
+        Args:
+            value: The number to apply prefix to.
+            unit: String prefix.
+
+        Returns:
+            Converted value.
+
+        Raises:
+            BackendPropertyError: If the units aren't recognized.
+        """
+        try:
+            return apply_prefix(value, unit)
+        except Exception as ex:
+            raise BackendPropertyError(f"Could not understand units: {unit}") from ex

qiskit/providers/models/backendstatus.py

@@ -0,0 +1,94 @@
+# 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.
+
+"""Class for backend status."""
+
+import html
+from qiskit.exceptions import QiskitError
+
+
+class BackendStatus:
+    """Class representing Backend Status."""
+
+    def __init__(
+        self,
+        backend_name: str,
+        backend_version: str,
+        operational: bool,
+        pending_jobs: int,
+        status_msg: str,
+    ):
+        """Initialize a BackendStatus object
+
+        Args:
+            backend_name: The backend's name
+            backend_version: The backend's version of the form X.Y.Z
+            operational: True if the backend is operational
+            pending_jobs: The number of pending jobs on the backend
+            status_msg: The status msg for the backend
+
+        Raises:
+            QiskitError: If the backend version is in an invalid format
+        """
+        self.backend_name = backend_name
+        self.backend_version = backend_version
+        self.operational = operational
+        if pending_jobs < 0:
+            raise QiskitError("Pending jobs must be >=0")
+        self.pending_jobs = pending_jobs
+        self.status_msg = status_msg
+
+    @classmethod
+    def from_dict(cls, data):
+        """Create a new BackendStatus object from a dictionary.
+
+        Args:
+            data (dict): A dictionary representing the BaseBakend to create.
+                         It will be in the same format as output by
+                         :func:`to_dict`.
+
+        Returns:
+            BackendStatus: The BackendStatus from the input dictionary.
+        """
+        return cls(**data)
+
+    def to_dict(self):
+        """Return a dictionary format representation of the BackendStatus.
+
+        Returns:
+            dict: The dictionary form of the QobjHeader.
+        """
+        return self.__dict__
+
+    def __eq__(self, other):
+        if isinstance(other, BackendStatus):
+            if self.__dict__ == other.__dict__:
+                return True
+        return False
+
+    def _repr_html_(self) -> str:
+        """Return html representation of the object
+
+        Returns:
+            Representation used in Jupyter notebook and other IDE's that call the method
+
+        """
+        rpr = self.__repr__()
+        html_code = (
+            f"<pre>{html.escape(rpr)}</pre>"
+            f"<b>name</b>: {self.backend_name}<br/>"
+            f"<b>version</b>: {self.backend_version},"
+            f" <b>pending jobs</b>: {self.pending_jobs}<br/>"
+            f"<b>status</b>: {self.status_msg}<br/>"
+        )
+
+        return html_code

qiskit/providers/models/jobstatus.py

@@ -0,0 +1,66 @@
+# 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."""
+
+
+class JobStatus:
+    """Model for JobStatus.
+
+    Attributes:
+        job_id (str): backend job_id.
+        status (str): status of the job.
+        status_msg (str): status message.
+    """
+
+    _data = {}
+
+    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