Migrate basic aer provider to new versioned interface

azure-pipelines.yml

@@ -705,8 +705,9 @@ stages:
             git clone https://github.com/Qiskit/qiskit-tutorials --depth=1
             python -m pip install --upgrade pip
             pip install -U -r requirements.txt -r requirements-dev.txt -c constraints.txt
-            pip install -U -c constraints.txt -e .
-            pip install -U "qiskit-ibmq-provider" "qiskit-aer" "z3-solver" "git+https://github.com/Qiskit/qiskit-ignis" "qiskit-aqua" "pyscf<1.7.4" "matplotlib<3.3.0" sphinx nbsphinx sphinx_rtd_theme cvxpy -c constraints.txt
+            pip install -c constraints.txt -e .
+            # TODO: Remove aqua and ignis from source after next aqua release
+            pip install "qiskit-ibmq-provider" "qiskit-aer" "z3-solver" "git+https://github.com/Qiskit/qiskit-ignis" "git+https://github.com/Qiskit/qiskit-aqua" "pyscf<1.7.4" "matplotlib<3.3.0" sphinx nbsphinx sphinx_rtd_theme cvxpy -c constraints.txt
             python setup.py build_ext --inplace
             sudo apt install -y graphviz pandoc
             pip check

qiskit/providers/basicaer/basicaerjob.py

@@ -10,122 +10,57 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""This module implements the job class used by Basic Aer Provider."""
-
-from concurrent import futures
-import sys
-import functools
-
-from qiskit.providers import BaseJob, JobStatus, JobError
-
+# pylint: disable=abstract-method
 
-def requires_submit(func):
-    """
-    Decorator to ensure that a submit has been performed before
-    calling the method.
 
-    Args:
-        func (callable): test function to be decorated.
+"""This module implements the job class used by Basic Aer Provider."""
 
-    Returns:
-        callable: the decorated function.
-    """
-    @functools.wraps(func)
-    def _wrapper(self, *args, **kwargs):
-        if self._future is None:
-            raise JobError("Job not submitted yet!. You have to .submit() first!")
-        return func(self, *args, **kwargs)
-    return _wrapper
+import warnings
 
+from qiskit.providers import JobStatus
+from qiskit.providers.job import JobV1
 
-class BasicAerJob(BaseJob):
-    """BasicAerJob class.
 
-    Attributes:
-        _executor (futures.Executor): executor to handle asynchronous jobs
-    """
+class BasicAerJob(JobV1):
+    """BasicAerJob class."""
 
-    if sys.platform in ['darwin', 'win32']:
-        _executor = futures.ThreadPoolExecutor()
-    else:
-        _executor = futures.ProcessPoolExecutor()
+    _async = False
 
-    def __init__(self, backend, job_id, fn, qobj):
+    def __init__(self, backend, job_id, result):
         super().__init__(backend, job_id)
-        self._fn = fn
-        self._qobj = qobj
-        self._future = None
+        self._result = result
 
     def submit(self):
         """Submit the job to the backend for execution.
 
         Raises:
             JobError: if trying to re-submit the job.
         """
-        if self._future is not None:
-            raise JobError("We have already submitted the job!")
-
-        self._future = self._executor.submit(self._fn, self._job_id, self._qobj)
+        return
 
-    @requires_submit
     def result(self, timeout=None):
         # pylint: disable=arguments-differ
-        """Get job result. The behavior is the same as the underlying
-        concurrent Future objects,
-
-        https://docs.python.org/3/library/concurrent.futures.html#future-objects
-
-        Args:
-            timeout (float): number of seconds to wait for results.
+        """Get job result .
 
         Returns:
             qiskit.Result: Result object
-
-        Raises:
-            concurrent.futures.TimeoutError: if timeout occurred.
-            concurrent.futures.CancelledError: if job cancelled before completed.
         """
-        return self._future.result(timeout=timeout)
+        if timeout is not None:
+            warnings.warn("The timeout kwarg doesn't have any meaning with "
+                          "BasicAer because execution is synchronous and the "
+                          "result already exists when run() returns.",
+                          UserWarning)
 
-    @requires_submit
-    def cancel(self):
-        return self._future.cancel()
+        return self._result
 
