Add BackendV2 mocked backend

qiskit/test/mock/__init__.py

@@ -20,7 +20,7 @@
 The mock devices are mainly for testing the compiler.
 """
 
-from .fake_provider import FakeProvider, FakeLegacyProvider
+from .fake_provider import FakeProvider, FakeLegacyProvider, FakeProviderV2
 from .fake_provider import FakeProviderFactory
 from .fake_backend import FakeBackend, FakeLegacyBackend
 from .fake_backend_v2 import FakeBackendV2, FakeBackend5QV2

qiskit/test/mock/backends/__init__.py

@@ -31,7 +31,7 @@
 from .essex import FakeEssex
 from .guadalupe import FakeGuadalupe
 from .hanoi import FakeHanoi
-from .jakarta import FakeJakarta
+from .jakarta import FakeJakarta, FakeJakartaV2
 from .johannesburg import FakeJohannesburg
 from .kolkata import FakeKolkata
 from .lagos import FakeLagos

qiskit/test/mock/backends/jakarta/__init__.py

@@ -12,4 +12,4 @@
 
 """Mock jakarta backend"""
 
-from .fake_jakarta import FakeJakarta
+from .fake_jakarta import FakeJakarta, FakeJakartaV2

qiskit/test/mock/backends/jakarta/fake_jakarta.py

@@ -15,7 +15,7 @@
 """
 
 import os
-from qiskit.test.mock import fake_pulse_backend
+from qiskit.test.mock import fake_pulse_backend, fake_backend
 
 
 class FakeJakarta(fake_pulse_backend.FakePulseBackend):
@@ -26,3 +26,11 @@ class FakeJakarta(fake_pulse_backend.FakePulseBackend):
     props_filename = "props_jakarta.json"
     defs_filename = "defs_jakarta.json"
     backend_name = "fake_jakarta"
+
+class FakeJakartaV2(fake_backend.FakeBackendV2):
+    """A fake 7 qubit V2 backend."""
+    dirname = os.path.dirname(__file__)
+    conf_filename = "conf_jakarta.json"
+    props_filename = "props_jakarta.json"
+    defs_filename = "defs_jakarta.json"
+    backend_name = "fake_jakarta_v2"

qiskit/test/mock/fake_backend.py

@@ -18,13 +18,35 @@
 
 import uuid
 import warnings
+import json
+import os
+
+from typing import Iterable, List, Union
 
 from qiskit import circuit
-from qiskit.providers.models import BackendProperties
-from qiskit.providers import BackendV1, BaseBackend
+from qiskit.providers.models import BackendProperties, PulseBackendConfiguration, PulseDefaults
+from qiskit.providers import BackendV1, BackendV2, BaseBackend, QubitProperties
+from qiskit.providers.options import Options
 from qiskit import pulse
+from qiskit.pulse.channels import (
+    AcquireChannel,
+    ControlChannel,
+    DriveChannel,
+    MeasureChannel,
+)
+from qiskit.circuit.parameter import Parameter
+from qiskit.transpiler import Target, InstructionProperties
 from qiskit.exceptions import QiskitError
 from qiskit.test.mock import fake_job
+from qiskit.test.mock.utils.json_decoder import (
+    decode_backend_configuration,
+    decode_backend_properties,
+    decode_pulse_defaults
+)
+from qiskit.test.mock.utils.backend_converter import (
+    convert_to_target,
+    qubit_props_dict_from_props
+)
 from qiskit.utils import optionals as _optionals
 from qiskit.providers import basicaer
 
@@ -256,3 +278,206 @@ def run_job():
             out_job = fake_job.FakeLegacyJob(self, job_id, run_job)
             out_job.submit()
         return out_job
