qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/tools/monitor/job_monitor.py

@@ -0,0 +1,107 @@
+# 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.
+
+
+"""A module for monitoring various qiskit functionality"""
+
+import sys
+import time
+
+
+def _text_checker(
+    job, interval, _interval_set=False, quiet=False, output=sys.stdout, line_discipline="\r"
+):
+    """A text-based job status checker
+
+    Args:
+        job (BaseJob): The job to check.
+        interval (int): The interval at which to check.
+        _interval_set (bool): Was interval time set by user?
+        quiet (bool): If True, do not print status messages.
+        output (file): The file like object to write status messages to.
+        By default this is sys.stdout.
+        line_discipline (string): character emitted at start of a line of job monitor output,
+        This defaults to \\r.
+
+    """
+    status = job.status()
+    msg = status.value
+    prev_msg = msg
+    msg_len = len(msg)
+
+    if not quiet:
+        print("{}{}: {}".format(line_discipline, "Job Status", msg), end="", file=output)
+    while status.name not in ["DONE", "CANCELLED", "ERROR"]:
+        time.sleep(interval)
+        status = job.status()
+        msg = status.value
+
+        if status.name == "QUEUED":
+            msg += " (%s)" % job.queue_position()
+            if job.queue_position() is None:
+                interval = 2
+            elif not _interval_set:
+                interval = max(job.queue_position(), 2)
+        else:
+            if not _interval_set:
+                interval = 2
+
+        # Adjust length of message so there are no artifacts
+        if len(msg) < msg_len:
+            msg += " " * (msg_len - len(msg))
+        elif len(msg) > msg_len:
+            msg_len = len(msg)
+
+        if msg != prev_msg and not quiet:
+            print("{}{}: {}".format(line_discipline, "Job Status", msg), end="", file=output)
+            prev_msg = msg
+    if not quiet:
+        print("", file=output)
+
+
+def job_monitor(job, interval=None, quiet=False, output=sys.stdout, line_discipline="\r"):
+    """Monitor the status of a IBMQJob instance.
+
+    Args:
+        job (BaseJob): Job to monitor.
+        interval (int): Time interval between status queries.
+        quiet (bool): If True, do not print status messages.
+        output (file): The file like object to write status messages to.
+        By default this is sys.stdout.
+        line_discipline (string): character emitted at start of a line of job monitor output,
+        This defaults to \\r.
+
+    Examples:
+
+        .. code-block:: python
+
+            from qiskit import BasicAer, transpile
+            from qiskit.circuit import QuantumCircuit
+            from qiskit.tools.monitor import job_monitor
+            sim_backend = BasicAer.get_backend("qasm_simulator")
+            qc = QuantumCircuit(2, 2)
+            qc.h(0)
+            qc.cx(0, 1)
+            qc.measure_all()
+            tqc = transpile(qc, sim_backend)
+            job_sim = sim_backend.run(tqc)
+            job_monitor(job_sim)
+    """
+    if interval is None:
+        _interval_set = False
+        interval = 5
+    else:
+        _interval_set = True
+
+    _text_checker(
+        job, interval, _interval_set, quiet=quiet, output=output, line_discipline=line_discipline
+    )

qiskit/tools/monitor/overview.py