-    @requires_submit
     def status(self):
         """Gets the status of the job by querying the Python's future
 
         Returns:
             qiskit.providers.JobStatus: The current JobStatus
-
-        Raises:
-            JobError: If the future is in unexpected state
-            concurrent.futures.TimeoutError: if timeout occurred.
         """
-        # The order is important here
-        if self._future.running():
-            _status = JobStatus.RUNNING
-        elif self._future.cancelled():
-            _status = JobStatus.CANCELLED
-        elif self._future.done():
-            _status = JobStatus.DONE if self._future.exception() is None else JobStatus.ERROR
-        else:
-            # Note: There is an undocumented Future state: PENDING, that seems to show up when
-            # the job is enqueued, waiting for someone to pick it up. We need to deal with this
-            # state but there's no public API for it, so we are assuming that if the job is not
-            # in any of the previous states, is PENDING, ergo INITIALIZING for us.
-            _status = JobStatus.INITIALIZING
-
-        return _status
+        return JobStatus.DONE
 
     def backend(self):
         """Return the instance of the backend used for this job."""
         return self._backend
-
-    def qobj(self):
-        """Return the Qobj submitted for this job.
-
-        Returns:
-            Qobj: the Qobj submitted for this job.
-        """
-        return self._qobj

qiskit/providers/basicaer/basicaerprovider.py

@@ -17,7 +17,7 @@
 import logging
 
 from qiskit.exceptions import QiskitError
-from qiskit.providers import BaseProvider
+from qiskit.providers.provider import ProviderV1
 from qiskit.providers.exceptions import QiskitBackendNotFoundError
 from qiskit.providers.providerutils import resolve_backend_name, filter_backends
 
@@ -35,11 +35,11 @@
 ]
 
 
-class BasicAerProvider(BaseProvider):
+class BasicAerProvider(ProviderV1):
     """Provider for Basic Aer backends."""
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(args, kwargs)
+    def __init__(self):
+        super().__init__()
 
         # Populate the list of Basic Aer backends.
         self._backends = self._verify_backends()
@@ -109,14 +109,9 @@ def _verify_backends(self):
         """
         ret = OrderedDict()
         for backend_cls in SIMULATORS:
-            try:
-                backend_instance = self._get_backend_instance(backend_cls)
-                backend_name = backend_instance.name()
-                ret[backend_name] = backend_instance
-            except QiskitError as err:
-                # Ignore backends that could not be initialized.
-                logger.info('Basic Aer backend %s is not available: %s',
-                            backend_cls, str(err))
+            backend_instance = self._get_backend_instance(backend_cls)
+            backend_name = backend_instance.name()
+            ret[backend_name] = backend_instance
         return ret
 
     def _get_backend_instance(self, backend_cls):

qiskit/providers/basicaer/qasm_simulator.py

@@ -31,15 +31,18 @@
 import uuid
 import time
 import logging
+import warnings
 
 from math import log2
 from collections import Counter
 import numpy as np
 
+from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.utils.multiprocessing import local_hardware_info
 from qiskit.providers.models import QasmBackendConfiguration
 from qiskit.result import Result
-from qiskit.providers import BaseBackend
+from qiskit.providers.backend import BackendV1
+from qiskit.providers.options import Options
 from qiskit.providers.basicaer.basicaerjob import BasicAerJob
 from .exceptions import BasicAerError
 from .basicaertools import single_gate_matrix
@@ -50,7 +53,7 @@
 logger = logging.getLogger(__name__)
 
 
-class QasmSimulatorPy(BaseBackend):
+class QasmSimulatorPy(BackendV1):
     """Python implementation of a qasm simulator."""
 
     MAX_QUBITS_MEMORY = int(log2(local_hardware_info()['memory'] * (1024 ** 3) / 16))
@@ -127,11 +130,12 @@ class QasmSimulatorPy(BaseBackend):
     # This should be set to True for the statevector simulator
     SHOW_FINAL_STATE = False
 
-    def __init__(self, configuration=None, provider=None):
-        super().__init__(configuration=(
-            configuration or QasmBackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION)),
-                         provider=provider)
-
+    def __init__(self, configuration=None, provider=None, **fields):
+        super().__init__(
+            configuration=(configuration or QasmBackendConfiguration.from_dict(
+                self.DEFAULT_CONFIGURATION)),
+            provider=provider,
+            **fields)
         # Define attributes in __init__.
         self._local_random = np.random.RandomState()
         self._classical_memory = 0
@@ -141,12 +145,19 @@ def __init__(self, configuration=None, provider=None):
         self._number_of_qubits = 0
         self._shots = 0
         self._memory = False
-        self._initial_statevector = self.DEFAULT_OPTIONS["initial_statevector"]
-        self._chop_threshold = self.DEFAULT_OPTIONS["chop_threshold"]
+        self._initial_statevector = self.options.get('initial_statevector')
+        self._chop_threshold = self.options.get("chop_threashold")
         self._qobj_config = None
         # TEMP
         self._sample_measure = False
 
+    @classmethod
+    def _default_options(cls):
+        return Options(shots=1024, memory=False,
+                       initial_statevector=None, chop_threshold=1e-15,
+                       allow_sample_measuring=True, seed_simulator=None,
+                       parameter_binds=None)
+
     def _add_unitary(self, gate, qubits):
         """Apply an N-qubit unitary matrix.
 