+
+class FakeBackendV2(BackendV2):
+    """This is a dummy bakend just for resting purposes. the FakeBackendV2 builds on top of the BackendV2 base class."""
+
+    def __init__(self):
+        self._configuration = self._get_conf_from_json()
+        super().__init__(
+            provider=None,
+            name=self._configuration.backend_name,
+            description=self._configuration.description,
+            online_date=self._configuration.online_date,
+            backend_version=self._configuration.backend_version
+        )
+        self._properties = None
+        self._qubit_properties = None
+        self._defaults = None
+        self._target = None
+
+    def properties(self):
+        """Returns a snapshot of device properties"""
+        if not self._properties:
+            self._set_props_from_json()
+        return self._properties
+
+    def defaults(self):
+        """Returns a snapshot of device defaults"""
+        if not self._defaults:
+            self._set_defaults_from_json()
+        return self._defaults
+
+    def _get_conf_from_json(self):
+        if not self.conf_filename:
+            raise QiskitError("No configuration file has been defined")
+        conf = self._load_json(self.conf_filename)
+        decode_backend_configuration(conf)
+        configuration = self._get_config_from_dict(conf)
+        configuration.backend_name = self.backend_name
+        return configuration
+
+    def _get_config_from_dict(self, conf):
+        return PulseBackendConfiguration.from_dict(conf)
+
+    def _set_props_from_json(self):
+        if not self.props_filename:
+            raise QiskitError("No properties file has been defined")
+        props = self._load_json(self.props_filename)
+        decode_backend_properties(props)
+        self._properties = BackendProperties.from_dict(props)
+
+    def _set_defaults_from_json(self):
+        if not self.props_filename:
+            raise QiskitError("No properties file has been defined")
+        defs = self._load_json(self.defs_filename)
+        decode_pulse_defaults(defs)
+        self._defaults = PulseDefaults.from_dict(defs)
+
+    def _load_json(self, filename):
+        with open(os.path.join(self.dirname, filename)) as f_json:
+            the_json = json.load(f_json)
+        return the_json
+
+    @property
+    def dtm(self) -> float:
+        """Return the system time resolution of output signals
+        Returns:
+            dtm: The output signal timestep in seconds.
+        """
+        return self._configuration.dtm
+
+    @property
+    def meas_map(self) -> List[List[int]]:
+        """Return the grouping of measurements which are multiplexed
+        This is required to be implemented if the backend supports Pulse
+        scheduling.
+        Returns:
+            meas_map: The grouping of measurements which are multiplexed
+        """
+        return self._configuration.meas_map
+
+    def qubit_properties(
+        self, qubit: Union[int, List[int]]
+    ) -> Union[QubitProperties, List[QubitProperties]]:
+        """Return QubitProperties for a given qubit.
+        Args:
+            qubit: The qubit to get the
+                :class:`~qiskit.provider.QubitProperties` object for. This can
+                be a single integer for 1 qubit or a list of qubits and a list
+                of :class:`~qiskit.provider.QubitProperties` objects will be
+                returned in the same order
+        """
+        if not self._qubit_properties:
+            self._qubit_properties = qubit_props_dict_from_props(self._properties)
+        if isinstance(qubit, int):  # type: ignore[unreachable]
+            return self._qubit_properties.get(qubit)
+        if isinstance(qubit, List):
+            return [self._qubit_properties.get(q) for q in qubit]
+        return None
+
+    @property
+    def target(self) -> Target:
+        self._convert_to_target()
+        return self._target
+
+    def _convert_to_target(self) -> None:
+        """Converts backend configuration, properties and defaults to Target object"""
+        if not self._target:
+            self._target = convert_to_target(
+                configuration=self._configuration,
+                properties=self._properties,
+                defaults=self._defaults,
+            )
+
+    @property
+    def max_circuits(self):
+        return None
+
+    @classmethod
+    def _default_options(cls):
+        if _optionals.HAS_AER:
+            from qiskit.providers import aer
+
+            return aer.QasmSimulator._default_options()
+        else:
+            return basicaer.QasmSimulatorPy._default_options()
+
+    def run(self, run_input, **kwargs):
+        """Main job in simulator"""
+        circuits = run_input
+        pulse_job = None
+        if isinstance(circuits, (pulse.Schedule, pulse.ScheduleBlock)):
+            pulse_job = True
+        elif isinstance(circuits, circuit.QuantumCircuit):
+            pulse_job = False
+        elif isinstance(circuits, list):
+            if circuits:
+                if all(isinstance(x, (pulse.Schedule, pulse.ScheduleBlock)) for x in circuits):
+                    pulse_job = True
+                elif all(isinstance(x, circuit.QuantumCircuit) for x in circuits):
+                    pulse_job = False
+        if pulse_job is None:
+            raise QiskitError(
+                "Invalid input object %s, must be either a "
+                "QuantumCircuit, Schedule, or a list of either" % circuits
+            )
+        if _optionals.HAS_AER:
+            from qiskit.providers import aer
+
+            if pulse_job:
+                from qiskit.providers.aer.pulse import PulseSystemModel
+
+                system_model = PulseSystemModel.from_backend(self)
+                sim = aer.Aer.get_backend("pulse_simulator")
+                job = sim.run(circuits, system_model=system_model, **kwargs)
+            else:
+                sim = aer.Aer.get_backend("qasm_simulator")
+                if self.properties():
+                    from qiskit.providers.aer.noise import NoiseModel
+
+                    noise_model = NoiseModel.from_backend(self, warnings=False)
+                    job = sim.run(circuits, noise_model=noise_model, **kwargs)
+                else:
+                    job = sim.run(circuits, **kwargs)
+        else:
+            if pulse_job:
+                raise QiskitError("Unable to run pulse schedules without qiskit-aer installed")
+            warnings.warn("Aer not found using BasicAer and no noise", RuntimeWarning)
+            sim = basicaer.BasicAer.get_backend("qasm_simulator")
+            job = sim.run(circuits, **kwargs)
+        return job
+
+    def drive_channel(self, qubit: int) -> DriveChannel:
+        """Return the drive channel for the given qubit.
+        Returns:
+            DriveChannel: The Qubit drive channel
+        """
+        return self._configuration.drive(qubit=qubit)
+
+    def measure_channel(self, qubit: int) -> MeasureChannel:
+        """Return the measure stimulus channel for the given qubit.
+        Returns:
+            MeasureChannel: The Qubit measurement stimulus line
+        """
+        return self._configuration.measure(qubit=qubit)
+
+    def acquire_channel(self, qubit: int) -> AcquireChannel:
+        """Return the acquisition channel for the given qubit.
+        Returns:
+            AcquireChannel: The Qubit measurement acquisition line.
+        """
+        return self._configuration.acquire(qubit=qubit)
+
+    def control_channel(self, qubits: Iterable[int]) -> List[ControlChannel]:
+        """Return the secondary drive channel for the given qubit
+        This is typically utilized for controlling multiqubit interactions.
+        This channel is derived from other channels.
+        Args:
+            qubits: Tuple or list of qubits of the form
+                ``(control_qubit, target_qubit)``.
+        Returns:
+            List[ControlChannel]: The Qubit measurement acquisition line.
+        """
+        return self._configuration.control(qubits=qubits)
+

