qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/test/providers/provider.py

@@ -0,0 +1,59 @@
+# 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.
+
+"""Base TestCase for testing Providers."""
+
+from unittest import SkipTest
+
+from ..base import QiskitTestCase
+
+
+class ProviderTestCase(QiskitTestCase):
+    """Test case for Providers.
+
+    Implementers of providers are encouraged to subclass and customize this
+    TestCase, as it contains a "canonical" series of tests in order to ensure
+    the provider functionality matches the specifications.
+
+    Members:
+        provider_cls (BaseProvider): provider to be used in this test case. Its
+            instantiation can be further customized by overriding the
+            ``_get_provider`` function.
+        backend_name (str): name of a backend provided by the provider.
+    """
+
+    provider_cls = None
+    backend_name = ""
+
+    def setUp(self):
+        super().setUp()
+        self.provider = self._get_provider()
+
+    @classmethod
+    def setUpClass(cls):
+        if cls is ProviderTestCase:
+            raise SkipTest("Skipping base class tests")
+        super().setUpClass()
+
+    def _get_provider(self):
+        """Return an instance of a Provider."""
+        return self.provider_cls()  # pylint: disable=not-callable
+
+    def test_backends(self):
+        """Test the provider has backends."""
+        backends = self.provider.backends()
+        self.assertTrue(len(backends) > 0)
+
+    def test_get_backend(self):
+        """Test getting a backend from the provider."""
+        backend = self.provider.get_backend(name=self.backend_name)
+        self.assertEqual(backend.name(), self.backend_name)

qiskit/test/reference_circuits.py

@@ -0,0 +1,41 @@
+# 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.
+
+"""Reference circuits used by the tests."""
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
+
+
+class ReferenceCircuits:
+    """Container for reference circuits used by the tests."""
+
+    @staticmethod
+    def bell():
+        """Return a Bell circuit."""
+        qr = QuantumRegister(2, name="qr")
+        cr = ClassicalRegister(2, name="qc")
+        qc = QuantumCircuit(qr, cr, name="bell")
+        qc.h(qr[0])
+        qc.cx(qr[0], qr[1])
+        qc.measure(qr, cr)
+
+        return qc
+
+    @staticmethod
+    def bell_no_measure():
+        """Return a Bell circuit."""
+        qr = QuantumRegister(2, name="qr")
+        qc = QuantumCircuit(qr, name="bell_no_measure")
+        qc.h(qr[0])
+        qc.cx(qr[0], qr[1])
+
+        return qc

qiskit/test/testing_options.py

@@ -0,0 +1,93 @@
+# 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.
+
+"""Obtain and set the options in QISKIT_TESTS, used for running the tests."""
+
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def get_test_options(option_var="QISKIT_TESTS"):
+    """Read option_var from env and returns a dict in which the test options are set.
+
+    Args:
+        option_var (str): The env var to read. Default: 'QISKIT_TESTS'
+
+    Returns:
+        dict: A dictionary with the format {<option>: (bool)<activated>}.
+    """
+    tests_options = {"skip_online": False, "mock_online": False, "run_slow": False, "rec": False}
+
+    def turn_false(option):
+        """Turn an option to False.
+
+        Args:
+            option (str): Turns defaults[option] to False
+
+        Returns:
+            bool: True, returns always True.
+        """
+
+        tests_options[option] = False
+        return True
+
+    dependency_solvers = {
+        "skip_online": lambda: turn_false("rec"),
+        "mock_online": lambda: turn_false("skip_online"),
+        "rec": lambda: turn_false("skip_online") and turn_false("run_slow"),
+    }
+
+    def set_flag(flag_):
+        """Set the flag to True and flip all the flags that need to be rewritten.
+
+        Args:
+            flag_ (str): Option to be True
+        """
+        tests_options[flag_] = True
+        if flag_ in dependency_solvers:
+            dependency_solvers[flag_]()
+
+    flag_string = os.getenv(option_var, None)
+    flags = flag_string.split(",") if flag_string else []
+    for flag in flags:
+        if flag not in tests_options:
+            logger.error('Testing option "%s" unknown.', flag)
+        set_flag(flag)
+
+    if _is_ci_fork_pull_request():
+        set_flag("skip_online")
+
+    logger.debug(tests_options)
+    return tests_options
+
+
+def _is_ci_fork_pull_request():
+    """Check if the tests are being run in a CI environment from a PR.
+
+    Check if the tests are being run in a CI environment and if it is a pull
+    request.
+
+    Returns:
+        bool: True if the tests are executed inside a CI tool, and the changes
+            are not against the "main" branch.
+    """
+    if os.getenv("TRAVIS"):
+        # Using Travis CI.
+        if os.getenv("TRAVIS_PULL_REQUEST_BRANCH"):
+            return True
+    elif os.getenv("APPVEYOR"):
+        # Using AppVeyor CI.
+        if os.getenv("APPVEYOR_PULL_REQUEST_NUMBER"):
+            return True
+    return False