@@ -292,10 +303,10 @@ def _validate_initial_statevector(self):
     def _set_options(self, qobj_config=None, backend_options=None):
         """Set the backend options for all experiments in a qobj"""
         # Reset default options
-        self._initial_statevector = self.DEFAULT_OPTIONS["initial_statevector"]
-        self._chop_threshold = self.DEFAULT_OPTIONS["chop_threshold"]
-        if backend_options is None:
-            backend_options = {}
+        self._initial_statevector = self.options.get("initial_statevector")
+        self._chop_threshold = self.options.get("chop_threshold")
+        if 'backend_options' in backend_options and backend_options['backend_options']:
+            backend_options = backend_options['backend_options']
 
         # Check for custom initial statevector in backend_options first,
         # then config second
@@ -377,7 +388,7 @@ def _validate_measure_sampling(self, experiment):
             # measure sampling is allowed
             self._sample_measure = True
 
-    def run(self, qobj, backend_options=None):
+    def run(self, qobj, **backend_options):
         """Run qobj asynchronously.
 
         Args:
@@ -402,11 +413,28 @@ def run(self, qobj, backend_options=None):
                     "initial_statevector": np.array([1, 0, 0, 1j]) / np.sqrt(2),
                 }
         """
-        self._set_options(qobj_config=qobj.config,
+        if isinstance(qobj, (QuantumCircuit, list)):
+            from qiskit.compiler import assemble
+            out_options = {}
+            for key in backend_options:
+                if not hasattr(self.options, key):
+                    warnings.warn(
+                        "Option %s is not used by this backend" % key,
+                        UserWarning, stacklevel=2)
+                else:
+                    out_options[key] = backend_options[key]
+            qobj = assemble(qobj, self, **out_options)
+            qobj_options = qobj.config
+        else:
+            warnings.warn('Using a qobj for run() is deprecated and will be '
+                          'removed in a future release.',
+                          PendingDeprecationWarning,
+                          stacklevel=2)
+            qobj_options = qobj.config
+        self._set_options(qobj_config=qobj_options,
                           backend_options=backend_options)
         job_id = str(uuid.uuid4())
-        job = BasicAerJob(self, job_id, self._run_job, qobj)
-        job.submit()
+        job = BasicAerJob(self, job_id, self._run_job(job_id, qobj))
         return job
 
     def _run_job(self, job_id, qobj):

qiskit/providers/basicaer/statevector_simulator.py

@@ -104,12 +104,12 @@ class StatevectorSimulatorPy(QasmSimulatorPy):
     # Override base class value to return the final state vector
     SHOW_FINAL_STATE = True
 
-    def __init__(self, configuration=None, provider=None):
+    def __init__(self, configuration=None, provider=None, **fields):
         super().__init__(configuration=(
             configuration or QasmBackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION)),
-                         provider=provider)
+                         provider=provider, **fields)
 
-    def run(self, qobj, backend_options=None):
+    def run(self, qobj, **backend_options):
         """Run qobj asynchronously.
 
         Args: