qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0__cp38-abi3-win32.whl

qiskit/providers/backend.py

@@ -23,6 +23,7 @@ from typing import List, Union, Iterable, Tuple
 from qiskit.providers.provider import Provider
 from qiskit.providers.models.backendstatus import BackendStatus
 from qiskit.circuit.gate import Instruction
+from qiskit.utils import deprecate_func
 
 
 class Backend:
@@ -43,7 +44,7 @@ class BackendV1(Backend, ABC):
     This abstract class is to be used for Backend objects.
     There are several classes of information contained in a Backend.
     The first are the attributes of the class itself. These should be used to
-    defined the immutable characteristics of the backend. The ``options``
+    define the immutable characteristics of the backend. The ``options``
     attribute of the backend is used to contain the dynamic user configurable
     options of the backend. It should be used more for runtime options
     that configure how the backend is used. For example, something like a
@@ -71,6 +72,14 @@ class BackendV1(Backend, ABC):
 
     version = 1
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="If the backend only encapsulates a hardware description, "
+        "consider constructing a Target directly. If it is part of a provider "
+        "that gives access to execution, consider using Primitives instead. "
+        "Alternatively, consider moving to BackendV2 (see https://qisk.it/backendV1-to-V2).",
+    )
     def __init__(self, configuration, provider=None, **fields):
         """Initialize a backend class
 
@@ -86,7 +95,7 @@ class BackendV1(Backend, ABC):
 
         ..
             This next bit is necessary just because autosummary generally won't summarise private
-            methods; changing that behaviour would have annoying knock-on effects through all the
+            methods; changing that behavior would have annoying knock-on effects through all the
             rest of the documentation, so instead we just hard-code the automethod directive.
         """
         self._configuration = configuration
@@ -95,7 +104,7 @@ class BackendV1(Backend, ABC):
         if fields:
             for field in fields:
                 if field not in self._options.data:
-                    raise AttributeError("Options field %s is not valid for this backend" % field)
+                    raise AttributeError(f"Options field {field} is not valid for this backend")
             self._options.update_config(**fields)
 
     @classmethod
@@ -129,7 +138,7 @@ class BackendV1(Backend, ABC):
         """
         for field in fields:
             if not hasattr(self._options, field):
-                raise AttributeError("Options field %s is not valid for this backend" % field)
+                raise AttributeError(f"Options field {field} is not valid for this backend")
         self._options.update_options(**fields)
 
     def configuration(self):
@@ -352,7 +361,7 @@ class BackendV2(Backend, ABC):
         if fields:
             for field in fields:
                 if field not in self._options.data:
-                    raise AttributeError("Options field %s is not valid for this backend" % field)
+                    raise AttributeError(f"Options field {field} is not valid for this backend")
             self._options.update_config(**fields)
         self.name = name
         """Name of the backend."""
@@ -598,7 +607,7 @@ class BackendV2(Backend, ABC):
         """
         for field in fields:
             if not hasattr(self._options, field):
-                raise AttributeError("Options field %s is not valid for this backend" % field)
+                raise AttributeError(f"Options field {field} is not valid for this backend")
         self._options.update_options(**fields)
 
     @property

qiskit/providers/backend_compat.py

@@ -390,10 +390,13 @@ class BackendV2Converter(BackendV2):
         self._properties = None
         self._defaults = None
 
-        if hasattr(self._backend, "properties"):
-            self._properties = self._backend.properties()
-        if hasattr(self._backend, "defaults"):
-            self._defaults = self._backend.defaults()
+        with warnings.catch_warnings():
+            # The class QobjExperimentHeader is deprecated
+            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+            if hasattr(self._backend, "properties"):
+                self._properties = self._backend.properties()
+            if hasattr(self._backend, "defaults"):
+                self._defaults = self._backend.defaults()
 
         self._target = None
         self._name_mapping = name_mapping

qiskit/providers/basic_provider/basic_provider_tools.py

@@ -66,7 +66,7 @@ def single_gate_matrix(gate: str, params: list[float] | None = None) -> np.ndarr
     if gate in SINGLE_QUBIT_GATES:
         gc = SINGLE_QUBIT_GATES[gate]
     else:
-        raise QiskitError("Gate is not a valid basis gate for this simulator: %s" % gate)
+        raise QiskitError(f"Gate is not a valid basis gate for this simulator: {gate}")
 
     return gc(*params).to_matrix()
 