qiskit/test/utils.py

@@ -0,0 +1,87 @@
+# 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.
+
+"""Utils for using with Qiskit unit tests."""
+
+import logging
+import os
+from enum import Enum
+from itertools import product
+
+from qiskit import __path__ as qiskit_path
+
+
+class Path(Enum):
+    """Helper with paths commonly used during the tests."""
+
+    # Main SDK path:    qiskit/
+    SDK = qiskit_path[0]
+    # test.python path: qiskit/test/python/
+    TEST = os.path.normpath(os.path.join(SDK, "..", "test", "python"))
+    # Examples path:    examples/
+    EXAMPLES = os.path.normpath(os.path.join(SDK, "..", "examples"))
+    # Schemas path:     qiskit/schemas
+    SCHEMAS = os.path.normpath(os.path.join(SDK, "schemas"))
+    # Sample QASMs path: qiskit/test/python/qasm
+    QASMS = os.path.normpath(os.path.join(TEST, "qasm"))
+
+
+def setup_test_logging(logger, log_level, filename):
+    """Set logging to file and stdout for a logger.
+
+    Args:
+        logger (Logger): logger object to be updated.
+        log_level (str): logging level.
+        filename (str): name of the output file.
+    """
+    # Set up formatter.
+    log_fmt = f"{logger.name}.%(funcName)s:%(levelname)s:%(asctime)s: %(message)s"
+    formatter = logging.Formatter(log_fmt)
+
+    # Set up the file handler.
+    file_handler = logging.FileHandler(filename)
+    file_handler.setFormatter(formatter)
+    logger.addHandler(file_handler)
+
+    if os.getenv("STREAM_LOG"):
+        # Set up the stream handler.
+        stream_handler = logging.StreamHandler()
+        stream_handler.setFormatter(formatter)
+        logger.addHandler(stream_handler)
+
+    # Set the logging level from the environment variable, defaulting
+    # to INFO if it is not a valid level.
+    level = logging._nameToLevel.get(log_level, logging.INFO)
+    logger.setLevel(level)
+
+
+class Case(dict):
+    """<no description>"""
+
+    pass
+
+
+def generate_cases(docstring, dsc=None, name=None, **kwargs):
+    """Combines kwargs in Cartesian product and creates Case with them"""
+    ret = []
+    keys = kwargs.keys()
+    vals = kwargs.values()
+    for values in product(*vals):
+        case = Case(zip(keys, values))
+        if docstring is not None:
+            setattr(case, "__doc__", docstring.format(**case))
+        if dsc is not None:
+            setattr(case, "__doc__", dsc.format(**case))
+        if name is not None:
+            setattr(case, "__name__", name.format(**case))
+        ret.append(case)
+    return ret

qiskit/tools/__init__.py

@@ -0,0 +1,44 @@
+# 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.
+
+"""
+==================================
+Qiskit Tools (:mod:`qiskit.tools`)
+==================================
+
+.. currentmodule:: qiskit.tools
+
+Parallel Routines
+-----------------
+
+A helper function for calling a custom function with python ``ProcessPoolExecutor``.
+Tasks can be executed in parallel using this function.
+It has a built-in event publisher to show the progress of the parallel tasks.
+
+.. autofunction:: parallel_map
+
+Monitoring
+----------
+
+A helper module to get IBM backend information and submitted job status.
+
+.. autofunction:: job_monitor
+.. autofunction:: backend_monitor
+.. autofunction:: backend_overview
+
+.. automodule:: qiskit.tools.events
+
+"""
+
+from .parallel import parallel_map
+from .monitor import job_monitor, backend_monitor, backend_overview
+from .events import progressbar

qiskit/tools/events/__init__.py

