qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/providers/fake_provider/utils/__init__.py

@@ -0,0 +1,15 @@
+# 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.
+
+"""
+Utils for test backends.
+"""

qiskit/providers/fake_provider/utils/backend_converter.py

@@ -0,0 +1,150 @@
+# 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.
+
+"""
+Utilities for constructing Target object from configuration, properties and
+pulse defaults json files
+"""
+
+from qiskit.transpiler.target import Target, InstructionProperties
+from qiskit.providers.backend import QubitProperties
+from qiskit.utils.units import apply_prefix
+from qiskit.circuit.library.standard_gates import IGate, SXGate, XGate, CXGate, RZGate
+from qiskit.circuit.parameter import Parameter
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.delay import Delay
+from qiskit.circuit.measure import Measure
+from qiskit.circuit.reset import Reset
+from qiskit.providers.models.pulsedefaults import PulseDefaults
+
+
+def convert_to_target(conf_dict: dict, props_dict: dict = None, defs_dict: dict = None) -> Target:
+    """Uses configuration, properties and pulse defaults dicts
+    to construct and return Target class.
+    """
+    name_mapping = {
+        "id": IGate(),
+        "sx": SXGate(),
+        "x": XGate(),
+        "cx": CXGate(),
+        "rz": RZGate(Parameter("λ")),
+        "reset": Reset(),
+    }
+    custom_gates = {}
+    qubit_props = None
+    if props_dict:
+        qubit_props = qubit_props_from_props(props_dict)
+    target = Target(qubit_properties=qubit_props, concurrent_measurements=conf_dict.get("meas_map"))
+    # Parse from properties if it exsits
+    if props_dict is not None:
+        # Parse instructions
+        gates = {}
+        for gate in props_dict["gates"]:
+            name = gate["gate"]
+            if name in name_mapping:
+                if name not in gates:
+                    gates[name] = {}
+            elif name not in custom_gates:
+                custom_gate = Gate(name, len(gate["qubits"]), [])
+                custom_gates[name] = custom_gate
+                gates[name] = {}
+
+            qubits = tuple(gate["qubits"])
+            gate_props = {}
+            for param in gate["parameters"]:
+                if param["name"] == "gate_error":
+                    gate_props["error"] = param["value"]
+                if param["name"] == "gate_length":
+                    gate_props["duration"] = apply_prefix(param["value"], param["unit"])
+            gates[name][qubits] = InstructionProperties(**gate_props)
+        for gate, props in gates.items():
+            if gate in name_mapping:
+                inst = name_mapping.get(gate)
+            else:
+                inst = custom_gates[gate]
+            target.add_instruction(inst, props)
+        # Create measurement instructions:
+        measure_props = {}
+        count = 0
+        for qubit in props_dict["qubits"]:
+            qubit_prop = {}
+            for prop in qubit:
+                if prop["name"] == "readout_length":
+                    qubit_prop["duration"] = apply_prefix(prop["value"], prop["unit"])
+                if prop["name"] == "readout_error":
+                    qubit_prop["error"] = prop["value"]
+            measure_props[(count,)] = InstructionProperties(**qubit_prop)
+            count += 1
+        target.add_instruction(Measure(), measure_props)
+    # Parse from configuration because properties doesn't exist
+    else:
+        for gate in conf_dict["gates"]:
+            name = gate["name"]
+            gate_props = {tuple(x): None for x in gate["coupling_map"]}
+            if name in name_mapping:
+                target.add_instruction(name_mapping[name], gate_props)
+            else:
+                custom_gate = Gate(name, len(gate["coupling_map"][0]), [])
+                target.add_instruction(custom_gate, gate_props)
+        measure_props = {(n,): None for n in range(conf_dict["n_qubits"])}
+        target.add_instruction(Measure(), measure_props)
+    # parse global configuration properties
+    dt = conf_dict.get("dt")
+    if dt:
+        target.dt = dt * 1e-9
+    if "timing_constraints" in conf_dict:
+        target.granularity = conf_dict["timing_constraints"].get("granularity")
+        target.min_length = conf_dict["timing_constraints"].get("min_length")
+        target.pulse_alignment = conf_dict["timing_constraints"].get("pulse_alignment")
+        target.acquire_alignment = conf_dict["timing_constraints"].get("acquire_alignment")
+    # If pulse defaults exists use that as the source of truth
+    if defs_dict is not None:
+        # TODO remove the usage of PulseDefaults as it will be deprecated in the future
+        pulse_defs = PulseDefaults.from_dict(defs_dict)
+        inst_map = pulse_defs.instruction_schedule_map
+        for inst in inst_map.instructions:
+            for qarg in inst_map.qubits_with_instruction(inst):
+                try:
+                    qargs = tuple(qarg)
+                except TypeError:
+                    qargs = (qarg,)
+                # Do NOT call .get method. This parses Qpbj immediately.
+                # This operation is computationally expensive and should be bypassed.
+                calibration_entry = inst_map._get_calibration_entry(inst, qargs)
+                if inst in target:
+                    if inst == "measure":
+                        for qubit in qargs:
+                            target[inst][(qubit,)].calibration = calibration_entry
+                    elif qargs in target[inst]:
+                        target[inst][qargs].calibration = calibration_entry
+    target.add_instruction(
+        Delay(Parameter("t")), {(bit,): None for bit in range(target.num_qubits)}
+    )
+    return target
+
+
+def qubit_props_from_props(properties: dict) -> list:
+    """Returns a dictionary of `qiskit.providers.backend.QubitProperties` using
+    a backend properties dictionary created by loading props.json payload.
+    """
+    qubit_props = []
+    for qubit in properties["qubits"]:
+        qubit_properties = {}
+        for prop_dict in qubit:
+            if prop_dict["name"] == "T1":
+                qubit_properties["t1"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
+            elif prop_dict["name"] == "T2":
+                qubit_properties["t2"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
+            elif prop_dict["name"] == "frequency":
+                qubit_properties["frequency"] = apply_prefix(prop_dict["value"], prop_dict["unit"])
+        qubit_props.append(QubitProperties(**qubit_properties))
+    return qubit_props

qiskit/providers/fake_provider/utils/json_decoder.py

@@ -0,0 +1,109 @@
+# 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.
+
+"""
+Utils to decode fake backend configurations from json
+"""
+
+from typing import Dict, Union, List
+
+import dateutil.parser
+
+
+def decode_pulse_defaults(defaults: Dict) -> None:
+    """Decode pulse defaults data.
+
+    Args:
+        defaults: A ``PulseDefaults`` in dictionary format.
+    """
+    for item in defaults["pulse_library"]:
+        _decode_pulse_library_item(item)
+
+    for cmd in defaults["cmd_def"]:
+        if "sequence" in cmd:
+            for instr in cmd["sequence"]:
+                _decode_pulse_qobj_instr(instr)
+
+
+def decode_backend_properties(properties: Dict) -> None:
+    """Decode backend properties.
+
+    Args:
+        properties: A ``BackendProperties`` in dictionary format.
+    """
+    properties["last_update_date"] = dateutil.parser.isoparse(properties["last_update_date"])
+    for qubit in properties["qubits"]:
+        for nduv in qubit:
+            nduv["date"] = dateutil.parser.isoparse(nduv["date"])
+    for gate in properties["gates"]:
+        for param in gate["parameters"]:
+            param["date"] = dateutil.parser.isoparse(param["date"])
+    for gen in properties["general"]:
+        gen["date"] = dateutil.parser.isoparse(gen["date"])
+
+
+def decode_backend_configuration(config: Dict) -> None:
+    """Decode backend configuration.
+
+    Args:
+        config: A ``QasmBackendConfiguration`` or ``PulseBackendConfiguration``
+            in dictionary format.
+    """
+    config["online_date"] = dateutil.parser.isoparse(config["online_date"])
+
+    if "u_channel_lo" in config:
+        for u_channle_list in config["u_channel_lo"]:
+            for u_channle_lo in u_channle_list:
+                u_channle_lo["scale"] = _to_complex(u_channle_lo["scale"])
+
+
+def _to_complex(value: Union[List[float], complex]) -> complex:
+    """Convert the input value to type ``complex``.
+
+    Args:
+        value: Value to be converted.
+
+    Returns:
+        Input value in ``complex``.
+
+    Raises:
+        TypeError: If the input value is not in the expected format.
+    """
+    if isinstance(value, list) and len(value) == 2:
+        return complex(value[0], value[1])
+    elif isinstance(value, complex):
+        return value
+
+    raise TypeError(f"{value} is not in a valid complex number format.")
+
+
+def _decode_pulse_library_item(pulse_library_item: Dict) -> None:
+    """Decode a pulse library item.
+
+    Args:
+        pulse_library_item: A ``PulseLibraryItem`` in dictionary format.
+    """
+    pulse_library_item["samples"] = [
+        _to_complex(sample) for sample in pulse_library_item["samples"]
+    ]
+
+
+def _decode_pulse_qobj_instr(pulse_qobj_instr: Dict) -> None:
+    """Decode a pulse Qobj instruction.
+
+    Args:
+        pulse_qobj_instr: A ``PulseQobjInstruction`` in dictionary format.
+    """
+    if "val" in pulse_qobj_instr:
+        pulse_qobj_instr["val"] = _to_complex(pulse_qobj_instr["val"])
+    if "parameters" in pulse_qobj_instr and "amp" in pulse_qobj_instr["parameters"]:
+        pulse_qobj_instr["parameters"]["amp"] = _to_complex(pulse_qobj_instr["parameters"]["amp"])

qiskit/providers/job.py

@@ -0,0 +1,147 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""Job abstract interface."""
+
+from __future__ import annotations
+
+import time
+from abc import ABC, abstractmethod
+from typing import Callable, Optional, TYPE_CHECKING
+
+from qiskit.exceptions import QiskitError
+from qiskit.providers.backend import Backend
+from qiskit.providers.exceptions import JobTimeoutError
+from qiskit.providers.jobstatus import JOB_FINAL_STATES, JobStatus
+
+if TYPE_CHECKING:
+    from qiskit.result import Result
+
+
+class Job:
+    """Base common type for all versioned Job 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
+
+
+class JobV1(Job, ABC):
+    """Class to handle jobs
+
+    This first version of the Backend abstract class is written to be mostly
+    backwards compatible with the legacy providers interface. This was done to ease
+    the transition for users and provider maintainers to the new versioned providers. Expect,
+    future versions of this abstract class to change the data model and
+    interface.
+    """
+
+    version = 1
+    _async = True
+
+    def __init__(self, backend: Optional[Backend], job_id: str, **kwargs) -> None:
+        """Initializes the asynchronous job.
+
+        Args:
+            backend: the backend used to run the job.
+            job_id: a unique id in the context of the backend used to run
+                the job.
+            kwargs: Any key value metadata to associate with this job.
+        """
+        self._job_id = job_id
+        self._backend = backend
+        self.metadata = kwargs
+
+    def job_id(self) -> str:
+        """Return a unique id identifying the job."""
+        return self._job_id
+
+    def backend(self) -> Backend:
+        """Return the backend where this job was executed."""
+        if self._backend is None:
+            raise QiskitError("The job does not have any backend.")
+        return self._backend
+
+    def done(self) -> bool:
+        """Return whether the job has successfully run."""
+        return self.status() == JobStatus.DONE
+
+    def running(self) -> bool:
+        """Return whether the job is actively running."""
+        return self.status() == JobStatus.RUNNING
+
+    def cancelled(self) -> bool:
+        """Return whether the job has been cancelled."""
+        return self.status() == JobStatus.CANCELLED
+
+    def in_final_state(self) -> bool:
+        """Return whether the job is in a final job state such as ``DONE`` or ``ERROR``."""
+        return self.status() in JOB_FINAL_STATES
+
+    def wait_for_final_state(
+        self, timeout: Optional[float] = None, wait: float = 5, callback: Optional[Callable] = None
+    ) -> None:
+        """Poll the job status until it progresses to a final state such as ``DONE`` or ``ERROR``.
+
+        Args:
+            timeout: Seconds to wait for the job. If ``None``, wait indefinitely.
+            wait: Seconds between queries.
+            callback: Callback function invoked after each query.
+                The following positional arguments are provided to the callback function:
+
+                * job_id: Job ID
+                * job_status: Status of the job from the last query
+                * job: This BaseJob instance
+
+                Note: different subclass might provide different arguments to
+                the callback function.
+
+        Raises:
+            JobTimeoutError: If the job does not reach a final state before the
+                specified timeout.
+        """
+        if not self._async:
+            return
+        start_time = time.time()
+        status = self.status()
+        while status not in JOB_FINAL_STATES:
+            elapsed_time = time.time() - start_time
+            if timeout is not None and elapsed_time >= timeout:
+                raise JobTimeoutError(f"Timeout while waiting for job {self.job_id()}.")
+            if callback:
+                callback(self.job_id(), status, self)
+            time.sleep(wait)
+            status = self.status()
+        return
+
+    @abstractmethod
+    def submit(self):
+        """Submit the job to the backend for execution."""
+        pass
+
+    @abstractmethod
+    def result(self) -> Result:
+        """Return the results of the job."""
+        pass
+
+    def cancel(self):
+        """Attempt to cancel the job."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def status(self) -> JobStatus:
+        """Return the status of the job, among the values of ``JobStatus``."""
+        pass

qiskit/providers/jobstatus.py

@@ -0,0 +1,30 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""This module defines an enumerated type for the state of backend jobs"""
+
+import enum
+
+
+class JobStatus(enum.Enum):
+    """Class for job status enumerated type."""
+
+    INITIALIZING = "job is being initialized"
+    QUEUED = "job is queued"
+    VALIDATING = "job is being validated"
+    RUNNING = "job is actively running"
+    CANCELLED = "job has been cancelled"
+    DONE = "job has successfully run"
+    ERROR = "job incurred error"
+
+
+JOB_FINAL_STATES = (JobStatus.DONE, JobStatus.CANCELLED, JobStatus.ERROR)

qiskit/providers/models/__init__.py

@@ -0,0 +1,89 @@
+# 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.
+
+"""
+================================================
+Backend Objects (:mod:`qiskit.providers.models`)
+================================================
+
+.. currentmodule:: qiskit.providers.models
+
+Qiskit schema-conformant objects used by the backends and providers.
+
+Classes
+=======
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   BackendConfiguration
+   BackendProperties
+   BackendStatus
+   QasmBackendConfiguration
+   PulseBackendConfiguration
+   UchannelLO
+   GateConfig
+   PulseDefaults
+   Command
+   JobStatus
+   GateProperties
+   Nduv
+"""
+# pylint: disable=undefined-all-variable
+__all__ = [
+    "BackendConfiguration",
+    "PulseBackendConfiguration",
+    "QasmBackendConfiguration",
+    "UchannelLO",
+    "GateConfig",
+    "BackendProperties",
+    "GateProperties",
+    "Nduv",
+    "BackendStatus",
+    "JobStatus",
+    "PulseDefaults",
+    "Command",
+]
+
+import importlib
+import warnings
+
+
+_NAME_MAP = {
+    # public object name mapped to containing module
+    "BackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "PulseBackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "QasmBackendConfiguration": "qiskit.providers.models.backendconfiguration",
+    "UchannelLO": "qiskit.providers.models.backendconfiguration",
+    "GateConfig": "qiskit.providers.models.backendconfiguration",
+    "BackendProperties": "qiskit.providers.models.backendproperties",
+    "GateProperties": "qiskit.providers.models.backendproperties",
+    "Nduv": "qiskit.providers.models.backendproperties",
+    "BackendStatus": "qiskit.providers.models.backendstatus",
+    "JobStatus": "qiskit.providers.models.jobstatus",
+    "PulseDefaults": "qiskit.providers.models.pulsedefaults",
+    "Command": "qiskit.providers.models.pulsedefaults",
+}
+
+
+def __getattr__(name):
+    if (module_name := _NAME_MAP.get(name)) is not None:
+        warnings.warn(
+            "qiskit.providers.models is deprecated since Qiskit 1.2 and will be "
+            "removed in Qiskit 2.0. With the removal of Qobj, there is no need for these "
+            "schema-conformant objects. If you still need to use them, it could be because "
+            "you are using a BackendV1, which is also deprecated in favor of BackendV2.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return getattr(importlib.import_module(module_name), name)
+    raise AttributeError(f"module 'qiskit.providers.models' has no attribute '{name}'")