qiskit/providers/basic_provider/basic_simulator.py

@@ -43,7 +43,7 @@ from qiskit.circuit.library import UnitaryGate
 from qiskit.circuit.library.standard_gates import get_standard_gate_name_mapping, GlobalPhaseGate
 from qiskit.providers import Provider
 from qiskit.providers.backend import BackendV2
-from qiskit.providers.models import BackendConfiguration
+from qiskit.providers.models.backendconfiguration import BackendConfiguration
 from qiskit.providers.options import Options
 from qiskit.qobj import QasmQobj, QasmQobjConfig, QasmQobjExperiment
 from qiskit.result import Result
@@ -208,7 +208,7 @@ class BasicSimulator(BackendV2):
                 target.add_instruction(UnitaryGate, name="unitary")
             else:
                 raise BasicProviderError(
-                    "Gate is not a valid basis gate for this simulator: %s" % name
+                    f"Gate is not a valid basis gate for this simulator: {name}"
                 )
         return target
 
@@ -236,24 +236,32 @@ class BasicSimulator(BackendV2):
             for name in self.target.operation_names
         ]
 
-        self._configuration = BackendConfiguration(
-            backend_name=self.name,
-            backend_version=self.backend_version,
-            n_qubits=self.num_qubits,
-            basis_gates=self.target.operation_names,
-            gates=gates,
-            local=True,
-            simulator=True,
-            conditional=True,
-            open_pulse=False,
-            memory=True,
-            # This max_shots is used by the assembler, setting it to 0
-            # to maintain the behavior from the previous implementation.
-            # Not related to the actual shots set in the backend options
-            max_shots=0,
-            coupling_map=None,
-            description="A python simulator for quantum experiments",
-        )
+        with warnings.catch_warnings():
+            # TODO Provider models are deprecated
+            #   https://github.com/Qiskit/qiskit/issues/12843
+            warnings.filterwarnings(
+                "ignore",
+                category=DeprecationWarning,
+                message=r".+qiskit\.providers\.models\.backendconfiguration\..+",
+            )
+            self._configuration = BackendConfiguration(
+                backend_name=self.name,
+                backend_version=self.backend_version,
+                n_qubits=self.num_qubits,
+                basis_gates=self.target.operation_names,
+                gates=gates,
+                local=True,
+                simulator=True,
+                conditional=True,
+                open_pulse=False,
+                memory=True,
+                # This max_shots is used by the assembler, setting it to 0
+                # to maintain the behavior from the previous implementation.
+                # Not related to the actual shots set in the backend options
+                max_shots=0,
+                coupling_map=None,
+                description="A python simulator for quantum experiments",
+            )
         return self._configuration
 
     @classmethod
@@ -525,17 +533,17 @@ class BasicSimulator(BackendV2):
                 }
         """
         # TODO: replace assemble with new run flow
-        from qiskit.compiler import assemble
+        from qiskit.compiler.assembler import _assemble
 
         out_options = {}
-        for key in backend_options:
+        for key, value in backend_options.items():
             if not hasattr(self.options, key):
                 warnings.warn(
-                    "Option %s is not used by this backend" % key, UserWarning, stacklevel=2
+                    f"Option {key} is not used by this backend", UserWarning, stacklevel=2
                 )
             else:
-                out_options[key] = backend_options[key]
-        qobj = assemble(run_input, self, **out_options)
+                out_options[key] = value
+        qobj = _assemble(run_input, self, **out_options)
         qobj_options = qobj.config
         self._set_options(qobj_config=qobj_options, backend_options=backend_options)
         job_id = str(uuid.uuid4())

qiskit/providers/fake_provider/fake_backend.py

@@ -23,7 +23,7 @@ from qiskit.providers.models import BackendProperties
 from qiskit.providers import BackendV1
 from qiskit import pulse
 from qiskit.exceptions import QiskitError
-from qiskit.utils import optionals as _optionals
+from qiskit.utils import optionals as _optionals, deprecate_func
 from qiskit.providers import basic_provider
 
 
@@ -39,6 +39,13 @@ class _Credentials:
 class FakeBackend(BackendV1):
     """This is a dummy backend just for testing purposes."""
 
+    @deprecate_func(
+        since="1.2",
+        removal_timeline="in the 2.0 release",
+        additional_msg="Fake backends using BackendV1 are deprecated in favor of "
+        ":class:`.GenericBackendV2`. You can convert BackendV1 to "
+        ":class:`.BackendV2` with :class:`.BackendV2Converter`.",
+    )
     def __init__(self, configuration, time_alive=10):
         """FakeBackend initializer.
 
@@ -143,8 +150,8 @@ class FakeBackend(BackendV1):
                     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
+                f"Invalid input object {circuits}, must be either a "
+                "QuantumCircuit, Schedule, or a list of either"
             )
         if pulse_job:
             raise QiskitError("Pulse simulation is currently not supported for fake backends.")

qiskit/providers/fake_provider/fake_openpulse_2q.py

@@ -14,15 +14,16 @@
 Fake backend supporting OpenPulse.
 """
 import datetime
+import warnings
 
-from qiskit.providers.models import (
+from qiskit.providers.models.backendconfiguration import (
     GateConfig,
     PulseBackendConfiguration,
-    PulseDefaults,
-    Command,
     UchannelLO,
 )
+
 from qiskit.providers.models.backendproperties import Nduv, Gate, BackendProperties
+from qiskit.providers.models.pulsedefaults import PulseDefaults, Command
 from qiskit.qobj import PulseQobjInstruction
 
 from .fake_backend import FakeBackend
@@ -126,152 +127,159 @@ class FakeOpenPulse2Q(FakeBackend):
             description="A fake test backend with pulse defaults",
         )
 
-        self._defaults = PulseDefaults.from_dict(
-            {
-                "qubit_freq_est": [4.9, 5.0],
-                "meas_freq_est": [6.5, 6.6],
-                "buffer": 10,
-                "pulse_library": [
-                    {"name": "x90p_d0", "samples": 2 * [0.1 + 0j]},
-                    {"name": "x90p_d1", "samples": 2 * [0.1 + 0j]},
-                    {"name": "x90m_d0", "samples": 2 * [-0.1 + 0j]},
-                    {"name": "x90m_d1", "samples": 2 * [-0.1 + 0j]},
-                    {"name": "y90p_d0", "samples": 2 * [0.1j]},
-                    {"name": "y90p_d1", "samples": 2 * [0.1j]},
-                    {"name": "xp_d0", "samples": 2 * [0.2 + 0j]},
-                    {"name": "ym_d0", "samples": 2 * [-0.2j]},
-                    {"name": "cr90p_u0", "samples": 9 * [0.1 + 0j]},
-                    {"name": "cr90m_u0", "samples": 9 * [-0.1 + 0j]},
-                    {"name": "measure_m0", "samples": 10 * [0.1 + 0j]},
-                    {"name": "measure_m1", "samples": 10 * [0.1 + 0j]},
-                ],
-                "cmd_def": [
-                    Command.from_dict(
-                        {
-                            "name": "u1",
-                            "qubits": [0],
-                            "sequence": [
-                                PulseQobjInstruction(
-                                    name="fc", ch="d0", t0=0, phase="-P0"
-                                ).to_dict()
-                            ],
-                        }
-                    ).to_dict(),
-                    Command.from_dict(
-                        {
-                            "name": "u1",
-                            "qubits": [1],
-                            "sequence": [
-                                PulseQobjInstruction(
-                                    name="fc", ch="d1", t0=0, phase="-P0"
-                                ).to_dict()
-                            ],
-                        }
-                    ).to_dict(),
-                    Command.from_dict(
-                        {
-                            "name": "u2",
-                            "qubits": [0],
-                            "sequence": [
-                                PulseQobjInstruction(
-                                    name="fc", ch="d0", t0=0, phase="-P1"
-                                ).to_dict(),
-                                PulseQobjInstruction(name="y90p_d0", ch="d0", t0=0).to_dict(),
-                                PulseQobjInstruction(
-                                    name="fc", ch="d0", t0=2, phase="-P0"
-                                ).to_dict(),
-                            ],
-                        }
-                    ).to_dict(),
-                    Command.from_dict(
-                        {
-                            "name": "u2",
-                            "qubits": [1],
-                            "sequence": [
-                                PulseQobjInstruction(
-                                    name="fc", ch="d1", t0=0, phase="-P1"
-                                ).to_dict(),
-                                PulseQobjInstruction(name="y90p_d1", ch="d1", t0=0).to_dict(),
-                                PulseQobjInstruction(
-                                    name="fc", ch="d1", t0=2, phase="-P0"
-                                ).to_dict(),
-                            ],
-                        }
-                    ).to_dict(),
-                    Command.from_dict(
-                        {
-                            "name": "u3",
-                            "qubits": [0],
-                            "sequence": [
-                                PulseQobjInstruction(
-                                    name="fc", ch="d0", t0=0, phase="-P2"
-                                ).to_dict(),
-                                PulseQobjInstruction(name="x90p_d0", ch="d0", t0=0).to_dict(),
-                                PulseQobjInstruction(
-                                    name="fc", ch="d0", t0=2, phase="-P0"
-                                ).to_dict(),
-                                PulseQobjInstruction(name="x90m_d0", ch="d0", t0=2).to_dict(),
-                                PulseQobjInstruction(
-                                    name="fc", ch="d0", t0=4, phase="-P1"
-                                ).to_dict(),
-                            ],
-                        }
-                    ).to_dict(),
-                    Command.from_dict(
-                        {
-                            "name": "u3",
-                            "qubits": [1],
-                            "sequence": [
-                                PulseQobjInstruction(
-                                    name="fc", ch="d1", t0=0, phase="-P2"
-                                ).to_dict(),
-                                PulseQobjInstruction(name="x90p_d1", ch="d1", t0=0).to_dict(),
-                                PulseQobjInstruction(
-                                    name="fc", ch="d1", t0=2, phase="-P0"
-                                ).to_dict(),
-                                PulseQobjInstruction(name="x90m_d1", ch="d1", t0=2).to_dict(),
-                                PulseQobjInstruction(
-                                    name="fc", ch="d1", t0=4, phase="-P1"
-                                ).to_dict(),
-                            ],
-                        }
-                    ).to_dict(),
-                    Command.from_dict(
-                        {
-                            "name": "cx",
-                            "qubits": [0, 1],
-                            "sequence": [
-                                PulseQobjInstruction(
-                                    name="fc", ch="d0", t0=0, phase=1.57
-                                ).to_dict(),
-                                PulseQobjInstruction(name="ym_d0", ch="d0", t0=0).to_dict(),
-                                PulseQobjInstruction(name="xp_d0", ch="d0", t0=11).to_dict(),
-                                PulseQobjInstruction(name="x90p_d1", ch="d1", t0=0).to_dict(),
-                                PulseQobjInstruction(name="cr90p_u0", ch="u0", t0=2).to_dict(),
-                                PulseQobjInstruction(name="cr90m_u0", ch="u0", t0=13).to_dict(),
-                            ],
-                        }
-                    ).to_dict(),
-                    Command.from_dict(
-                        {
-                            "name": "measure",
-                            "qubits": [0, 1],
-                            "sequence": [
-                                PulseQobjInstruction(name="measure_m0", ch="m0", t0=0).to_dict(),
-                                PulseQobjInstruction(name="measure_m1", ch="m1", t0=0).to_dict(),
-                                PulseQobjInstruction(
-                                    name="acquire",
-                                    duration=10,
-                                    t0=0,
-                                    qubits=[0, 1],
-                                    memory_slot=[0, 1],
-                                ).to_dict(),
-                            ],
-                        }
-                    ).to_dict(),
-                ],
-            }
-        )
+        with warnings.catch_warnings():
+            # The class PulseQobjInstruction is deprecated
+            warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit")
+            self._defaults = PulseDefaults.from_dict(
+                {
+                    "qubit_freq_est": [4.9, 5.0],
+                    "meas_freq_est": [6.5, 6.6],
+                    "buffer": 10,
+                    "pulse_library": [
+                        {"name": "x90p_d0", "samples": 2 * [0.1 + 0j]},
+                        {"name": "x90p_d1", "samples": 2 * [0.1 + 0j]},
+                        {"name": "x90m_d0", "samples": 2 * [-0.1 + 0j]},
+                        {"name": "x90m_d1", "samples": 2 * [-0.1 + 0j]},
+                        {"name": "y90p_d0", "samples": 2 * [0.1j]},
+                        {"name": "y90p_d1", "samples": 2 * [0.1j]},
+                        {"name": "xp_d0", "samples": 2 * [0.2 + 0j]},
+                        {"name": "ym_d0", "samples": 2 * [-0.2j]},
+                        {"name": "cr90p_u0", "samples": 9 * [0.1 + 0j]},
+                        {"name": "cr90m_u0", "samples": 9 * [-0.1 + 0j]},
+                        {"name": "measure_m0", "samples": 10 * [0.1 + 0j]},
+                        {"name": "measure_m1", "samples": 10 * [0.1 + 0j]},
+                    ],
+                    "cmd_def": [
+                        Command.from_dict(
+                            {
+                                "name": "u1",
+                                "qubits": [0],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d0", t0=0, phase="-P0"
+                                    ).to_dict()
+                                ],
+                            }
+                        ).to_dict(),
+                        Command.from_dict(
+                            {
+                                "name": "u1",
+                                "qubits": [1],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d1", t0=0, phase="-P0"
+                                    ).to_dict()
+                                ],
+                            }
+                        ).to_dict(),
+                        Command.from_dict(
+                            {
+                                "name": "u2",
+                                "qubits": [0],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d0", t0=0, phase="-P1"
+                                    ).to_dict(),
+                                    PulseQobjInstruction(name="y90p_d0", ch="d0", t0=0).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d0", t0=2, phase="-P0"
+                                    ).to_dict(),
+                                ],
+                            }
+                        ).to_dict(),
+                        Command.from_dict(
+                            {
+                                "name": "u2",
+                                "qubits": [1],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d1", t0=0, phase="-P1"
+                                    ).to_dict(),
+                                    PulseQobjInstruction(name="y90p_d1", ch="d1", t0=0).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d1", t0=2, phase="-P0"
+                                    ).to_dict(),
+                                ],
+                            }
+                        ).to_dict(),
+                        Command.from_dict(
+                            {
+                                "name": "u3",
+                                "qubits": [0],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d0", t0=0, phase="-P2"
+                                    ).to_dict(),
+                                    PulseQobjInstruction(name="x90p_d0", ch="d0", t0=0).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d0", t0=2, phase="-P0"
+                                    ).to_dict(),
+                                    PulseQobjInstruction(name="x90m_d0", ch="d0", t0=2).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d0", t0=4, phase="-P1"
+                                    ).to_dict(),
+                                ],
+                            }
+                        ).to_dict(),
+                        Command.from_dict(
+                            {
+                                "name": "u3",
+                                "qubits": [1],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d1", t0=0, phase="-P2"
+                                    ).to_dict(),
+                                    PulseQobjInstruction(name="x90p_d1", ch="d1", t0=0).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d1", t0=2, phase="-P0"
+                                    ).to_dict(),
+                                    PulseQobjInstruction(name="x90m_d1", ch="d1", t0=2).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d1", t0=4, phase="-P1"
+                                    ).to_dict(),
+                                ],
+                            }
+                        ).to_dict(),
+                        Command.from_dict(
+                            {
+                                "name": "cx",
+                                "qubits": [0, 1],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="fc", ch="d0", t0=0, phase=1.57
+                                    ).to_dict(),
+                                    PulseQobjInstruction(name="ym_d0", ch="d0", t0=0).to_dict(),
+                                    PulseQobjInstruction(name="xp_d0", ch="d0", t0=11).to_dict(),
+                                    PulseQobjInstruction(name="x90p_d1", ch="d1", t0=0).to_dict(),
+                                    PulseQobjInstruction(name="cr90p_u0", ch="u0", t0=2).to_dict(),
+                                    PulseQobjInstruction(name="cr90m_u0", ch="u0", t0=13).to_dict(),
+                                ],
+                            }
+                        ).to_dict(),
+                        Command.from_dict(
+                            {
+                                "name": "measure",
+                                "qubits": [0, 1],
+                                "sequence": [
+                                    PulseQobjInstruction(
+                                        name="measure_m0", ch="m0", t0=0
+                                    ).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="measure_m1", ch="m1", t0=0
+                                    ).to_dict(),
+                                    PulseQobjInstruction(
+                                        name="acquire",
+                                        duration=10,
+                                        t0=0,
+                                        qubits=[0, 1],
+                                        memory_slot=[0, 1],
+                                    ).to_dict(),
+                                ],
+                            }
+                        ).to_dict(),
+                    ],
+                }
+            )
 
         mock_time = datetime.datetime.now()
         dt = 1.3333