@@ -0,0 +1,25 @@
+# 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.
+
+"""
+===================================
+Events (:mod:`qiskit.tools.events`)
+===================================
+
+A helper component for publishing and subscribing to events.
+
+.. currentmodule:: qiskit.tools.events
+
+.. autoclass:: TextProgressBar
+"""
+
+from .progressbar import TextProgressBar

qiskit/tools/events/progressbar.py

@@ -0,0 +1,195 @@
+# 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
+import datetime
+import sys
+from qiskit.tools.events.pubsub import Subscriber
+
+
+class BaseProgressBar(Subscriber):
+    """An abstract progress bar with some shared functionality."""
+
+    def __init__(self):
+        super().__init__()
+        self.type = "progressbar"
+        self.touched = False
+        self.iter = None
+        self.t_start = None
+        self.t_done = None
+
+    def start(self, iterations):
+        """Start the progress bar.
+
+        Parameters:
+            iterations (int): Number of iterations.
+        """
+        self.touched = True
+        self.iter = int(iterations)
+        self.t_start = time.time()
+
+    def update(self, n):
+        """Update status of progress bar."""
+        pass
+
+    def time_elapsed(self):
+        """Return the time elapsed since start.
+
+        Returns:
+            elapsed_time: Time since progress bar started.
+        """
+        return "%6.2fs" % (time.time() - self.t_start)
+
+    def time_remaining_est(self, completed_iter):
+        """Estimate the remaining time left.
+
+        Parameters:
+            completed_iter (int): Number of iterations completed.
+
+        Returns:
+            est_time: Estimated time remaining.
+        """
+        if completed_iter:
+            t_r_est = (time.time() - self.t_start) / completed_iter * (self.iter - completed_iter)
+        else:
+            t_r_est = 0
+        date_time = datetime.datetime(1, 1, 1) + datetime.timedelta(seconds=t_r_est)
+        time_string = "%02d:%02d:%02d:%02d" % (
+            date_time.day - 1,
+            date_time.hour,
+            date_time.minute,
+            date_time.second,
+        )
+
+        return time_string
+
+    def finished(self):
+        """Run when progress bar has completed."""
+        pass
+
+
+class TextProgressBar(BaseProgressBar):
+    """
+    A simple text-based progress bar.
+
+    output_handler : the handler the progress bar should be written to, default
+                     is sys.stdout, another option is sys.stderr
+
+    Examples:
+
+        The progress bar can be used to track the progress of a `parallel_map`.
+
+        .. code-block:: python
+
+            import numpy as np
+            import qiskit.tools.jupyter
+            from qiskit.tools.parallel import parallel_map
+            from qiskit.tools.events import TextProgressBar
+
+            TextProgressBar()
+            %qiskit_progress_bar -t text
+            parallel_map(np.sin, np.linspace(0,10,100));
+
+        And it can also be used individually.
+
+        .. code-block:: python
+
+            from qiskit.tools.events import TextProgressBar
+
+            iterations = 100
+            t = TextProgressBar()
+            t.start(iterations=iterations)
+            for i in range(iterations):
+                # step i of heavy calculation ...
+                t.update(i + 1)  # update progress bar
+
+    """
+
+    def __init__(self, output_handler=None):
+        super().__init__()
+        self._init_subscriber()
+
+        self.output_handler = output_handler if output_handler else sys.stdout
+
+    def _init_subscriber(self):
+        def _initialize_progress_bar(num_tasks):
+            self.start(num_tasks)
+
+        self.subscribe("terra.parallel.start", _initialize_progress_bar)
+
+        def _update_progress_bar(progress):
+            self.update(progress)
+
+        self.subscribe("terra.parallel.done", _update_progress_bar)
+
+        def _finish_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):
+        self.touched = True
+        self.iter = int(iterations)
+        self.t_start = time.time()
+        pbar = "-" * 50
+        self.output_handler.write("\r|{}| {}{}{} [{}]".format(pbar, 0, "/", self.iter, ""))
+
+    def update(self, n):
+        # Don't update if we are not initialized or
+        # the update iteration number is greater than the total iterations set on start.
+        if not self.touched or n > self.iter:
+            return
+        filled_length = int(round(50 * n / self.iter))
+        pbar = "█" * filled_length + "-" * (50 - filled_length)
+        time_left = self.time_remaining_est(n)
+        self.output_handler.write("\r|{}| {}{}{} [{}]".format(pbar, n, "/", self.iter, time_left))
+        if n == self.iter:
+            self.output_handler.write("\n")
+        self.output_handler.flush()