qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/tools/jupyter/jupyter_magics.py

@@ -0,0 +1,190 @@
+# 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 of magic functions"""
+
+import time
+import threading
+from IPython import get_ipython
+from IPython.display import display
+from IPython.core import magic_arguments
+from IPython.core.magic import cell_magic, line_magic, Magics, magics_class, register_line_magic
+
+from qiskit.utils import optionals as _optionals
+from qiskit.utils.deprecation import deprecate_func
+import qiskit
+from qiskit.tools.events.progressbar import TextProgressBar
+from .progressbar import HTMLProgressBar
+from .library import circuit_library_widget
+
+
+def _html_checker(job_var, interval, status, header, _interval_set=False):
+    """Internal function that updates the status
+    of a HTML job monitor.
+
+    Args:
+        job_var (BaseJob): The job to keep track of.
+        interval (int): The status check interval
+        status (widget): HTML ipywidget for output to screen
+        header (str): String representing HTML code for status.
+        _interval_set (bool): Was interval set by user?
+    """
+    job_status = job_var.status()
+    job_status_name = job_status.name
+    job_status_msg = job_status.value
+    status.value = header % (job_status_msg)
+    while job_status_name not in ["DONE", "CANCELLED"]:
+        time.sleep(interval)
+        job_status = job_var.status()
+        job_status_name = job_status.name
+        job_status_msg = job_status.value
+        if job_status_name == "ERROR":
+            break
+        if job_status_name == "QUEUED":
+            job_status_msg += " (%s)" % job_var.queue_position()
+            if job_var.queue_position() is None:
+                interval = 2
+            elif not _interval_set:
+                interval = max(job_var.queue_position(), 2)
+        else:
+            if not _interval_set:
+                interval = 2
+        status.value = header % (job_status_msg)
+
+    status.value = header % (job_status_msg)
+
+
+@magics_class
+class StatusMagic(Magics):
+    """A class of status magic functions."""
+
+    @cell_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        "-i", "--interval", type=float, default=None, help="Interval for status check."
+    )
+    @_optionals.HAS_IPYWIDGETS.require_in_call
+    def qiskit_job_status(self, line="", cell=None):
+        """A Jupyter magic function to check the status of a Qiskit job instance."""
+        import ipywidgets as widgets
+
+        args = magic_arguments.parse_argstring(self.qiskit_job_status, line)
+
+        if args.interval is None:
+            args.interval = 2
+            _interval_set = False
+        else:
+            _interval_set = True
+
+        # Split cell lines to get LHS variables
+        cell_lines = cell.split("\n")
+        line_vars = []
+        for cline in cell_lines:
+            if "=" in cline and "==" not in cline:
+                line_vars.append(cline.replace(" ", "").split("=")[0])
+            elif ".append(" in cline:
+                line_vars.append(cline.replace(" ", "").split("(")[0])
+
+        # Execute the cell
+        self.shell.ex(cell)
+
+        # Look for all vars that are BaseJob instances
+        jobs = []
+        for var in line_vars:
+            iter_var = False
+            if "#" not in var:
+                # The line var is a list or array, but we cannot parse the index
+                # so just iterate over the whole array for jobs.
+                if "[" in var:
+                    var = var.split("[")[0]
+                    iter_var = True
+                elif ".append" in var:
+                    var = var.split(".append")[0]
+                    iter_var = True
+
+                if iter_var:
+                    for item in self.shell.user_ns[var]:
+                        if isinstance(item, qiskit.providers.job.Job):
+                            jobs.append(item)
+                else:
+                    if isinstance(self.shell.user_ns[var], qiskit.providers.job.Job):
+                        jobs.append(self.shell.user_ns[var])
+
+        # Must have one job class
+        if not any(jobs):
+            raise Exception("Cell must contain at least one variable of BaseJob type.")
+
+        # List index of job if checking status of multiple jobs.
+        multi_job = False
+        if len(jobs) > 1:
+            multi_job = True
+
+        job_checkers = []
+        # Loop over every BaseJob that was found.
+        for idx, job_var in enumerate(jobs):
+            style = "font-size:16px;"
+            if multi_job:
+                idx_str = "[%s]" % idx
+            else:
+                idx_str = ""
+            header = f"<p style='{style}'>Job Status {idx_str}: %s </p>"
+            status = widgets.HTML(value=header % job_var.status().value)
+
+            thread = threading.Thread(
+                target=_html_checker, args=(job_var, args.interval, status, header, _interval_set)
+            )
+            thread.start()
+            job_checkers.append(status)
+
+        # Group all HTML widgets into single vertical layout
+        box = widgets.VBox(job_checkers)
+        display(box)
+
+
+@magics_class
+class ProgressBarMagic(Magics):
+    """A class of progress bar magic functions."""
+
+    @line_magic
+    @magic_arguments.magic_arguments()
+    @magic_arguments.argument(
+        "-t", "--type", type=str, default="html", help="Type of progress bar, 'html' or 'text'."
+    )
+    def qiskit_progress_bar(self, line="", cell=None):  # pylint: disable=unused-argument
+        """A Jupyter magic function to generate progressbar."""
+        args = magic_arguments.parse_argstring(self.qiskit_progress_bar, line)
+        if args.type == "html":
+            pbar = HTMLProgressBar()
+        elif args.type == "text":
+            pbar = TextProgressBar()
+        else:
+            raise qiskit.QiskitError("Invalid progress bar type.")
+
+        return pbar
+
+
+if _optionals.HAS_MATPLOTLIB and get_ipython():
+
+    @register_line_magic
+    @deprecate_func(
+        since="0.25.0",
+        additional_msg="This was originally only for internal documentation and is no longer used.",
+    )
+    def circuit_library_info(circuit: qiskit.QuantumCircuit) -> None:
+        """Displays library information for a quantum circuit.
+
+        Args:
+            circuit: Input quantum circuit.
+        """
+        shell = get_ipython()
+        circ = shell.ev(circuit)
+        circuit_library_widget(circ)

qiskit/tools/jupyter/library.py

@@ -0,0 +1,189 @@
+# 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.
+
+# pylint: disable=invalid-name,no-name-in-module,ungrouped-imports
+
+"""A circuit library widget module"""
+
+import ipywidgets as wid
+from IPython.display import display
+from qiskit import QuantumCircuit
+from qiskit.utils import optionals as _optionals
+from qiskit.utils.deprecation import deprecate_func
+
+
+@_optionals.HAS_MATPLOTLIB.require_in_call
+def _generate_circuit_library_visualization(circuit: QuantumCircuit):
+    import matplotlib.pyplot as plt
+
+    circuit = circuit.decompose()
+    ops = circuit.count_ops()
+    num_nl = circuit.num_nonlocal_gates()
+    _fig, (ax0, ax1) = plt.subplots(2, 1)
+    circuit.draw("mpl", ax=ax0)
+    ax1.axis("off")
+    ax1.grid(visible=None)
+    ax1.table(
+        [[circuit.name], [circuit.width()], [circuit.depth()], [sum(ops.values())], [num_nl]],
+        rowLabels=["Circuit Name", "Width", "Depth", "Total Gates", "Non-local Gates"],
+    )
+    plt.tight_layout()
+    plt.show()
+
+
+@deprecate_func(
+    since="0.25.0",
+    additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
+    package_name="qiskit-terra",
+)
+def circuit_data_table(circuit: QuantumCircuit) -> wid.HTML:
+    """Create a HTML table widget for a given quantum circuit.
+
+    Args:
+        circuit: Input quantum circuit.
+
+    Returns:
+        Output widget.
+    """
+
+    circuit = circuit.decompose()
+    ops = circuit.count_ops()
+    num_nl = circuit.num_nonlocal_gates()
+
+    html = "<table>"
+    html += """<style>
+table {
+    font-family: "IBM Plex Sans", Arial, Helvetica, sans-serif;
+    border-collapse: collapse;
+    width: 100%;
+    border-left: 2px solid #212121;
+}
+
+th {
+    text-align: left;
+    padding: 5px 5px 5px 5px;
+    width: 100%;
+    background-color: #988AFC;
+    color: #fff;
+    font-size: 14px;
+    border-left: 2px solid #988AFC;
+}
+
+td {
+    text-align: left;
+    padding: 5px 5px 5px 5px;
+    width: 100%;
+    font-size: 12px;
+    font-weight: medium;
+}
+
+tr:nth-child(even) {background-color: #f6f6f6;}
+</style>"""
+    html += f"<tr><th>{circuit.name}</th><th></tr>"
+    html += f"<tr><td>Width</td><td>{circuit.width()}</td></tr>"
+    html += f"<tr><td>Depth</td><td>{circuit.depth()}</td></tr>"
+    html += f"<tr><td>Total Gates</td><td>{sum(ops.values())}</td></tr>"
+    html += f"<tr><td>Non-local Gates</td><td>{num_nl}</td></tr>"
+    html += "</table>"
+
+    out_wid = wid.HTML(html)
+    return out_wid
+
+
+head_style = (
+    "font-family: IBM Plex Sans, Arial, Helvetica, sans-serif;"
+    " font-size: 20px; font-weight: medium;"
+)
+
+property_label = wid.HTML(
+    f"<p style='{head_style}'>Circuit Properties</p>",
+    layout=wid.Layout(margin="0px 0px 10px 0px"),
+)
+
+
+@deprecate_func(
+    since="0.25.0",
+    additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
+    package_name="qiskit-terra",
+)
+def properties_widget(circuit: QuantumCircuit) -> wid.VBox:
+    """Create a HTML table widget with header for a given quantum circuit.
+
+    Args:
+        circuit: Input quantum circuit.
+
+    Returns:
+        Output widget.
+    """
+    properties = wid.VBox(
+        children=[property_label, circuit_data_table(circuit)],
+        layout=wid.Layout(width="40%", height="auto"),
+    )
+    return properties
+
+
+@deprecate_func(
+    since="0.25.0",
+    additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
+    package_name="qiskit-terra",
+)
+def circuit_diagram_widget() -> wid.Box:
+    """Create a circuit diagram widget.
+
+    Returns:
+        Output widget.
+    """
+    # The max circuit height corresponds to a 20Q circuit with flat
+    # classical register.
+    top_out = wid.Output(
+        layout=wid.Layout(
+            width="100%",
+            height="auto",
+            max_height="1000px",
+            overflow="hidden scroll",
+        )
+    )
+
+    top = wid.Box(children=[top_out], layout=wid.Layout(width="100%", height="auto"))
+
+    return top
+
+
+@deprecate_func(
+    since="0.25.0",
+    additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
+    package_name="qiskit-terra",
+)
+def circuit_library_widget(circuit: QuantumCircuit) -> None:
+    """Create a circuit library widget.
+
+    Args:
+        circuit: Input quantum circuit.
+    """
+    sep_length = str(min(20, 495))
+
+    # The separator widget
+    sep = wid.HTML(
+        f"<div style='border-left: 3px solid #212121;height: {sep_length}px;'></div>",
+        layout=wid.Layout(height="auto", max_height="495px", margin="40px 0px 0px 20px"),
+    )
+    bottom = wid.HBox(
+        children=[properties_widget(circuit), sep],
+        layout=wid.Layout(max_height="550px", height="auto"),
+    )
+
+    top = circuit_diagram_widget()
+
+    with top.children[0]:
+        display(circuit.decompose().draw(output="mpl"))
+
+    display(wid.VBox(children=[top, bottom], layout=wid.Layout(width="100%", height="auto")))