qiskit/test/mock/fake_provider.py

@@ -199,3 +199,73 @@ def __init__(self):
         ]
 
         super().__init__()
+
+class FakeProviderV2(ProviderV1):
+    """Dummy provider just for testing purposes.
+
+    Only filtering backends by name is implemented.
+    This class contains fake V2 backends
+    """
+
+    def get_backend(self, name=None, **kwargs):
+        backend = self._backends[0]
+        if name:
+            filtered_backends = [backend for backend in self._backends if backend.name() == name]
+            if not filtered_backends:
+                raise QiskitBackendNotFoundError()
+
+            backend = filtered_backends[0]
+
+        return backend
+
+    def backends(self, name=None, **kwargs):
+        return self._backends
+
+    def __init__(self):
+        self._backends = [
+            # FakeAlmaden(),
+            # FakeArmonk(),
+            # FakeAthens(),
+            # FakeBelem(),
+            # FakeBoeblingen(),
+            # FakeBogota(),
+            # FakeBrooklyn(),
+            # FakeBurlington(),
+            # FakeCambridge(),
+            # FakeCambridgeAlternativeBasis(),
+            # FakeCasablanca(),
+            # FakeEssex(),
+            # FakeGuadalupe(),
+            FakeJakartaV2(),
+            # FakeJohannesburg(),
+            # FakeLagos(),
+            # FakeLima(),
+            # FakeLondon(),
+            # FakeManila(),
+            # FakeManhattan(),
+            # FakeMelbourne(),
+            # FakeMontreal(),
+            # FakeMumbai(),
+            # FakeOpenPulse2Q(),
+            # FakeOpenPulse3Q(),
+            # FakeOurense(),
+            # FakeParis(),
+            # FakePoughkeepsie(),
+            # FakeQasmSimulator(),
+            # FakeQuito(),
+            # FakeRochester(),
+            # FakeRome(),
+            # FakeRueschlikon(),
+            # FakeSantiago(),
+            # FakeSingapore(),
+            # FakeSydney(),
+            # FakeTenerife(),
+            # FakeTokyo(),
+            # FakeToronto(),
+            # FakeValencia(),
+            # FakeVigo(),
+            # FakeYorktown(),
+        ]
+
+        super().__init__()
+

qiskit/test/mock/fake_qasm_backend.py

@@ -18,7 +18,7 @@
 import os
 
 from qiskit.providers.models import BackendProperties, QasmBackendConfiguration
-from qiskit.test.mock.fake_backend import FakeBackend, FakeLegacyBackend
+from qiskit.test.mock.fake_backend import FakeBackend, FakeBackendV2, FakeLegacyBackend
 from qiskit.test.mock.utils.json_decoder import (
     decode_backend_configuration,
     decode_backend_properties,

qiskit/test/mock/utils/__init__.py

@@ -14,4 +14,4 @@
 Utils for test backends.
 """
 
-from .configurable_backend import ConfigurableFakeBackend
+# from .configurable_backend import ConfigurableFakeBackend