@@ -0,0 +1,247 @@
+# 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.
+
+"""A module for viewing the details of all available devices.
+"""
+
+import math
+from qiskit.exceptions import QiskitError, MissingOptionalLibraryError
+
+
+def get_unique_backends():
+    """Gets the unique backends that are available.
+
+    Returns:
+        list: Unique available backends.
+
+    Raises:
+        QiskitError: No backends available.
+        MissingOptionalLibraryError: If qiskit-ibmq-provider is not installed
+    """
+    try:
+        from qiskit.providers.ibmq import IBMQ
+    except ImportError as ex:
+        raise MissingOptionalLibraryError(
+            libname="qiskit-ibmq-provider",
+            name="get_unique_backends",
+            pip_install="pip install qiskit-ibmq-provider",
+        ) from ex
+    backends = []
+    for provider in IBMQ.providers():
+        for backend in provider.backends():
+            backends.append(backend)
+    unique_hardware_backends = []
+    unique_names = []
+    for back in backends:
+        if back.name() not in unique_names and not back.configuration().simulator:
+            unique_hardware_backends.append(back)
+            unique_names.append(back.name())
+    if not unique_hardware_backends:
+        raise QiskitError("No backends available.")
+    return unique_hardware_backends
+
+
+def backend_monitor(backend):
+    """Monitor a single IBMQ backend.
+
+    Args:
+        backend (IBMQBackend): Backend to monitor.
+    Raises:
+        QiskitError: Input is not a IBMQ backend.
+        MissingOptionalLibraryError: If qiskit-ibmq-provider is not installed
+
+    Examples:
+    .. code-block:: python
+
+       from qiskit.providers.ibmq import IBMQ
+       from qiskit.tools.monitor import backend_monitor
+       provider = IBMQ.get_provider(hub='ibm-q')
+       backend_monitor(provider.backends.ibmq_lima)
+    """
+    try:
+        from qiskit.providers.ibmq import IBMQBackend
+    except ImportError as ex:
+        raise MissingOptionalLibraryError(
+            libname="qiskit-ibmq-provider",
+            name="backend_monitor",
+            pip_install="pip install qiskit-ibmq-provider",
+        ) from ex
+
+    if not isinstance(backend, IBMQBackend):
+        raise QiskitError("Input variable is not of type IBMQBackend.")
+    config = backend.configuration().to_dict()
+    status = backend.status().to_dict()
+    config_dict = {**status, **config}
+
+    print(backend.name())
+    print("=" * len(backend.name()))
+    print("Configuration")
+    print("-" * 13)
+    offset = "    "
+
+    upper_list = [
+        "n_qubits",
+        "operational",
+        "status_msg",
+        "pending_jobs",
+        "backend_version",
+        "basis_gates",
+        "local",
+        "simulator",
+    ]
+
+    lower_list = list(set(config_dict.keys()).difference(upper_list))
+    # Remove gates because they are in a different tab
+    lower_list.remove("gates")
+    for item in upper_list + lower_list:
+        print(offset + item + ":", config_dict[item])
+
+    # Stop here if simulator
+    if config["simulator"]:
+        return
+
+    print()
+    props = backend.properties()
+    qubit_header = None
+    sep = " / "
+
+    for index, qubit_data in enumerate(props.qubits):
+        name = "Q%s" % index
+        gate_data = [gate for gate in props.gates if gate.qubits == [index]]
+
+        cal_data = dict.fromkeys(["T1", "T2", "frequency", "readout_error"], "Unknown")
+        for nduv in qubit_data:
+            if nduv.name in cal_data:
+                cal_data[nduv.name] = format(nduv.value, ".5f") + " " + nduv.unit
+
+        gate_names = []
+        gate_error = []
+        for gd in gate_data:
+            if gd.gate in ["id"]:
+                continue
+            try:
+                gate_error.append(format(props.gate_error(gd.gate, index), ".5f"))
+                gate_names.append(gd.gate.upper() + " err")
+            except QiskitError:
+                pass
+
+        if not qubit_header:
+            qubit_header = (
+                "Qubits [Name / Freq / T1 / T2" + sep.join([""] + gate_names) + " / Readout err]"
+            )
+            print(qubit_header)
+            print("-" * len(qubit_header))
+
+        qstr = sep.join(
+            [name, cal_data["frequency"], cal_data["T1"], cal_data["T2"]]
+            + gate_error
+            + [cal_data["readout_error"]]
+        )
+
+        print(offset + qstr)
+
+    print()
+    multi_qubit_gates = [g for g in props.gates if len(g.qubits) > 1]
+    multi_header = "Multi-Qubit Gates [Name / Type / Gate Error]"
+    print(multi_header)
+    print("-" * len(multi_header))
+
+    for gate in multi_qubit_gates:
+        qubits = gate.qubits
+        ttype = gate.gate
+        error = "Unknown"
+        try:
+            error = format(props.gate_error(gate.gate, qubits), ".5f")
+        except QiskitError:
+            pass
+        mstr = sep.join([f"{ttype}{qubits[0]}_{qubits[1]}", ttype, str(error)])
+        print(offset + mstr)
+
+
+def backend_overview():
+    """Gives overview information on all the IBMQ
+    backends that are available.
+
+    Examples:
+
+        .. code-block:: python
+
+            from qiskit.providers.ibmq import IBMQ
+            from qiskit.tools.monitor import backend_overview
+            provider = IBMQ.get_provider(hub='ibm-q')
+            backend_overview()
+    """
+    unique_hardware_backends = get_unique_backends()
+    _backends = []
+    # Sort backends by operational or not
+    for idx, back in enumerate(unique_hardware_backends):
+        if back.status().operational:
+            _backends = [back] + _backends
+        else:
+            _backends = _backends + [back]
+
+    stati = [back.status() for back in _backends]
+    idx = list(range(len(_backends)))
+    pending = [s.pending_jobs for s in stati]
+    _, least_idx = zip(*sorted(zip(pending, idx)))
+
+    # Make sure least pending is operational
+    for ind in least_idx:
+        if stati[ind].operational:
+            least_pending_idx = ind
+            break
+
+    num_rows = math.ceil(len(_backends) / 3)
+
+    count = 0
+    num_backends = len(_backends)
+    for _ in range(num_rows):
+        max_len = 0
+        str_list = [""] * 8
+        for idx in range(3):
+            offset = " " * 10 if idx else ""
+            config = _backends[count].configuration().to_dict()
+            props = _backends[count].properties().to_dict()
+            num_qubits = config["n_qubits"]
+            str_list[0] += " " * (max_len - len(str_list[0])) + offset
+            str_list[0] += _backends[count].name()
+
+            str_list[1] += " " * (max_len - len(str_list[1])) + offset
+            str_list[1] += "-" * len(_backends[count].name())
+
+            str_list[2] += " " * (max_len - len(str_list[2])) + offset
+            str_list[2] += "Num. Qubits:  %s" % config["n_qubits"]
+
+            str_list[3] += " " * (max_len - len(str_list[3])) + offset
+            str_list[3] += "Pending Jobs: %s" % stati[count].pending_jobs
+
+            str_list[4] += " " * (max_len - len(str_list[4])) + offset
+            str_list[4] += "Least busy:   %s" % (count == least_pending_idx)
+
+            str_list[5] += " " * (max_len - len(str_list[5])) + offset
+            str_list[5] += "Operational:  %s" % stati[count].operational
+
+            str_list[6] += " " * (max_len - len(str_list[6])) + offset
+            str_list[6] += "Avg. T1:      %s" % round(
+                sum(q[0]["value"] for q in props["qubits"]) / num_qubits, 1
+            )
+            str_list[7] += " " * (max_len - len(str_list[7])) + offset
+            str_list[7] += "Avg. T2:      %s" % round(
+                sum(q[1]["value"] for q in props["qubits"]) / num_qubits, 1
+            )
+            count += 1
+            if count == num_backends:
+                break
+            max_len = max(len(s) for s in str_list)
+
+        print("\n".join(str_list))
+        print("\n" * 2)

qiskit/tools/parallel.py

@@ -0,0 +1,198 @@
+# 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.
+
+# This file is part of QuTiP: Quantum Toolbox in Python.
+#
+#    Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson.
+#    All rights reserved.
+#
+#    Redistribution and use in source and binary forms, with or without
+#    modification, are permitted provided that the following conditions are
+#    met:
+#
+#    1. Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+#
+#    2. Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#    3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names
+#       of its contributors may be used to endorse or promote products derived
+#       from this software without specific prior written permission.
+#
+#    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+#    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+###############################################################################
+
+"""
+Routines for running Python functions in parallel using process pools
+from the multiprocessing library.
+"""
+
+import os
+from concurrent.futures import ProcessPoolExecutor
+import sys
+
+from qiskit.exceptions import QiskitError
+from qiskit.utils.multiprocessing import local_hardware_info
+from qiskit.tools.events.pubsub import Publisher
+from qiskit import user_config
+
+
+def get_platform_parallel_default():
+    """
+    Returns the default parallelism flag value for the current platform.
+
+    Returns:
+        parallel_default: The default parallelism flag value for the
+        current platform.
+
+    """
+    # Default False on Windows
+    if sys.platform == "win32":
+        parallel_default = False
+    # On macOS default false on Python >=3.8
+    elif sys.platform == "darwin":
+        parallel_default = False
+    # On linux (and other OSes) default to True
+    else:
+        parallel_default = True
+
+    return parallel_default
+
+
+CONFIG = user_config.get_config()
+
+if os.getenv("QISKIT_PARALLEL", None) is not None:
+    PARALLEL_DEFAULT = os.getenv("QISKIT_PARALLEL", None).lower() == "true"
+else:
+    PARALLEL_DEFAULT = get_platform_parallel_default()
+
+# Set parallel flag
+if os.getenv("QISKIT_IN_PARALLEL") is None:
+    os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
+
+if os.getenv("QISKIT_NUM_PROCS") is not None:
+    CPU_COUNT = int(os.getenv("QISKIT_NUM_PROCS"))
+else:
+    CPU_COUNT = CONFIG.get("num_process", local_hardware_info()["cpus"])
+
+
+def _task_wrapper(param):
+    (task, value, task_args, task_kwargs) = param
+    return task(value, *task_args, **task_kwargs)
+
+
+def parallel_map(  # pylint: disable=dangerous-default-value
+    task, values, task_args=(), task_kwargs={}, num_processes=CPU_COUNT
+):
+    """
+    Parallel execution of a mapping of `values` to the function `task`. This
+    is functionally equivalent to::
+
+        result = [task(value, *task_args, **task_kwargs) for value in values]
+
+    On Windows this function defaults to a serial implementation to avoid the
+    overhead from spawning processes in Windows.
+
+    Args:
+        task (func): Function that is to be called for each value in ``values``.
+        values (array_like): List or array of values for which the ``task``
+                            function is to be evaluated.
+        task_args (list): Optional additional arguments to the ``task`` function.
+        task_kwargs (dict): Optional additional keyword argument to the ``task`` function.
+        num_processes (int): Number of processes to spawn.
+
+    Returns:
+        result: The result list contains the value of
+                ``task(value, *task_args, **task_kwargs)`` for
+                    each value in ``values``.
+
+    Raises:
+        QiskitError: If user interrupts via keyboard.
+
+    Events:
+        terra.parallel.start: The collection of parallel tasks are about to start.
+        terra.parallel.update: One of the parallel task has finished.
+        terra.parallel.finish: All the parallel tasks have finished.
+
+    Examples:
+
+        .. code-block:: python
+
+            import time
+            from qiskit.tools.parallel import parallel_map
+            def func(_):
+                    time.sleep(0.1)
+                    return 0
+            parallel_map(func, list(range(10)));
+    """
+    if len(values) == 0:
+        return []
+    if len(values) == 1:
+        return [task(values[0], *task_args, **task_kwargs)]
+
+    Publisher().publish("terra.parallel.start", len(values))
+    nfinished = [0]
+
+    def _callback(_):
+        nfinished[0] += 1
+        Publisher().publish("terra.parallel.done", nfinished[0])
+
+    # Run in parallel if not Win and not in parallel already
+    if (
+        num_processes > 1
+        and os.getenv("QISKIT_IN_PARALLEL") == "FALSE"
+        and CONFIG.get("parallel_enabled", PARALLEL_DEFAULT)
+    ):
+        os.environ["QISKIT_IN_PARALLEL"] = "TRUE"
+        try:
+            results = []
+            with ProcessPoolExecutor(max_workers=num_processes) as executor:
+                param = ((task, value, task_args, task_kwargs) for value in values)
+                future = executor.map(_task_wrapper, param)
+
+            results = list(future)
+            Publisher().publish("terra.parallel.done", len(results))
+
+        except (KeyboardInterrupt, Exception) as error:
+            if isinstance(error, KeyboardInterrupt):
+                Publisher().publish("terra.parallel.finish")
+                os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
+                raise QiskitError("Keyboard interrupt in parallel_map.") from error
+            # Otherwise just reset parallel flag and error
+            os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
+            raise error
+
+        Publisher().publish("terra.parallel.finish")
+        os.environ["QISKIT_IN_PARALLEL"] = "FALSE"
+        return results
+
+    # Cannot do parallel on Windows , if another parallel_map is running in parallel,
+    # or len(values) == 1.
+    results = []
+    for _, value in enumerate(values):
+        result = task(value, *task_args, **task_kwargs)
+        results.append(result)
+        _callback(0)
+    Publisher().publish("terra.parallel.finish")
+    return results

qiskit/tools/visualization.py

@@ -0,0 +1,16 @@
+# 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.
+
+# pylint: disable=unused-wildcard-import,missing-module-docstring,wildcard-import
+
+# NOTE(mtreinish): Import public API here to maintain backwards compat
+from qiskit.visualization import *