qiskit/tools/jupyter/monospace.py

@@ -0,0 +1,29 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+# pylint: disable=unused-argument
+
+"""A Jupyter magic to choose a real monospaced fonts, if available."""
+
+from IPython.display import HTML, display
+from IPython.core.magic import line_magic, Magics, magics_class
+
+
+@magics_class
+class MonospacedOutput(Magics):
+    """A class for setting "Courier New" for output code."""
+
+    @line_magic
+    def monospaced_output(self, line="", cell=None):
+        """A Jupyter magic function to set "Courier New" for output code."""
+        html = """<style type='text/css'>
+        code, kbd, pre, samp {font-family: Courier New,monospace;line-height: 1.1;}</style>"""
+        display(HTML(html))

qiskit/tools/jupyter/progressbar.py

@@ -0,0 +1,122 @@
+# 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.
+###############################################################################
+
+"""Progress bars module"""
+
+import time
+
+from qiskit.tools.events.progressbar import BaseProgressBar
+from qiskit.utils import optionals as _optionals
+
+
+@_optionals.HAS_IPYWIDGETS.require_in_instance
+class HTMLProgressBar(BaseProgressBar):
+    """
+    A simple HTML progress bar for using in IPython notebooks.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.progress_bar = None
+        self.label = None
+        self.box = None
+        self._init_subscriber()
+
+    def _init_subscriber(self):
+        def _initialize_progress_bar(num_tasks):
+            """When an event of compilation starts, this function will be called, and
+            will initialize the progress bar.
+
+            Args:
+                num_tasks: Number of compilation tasks the progress bar will track
+            """
+            self.start(num_tasks)
+
+        self.subscribe("terra.parallel.start", _initialize_progress_bar)
+
+        def _update_progress_bar(progress):
+            """When an event of compilation completes, this function will be called, and
+            will update the progress bar indication.
+
+            Args:
+                progress: Number of tasks completed
+            """
+            self.update(progress)
+
+        self.subscribe("terra.parallel.done", _update_progress_bar)
+
+        def _finish_progress_bar():
+            """When an event of compilation finishes (meaning that there's no more circuits to
+            compile), this function will be called, unsubscribing from all events and
+            finishing the progress bar."""
+            self.unsubscribe("terra.parallel.start", _initialize_progress_bar)
+            self.unsubscribe("terra.parallel.done", _update_progress_bar)
+            self.unsubscribe("terra.parallel.finish", _finish_progress_bar)
+            self.finished()
+
+        self.subscribe("terra.parallel.finish", _finish_progress_bar)
+
+    def start(self, iterations):
+        import ipywidgets as widgets
+        from IPython.display import display
+
+        self.touched = True
+        self.iter = int(iterations)
+        self.t_start = time.time()
+        self.progress_bar = widgets.IntProgress(min=0, max=self.iter, value=0)
+        self.progress_bar.bar_style = "info"
+        self.label = widgets.HTML()
+        self.box = widgets.VBox(children=[self.label, self.progress_bar])
+        display(self.box)
+
+    def update(self, n):
+        self.progress_bar.value += 1
+        lbl = "Completed %s/%s: Est. remaining time: %s."
+        self.label.value = lbl % (n, self.iter, self.time_remaining_est(n))
+
+    def finished(self):
+        self.t_done = time.time()
+        self.progress_bar.bar_style = "success"
+        self.label.value = "Elapsed time: %s" % self.time_elapsed()

qiskit/tools/jupyter/version_table.py

@@ -0,0 +1,67 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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-argument
+
+"""A module for monitoring backends."""
+
+import time
+from sys import modules
+from IPython.display import HTML, display
+from IPython.core.magic import line_magic, Magics, magics_class
+import qiskit
+from qiskit.utils import local_hardware_info
+
+
+@magics_class
+class VersionTable(Magics):
+    """A class of status magic functions."""
+
+    @line_magic
+    def qiskit_version_table(self, line="", cell=None):
+        """
+        Print an HTML-formatted table with version numbers for Qiskit and its
+        dependencies. This should make it possible to reproduce the environment
+        and the calculation later on.
+        """
+        html = "<h3>Version Information</h3>"
+        html += "<table>"
+        html += "<tr><th>Software</th><th>Version</th></tr>"
+
+        packages = {"qiskit": qiskit.__version__}
+        qiskit_modules = {module.split(".")[0] for module in modules.keys() if "qiskit" in module}
+
+        for qiskit_module in qiskit_modules:
+            packages[qiskit_module] = getattr(modules[qiskit_module], "__version__", None)
+
+        for name, version in packages.items():
+            if version:
+                html += f"<tr><td><code>{name}</code></td><td>{version}</td></tr>"
+
+        html += "<tr><th colspan='2'>System information</th></tr>"
+
+        local_hw_info = local_hardware_info()
+        sys_info = [
+            ("Python version", local_hw_info["python_version"]),
+            ("Python compiler", local_hw_info["python_compiler"]),
+            ("Python build", local_hw_info["python_build"]),
+            ("OS", "%s" % local_hw_info["os"]),
+            ("CPUs", "%s" % local_hw_info["cpus"]),
+            ("Memory (Gb)", "%s" % local_hw_info["memory"]),
+        ]
+
+        for name, version in sys_info:
+            html += f"<tr><td>{name}</td><td>{version}</td></tr>"
+
+        html += "<tr><td colspan='2'>%s</td></tr>" % time.strftime("%a %b %d %H:%M:%S %Y %Z")
+        html += "</table>"
+
+        return display(HTML(html))

qiskit/tools/jupyter/watcher_monitor.py

@@ -0,0 +1,74 @@
+# 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.
+
+"""A module of widgets for job monitoring"""
+import sys
+import time
+import threading
+
+
+def _job_monitor(job, status, watcher):
+    """Monitor the status of a IBMQJob instance.
+
+    Args:
+        job (BaseJob): Job to monitor.
+        status (Enum): Job status.
+        watcher (JobWatcher): Job watcher instance
+    """
+    thread = threading.Thread(target=_job_checker, args=(job, status, watcher))
+    thread.start()
+
+
+def _job_checker(job, status, watcher):
+    """A simple job status checker
+
+    Args:
+        job (BaseJob): The job to check.
+        status (Enum): Job status.
+        watcher (JobWatcher): Job watcher instance
+
+    """
+    prev_status_name = None
+    prev_queue_pos = None
+    interval = 2
+    exception_count = 0
+
+    while status.name not in ["DONE", "CANCELLED", "ERROR"]:
+        time.sleep(interval)
+        try:
+            status = job.status()
+            exception_count = 0
+
+            if status.name == "QUEUED":
+                queue_pos = job.queue_position()
+                if queue_pos != prev_queue_pos:
+
+                    update_info = (job.job_id(), status.name, queue_pos, status.value)
+
+                    watcher.update_single_job(update_info)
+                    interval = max(queue_pos, 2)
+                    prev_queue_pos = queue_pos
+
+            elif status.name != prev_status_name:
+                update_info = (job.job_id(), status.name, 0, status.value)
+
+                watcher.update_single_job(update_info)
+                interval = 2
+                prev_status_name = status.name
+
+        # pylint: disable=broad-except
+        except Exception:
+            exception_count += 1
+            if exception_count == 5:
+                update_info = (job.job_id(), "NA", 0, "Could not query job.")
+                watcher.update_single_job(update_info)
+                sys.exit()

qiskit/tools/monitor/__init__.py

@@ -0,0 +1,16 @@
+# 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 jobs, backends, etc."""
+
+from .job_monitor import job_monitor
+from .overview import backend_monitor, backend_overview