qiskit 1.4.1__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/providers/__init__.py

@@ -21,7 +21,7 @@ This module contains the classes used to build external providers for Qiskit. A
 provider is anything that provides an external service to Qiskit. The typical
 example of this is a Backend provider which provides
 :class:`~qiskit.providers.Backend` objects which can be used for executing
-:class:`~qiskit.circuit.QuantumCircuit` and/or :class:`~qiskit.pulse.Schedule`
+:class:`~qiskit.circuit.QuantumCircuit`
 objects. This module contains the abstract classes which are used to define the
 interface between a provider and Qiskit.
 
@@ -75,15 +75,6 @@ mandatory/the minimum version).
 Abstract Classes
 ================
 
-Provider
---------
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   Provider
-   ProviderV1
-
 Backend
 -------
 
@@ -91,11 +82,8 @@ Backend
    :toctree: ../stubs/
 
    Backend
-   BackendV1
    BackendV2
    QubitProperties
-   BackendV2Converter
-   convert_to_target
 
 Options
 -------
@@ -126,10 +114,8 @@ Exceptions
 ----------
 
 .. autoexception:: QiskitBackendNotFoundError
-.. autoexception:: BackendPropertyError
 .. autoexception:: JobError
 .. autoexception:: JobTimeoutError
-.. autoexception:: BackendConfigurationError
 
 Writing a New Backend
 =====================
@@ -142,8 +128,7 @@ method to get available :class:`~qiskit.providers.BackendV2` objects. The
 a backend and its operation for the :mod:`~qiskit.transpiler` so that circuits
 can be compiled to something that is optimized and can execute on the
 backend. It also provides the :meth:`~qiskit.providers.BackendV2.run` method which can
-run the :class:`~qiskit.circuit.QuantumCircuit` objects and/or
-:class:`~qiskit.pulse.Schedule` objects. This enables users and other Qiskit
+run the :class:`~qiskit.circuit.QuantumCircuit` objects. This enables users and other Qiskit
 APIs to get results from
 executing circuits on devices in a standard
 fashion regardless of how the backend is implemented. At a high level the basic
@@ -568,7 +553,7 @@ which will block until the execution is complete and then will return a
 For some backends (mainly local simulators) the execution of circuits is a
 synchronous operation and there is no need to return a handle to a running job
 elsewhere. For sync jobs its expected that the
-:obj:`~qiskit.providers.BackendV1.run` method on the backend will block until a
+:obj:`~qiskit.providers.BackendV2.run` method on the backend will block until a
 :class:`~qiskit.result.Result` object is generated and the sync job will return
 with that inner :class:`~qiskit.result.Result` object.
 
@@ -612,7 +597,6 @@ An example job class for an async API based backend would look something like::
                 'backend_name': self._backend.configuration().backend_name,
                 'backend_version': self._backend.configuration().backend_version,
                 'job_id': self._job_id,
-                'qobj_id': ', '.join(x.name for x in self.circuits),
                 'success': True,
             })
 
@@ -672,123 +656,15 @@ quasi-probabilities directly from mthree in the result. Doing this would
 enable algorithms to get the best results with
 mitigation applied directly from your backends. You can refer to the
 documentation in :mod:`qiskit.primitives` on how to write custom
-implementations. Also the built-in implementations: :class:`~.Sampler`,
+implementations. Also, the built-in implementations: :class:`~.Sampler`,
 :class:`~.Estimator`, :class:`~.BackendSampler`, and :class:`~.BackendEstimator`
 can serve as references/models on how to implement these as well.
-
-Migrating from BackendV1 to BackendV2
-=====================================
-
-The :obj:`~BackendV2` class re-defined user access for most properties of a
-backend to make them work with native Qiskit data structures and have flatter
-access patterns. However this means when using a provider that upgrades
-from :obj:`~BackendV1` to :obj:`~BackendV2` existing access patterns will need
-to be adjusted. It is expected for existing providers to deprecate the old
-access where possible to provide a graceful migration, but eventually users
-will need to adjust code. The biggest change to adapt to in :obj:`~BackendV2` is
-that most of the information accessible about a backend is contained in its
-:class:`~qiskit.transpiler.Target` object and the backend's attributes often query
-its :attr:`~qiskit.providers.BackendV2.target`
-attribute to return information, however in many cases the attributes only provide
-a subset of information the target can contain. For example, ``backend.coupling_map``
-returns a :class:`~qiskit.transpiler.CouplingMap` constructed from the
-:class:`~qiskit.transpiler.Target` accessible in the
-:attr:`~qiskit.providers.BackendV2.target` attribute, however the target may contain
-instructions that operate on more than two qubits (which can't be represented in a
-:class:`~qiskit.transpiler.CouplingMap`) or has instructions that only operate on
-a subset of qubits (or two qubit links for a two qubit instruction) which won't be
-detailed in the full coupling map returned by
-:attr:`~qiskit.providers.BackendV2.coupling_map`. So depending on your use case
-it might be necessary to look deeper than just the equivalent access with
-:obj:`~BackendV2`.
-
-Below is a table of example access patterns in :obj:`~BackendV1` and the new form
-with :obj:`~BackendV2`:
-
-.. list-table:: Migrate from :obj:`~BackendV1` to :obj:`~BackendV2`
-   :header-rows: 1
-
-   * - :obj:`~BackendV1`
-     - :obj:`~BackendV2`
-     - Notes
-   * - ``backend.configuration().n_qubits``
-     - ``backend.num_qubits``
-     -
-   * - ``backend.configuration().coupling_map``
-     - ``backend.coupling_map``
-     - The return from :obj:`~BackendV2` is a :class:`~qiskit.transpiler.CouplingMap` object.
-       while in :obj:`~BackendV1` it is an edge list. Also this is just a view of
-       the information contained in ``backend.target`` which may only be a subset of the
-       information contained in :class:`~qiskit.transpiler.Target` object.
-   * - ``backend.configuration().backend_name``
-     - ``backend.name``
-     -
-   * - ``backend.configuration().backend_version``
-     - ``backend.backend_version``
-     - The :attr:`~qiskit.providers.BackendV2.version` attribute represents
-       the version of the abstract :class:`~qiskit.providers.Backend` interface
-       the object implements while :attr:`~qiskit.providers.BackendV2.backend_version`
-       is metadata about the version of the backend itself.
-   * - ``backend.configuration().basis_gates``
-     - ``backend.operation_names``
-     - The :obj:`~BackendV2` return is a list of operation names contained in the
-       ``backend.target`` attribute. The :class:`~qiskit.transpiler.Target` may contain more
-       information that can be expressed by this list of names. For example, that some
-       operations only work on a subset of qubits or that some names implement the same gate
-       with different parameters.
-   * - ``backend.configuration().dt``
-     - ``backend.dt``
-     -
-   * - ``backend.configuration().dtm``
-     - ``backend.dtm``
-     -
-   * - ``backend.configuration().max_experiments``
-     - ``backend.max_circuits``
-     -
-   * - ``backend.configuration().online_date``
-     - ``backend.online_date``
-     -
-   * - ``InstructionDurations.from_backend(backend)``
-     - ``backend.instruction_durations``
-     -
-   * - ``backend.defaults().instruction_schedule_map``
-     - ``backend.instruction_schedule_map``
-     -
-   * - ``backend.properties().t1(0)``
-     - ``backend.qubit_properties(0).t1``
-     -
-   * - ``backend.properties().t2(0)``
-     - ``backend.qubit_properties(0).t2``
-     -
-   * - ``backend.properties().frequency(0)``
-     - ``backend.qubit_properties(0).frequency``
-     -
-   * - ``backend.properties().readout_error(0)``
-     - ``backend.target["measure"][(0,)].error``
-     - In :obj:`~BackendV2` the error rate for the :class:`~qiskit.circuit.library.Measure`
-       operation on a given qubit is used to model the readout error. However a
-       :obj:`~BackendV2` can implement multiple measurement types and list them
-       separately in a :class:`~qiskit.transpiler.Target`.
-   * - ``backend.properties().readout_length(0)``
-     - ``backend.target["measure"][(0,)].duration``
-     - In :obj:`~BackendV2` the duration for the :class:`~qiskit.circuit.library.Measure`
-       operation on a given qubit is used to model the readout length. However, a
-       :obj:`~BackendV2` can implement multiple measurement types and list them
-       separately in a :class:`~qiskit.transpiler.Target`.
-
-There is also a :class:`~.BackendV2Converter` class available that enables you
-to wrap a :class:`~.BackendV1` object with a :class:`~.BackendV2` interface.
 """
 
 # Providers interface
-from qiskit.providers.provider import Provider
-from qiskit.providers.provider import ProviderV1
 from qiskit.providers.backend import Backend
-from qiskit.providers.backend import BackendV1
 from qiskit.providers.backend import BackendV2
 from qiskit.providers.backend import QubitProperties
-from qiskit.providers.backend_compat import BackendV2Converter
-from qiskit.providers.backend_compat import convert_to_target
 from qiskit.providers.options import Options
 from qiskit.providers.job import Job
 from qiskit.providers.job import JobV1
@@ -797,7 +673,5 @@ from qiskit.providers.exceptions import (
     JobError,
     JobTimeoutError,
     QiskitBackendNotFoundError,
-    BackendPropertyError,
-    BackendConfigurationError,
 )
 from qiskit.providers.jobstatus import JobStatus

qiskit/providers/backend.py

@@ -18,13 +18,9 @@
 from abc import ABC
 from abc import abstractmethod
 import datetime
-from typing import List, Union, Iterable, Tuple
+from typing import List, Union, 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
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
 class Backend:
@@ -39,213 +35,6 @@ class Backend:
     version = 0
 
 
-class BackendV1(Backend, ABC):
-    """Abstract class for Backends
-
-    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
-    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
-    ``shots`` field for a backend that runs experiments which would contain an
-    int for how many shots to execute. The ``properties`` attribute is
-    optionally defined :class:`~qiskit.providers.models.BackendProperties`
-    object and is used to return measured properties, or properties
-    of a backend that may change over time. The simplest example of this would
-    be a version string, which will change as a backend is updated, but also
-    could be something like noise parameters for backends that run experiments.
-
-    This first version of the Backend abstract class is written to be mostly
-    backwards compatible with the legacy providers interface. This includes reusing
-    the model objects :class:`~qiskit.providers.models.BackendProperties` and
-    :class:`~qiskit.providers.models.BackendConfiguration`. This was done to
-    ease the transition for users and provider maintainers to the new versioned providers.
-    Expect, future versions of this abstract class to change the data model and
-    interface.
-
-    Subclasses of this should override the public method :meth:`run` and the internal
-    :meth:`_default_options`:
-
-    .. automethod:: _default_options
-    """
-
-    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
-
-        Args:
-            configuration (BackendConfiguration): A backend configuration
-                object for the backend object.
-            provider (qiskit.providers.Provider): Optionally, the provider
-                object that this Backend comes from.
-            fields: kwargs for the values to use to override the default
-                options.
-        Raises:
-            AttributeError: if input field not a valid options
-
-        ..
-            This next bit is necessary just because autosummary generally won't summarise private
-            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
-        self._options = self._default_options()
-        self._provider = provider
-        if fields:
-            for field in fields:
-                if field not in self._options.data:
-                    raise AttributeError(f"Options field {field} is not valid for this backend")
-            self._options.update_config(**fields)
-
-    @classmethod
-    @abstractmethod
-    def _default_options(cls):
-        """Return the default options
-
-        This method will return a :class:`qiskit.providers.Options`
-        subclass object that will be used for the default options. These
-        should be the default parameters to use for the options of the
-        backend.
-
-        Returns:
-            qiskit.providers.Options: A options object with
-                default values set
-        """
-
-    def set_options(self, **fields):
-        """Set the options fields for the backend
-
-        This method is used to update the options of a backend. If
-        you need to change any of the options prior to running just
-        pass in the kwarg with the new value for the options.
-
-        Args:
-            fields: The fields to update the options
-
-        Raises:
-            AttributeError: If the field passed in is not part of the
-                options
-        """
-        for field in fields:
-            if not hasattr(self._options, field):
-                raise AttributeError(f"Options field {field} is not valid for this backend")
-        self._options.update_options(**fields)
-
-    def configuration(self):
-        """Return the backend configuration.
-
-        Returns:
-            BackendConfiguration: the configuration for the backend.
-        """
-        return self._configuration
-
-    def properties(self):
-        """Return the backend properties.
-
-        Returns:
-            BackendProperties: the configuration for the backend. If the backend
-            does not support properties, it returns ``None``.
-        """
-        return None
-
-    def provider(self):
-        """Return the backend Provider.
-
-        Returns:
-            Provider: the Provider responsible for the backend.
-        """
-        return self._provider
-
-    def status(self):
-        """Return the backend status.
-
-        Returns:
-            BackendStatus: the status of the backend.
-        """
-        return BackendStatus(
-            backend_name=self.name(),
-            backend_version="1",
-            operational=True,
-            pending_jobs=0,
-            status_msg="",
-        )
-
-    def name(self):
-        """Return the backend name.
-
-        Returns:
-            str: the name of the backend.
-        """
-        return self._configuration.backend_name
-
-    def __str__(self):
-        return self.name()
-
-    def __repr__(self):
-        """Official string representation of a Backend.
-
-        Note that, by Qiskit convention, it is consciously *not* a fully valid
-        Python expression. Subclasses should provide 'a string of the form
-        <...some useful description...>'. [0]
-
-        [0] https://docs.python.org/3/reference/datamodel.html#object.__repr__
-        """
-        return f"<{self.__class__.__name__}('{self.name()}')>"
-
-    @property
-    def options(self):
-        """Return the options for the backend
-
-        The options of a backend are the dynamic parameters defining
-        how the backend is used. These are used to control the :meth:`run`
-        method.
-        """
-        return self._options
-
-    @abstractmethod
-    def run(self, run_input, **options):
-        """Run on the backend.
-
-        This method returns a :class:`~qiskit.providers.Job` object
-        that runs circuits. Depending on the backend this may be either an async
-        or sync call. It is at the discretion of the provider to decide whether
-        running should block until the execution is finished or not: the Job
-        class can handle either situation.
-
-        Args:
-            run_input (QuantumCircuit or Schedule or list): An individual or a
-                list of :class:`~qiskit.circuit.QuantumCircuit` or
-                :class:`~qiskit.pulse.Schedule` objects to run on the backend.
-                For legacy providers migrating to the new versioned providers,
-                provider interface a :class:`~qiskit.qobj.QasmQobj` or
-                :class:`~qiskit.qobj.PulseQobj` objects should probably be
-                supported too (but deprecated) for backwards compatibility. Be
-                sure to update the docstrings of subclasses implementing this
-                method to document that. New provider implementations should not
-                do this though as :mod:`qiskit.qobj` will be deprecated and
-                removed along with the legacy providers interface.
-            options: Any kwarg options to pass to the backend for running the
-                config. If a key is also present in the options
-                attribute/object then the expectation is that the value
-                specified will be used instead of what's set in the options
-                object.
-        Returns:
-            Job: The job object for the run
-        """
-        pass
-
-
 class QubitProperties:
     """A representation of the properties of a qubit on a backend.
 
@@ -290,13 +79,6 @@ class BackendV2(Backend, ABC):
     something like a ``shots`` field for a backend that runs experiments which
     would contain an int for how many shots to execute.
 
-    If migrating a provider from :class:`~qiskit.providers.BackendV1`
-    one thing to keep in mind is for
-    backwards compatibility you might need to add a configuration method that
-    will build a :class:`~qiskit.providers.models.BackendConfiguration` object
-    and :class:`~qiskit.providers.models.BackendProperties` from the attributes
-    defined in this class for backwards compatibility.
-
     A backend object can optionally contain methods named
     ``get_translation_stage_plugin`` and ``get_scheduling_stage_plugin``. If these
     methods are present on a backend object and this object is used for
@@ -327,7 +109,7 @@ class BackendV2(Backend, ABC):
 
     def __init__(
         self,
-        provider: Provider = None,
+        provider=None,
         name: str = None,
         description: str = None,
         online_date: datetime.datetime = None,
@@ -337,9 +119,8 @@ class BackendV2(Backend, ABC):
         """Initialize a BackendV2 based backend
 
         Args:
-            provider: An optional backwards reference to the
-                :class:`~qiskit.providers.Provider` object that the backend
-                is from
+            provider: An optional backwards reference to the provider
+                object that the backend is from
             name: An optional name for the backend
             description: An optional description of the backend
             online_date: An optional datetime the backend was brought online
@@ -361,9 +142,9 @@ class BackendV2(Backend, ABC):
         self._provider = provider
         if fields:
             for field in fields:
-                if field not in self._options.data:
+                if field not in self._options:
                     raise AttributeError(f"Options field {field} is not valid for this backend")
-            self._options.update_config(**fields)
+            self._options.update_options(**fields)
         self.name = name
         """Name of the backend."""
         self.description = description
@@ -420,7 +201,7 @@ class BackendV2(Backend, ABC):
     @property
     @abstractmethod
     def max_circuits(self):
-        """The maximum number of circuits (or Pulse schedules) that can be
+        """The maximum number of circuits that can be
         run in a single job.
 
         If there is no limit this will return None
@@ -485,18 +266,6 @@ class BackendV2(Backend, ABC):
         """
         raise NotImplementedError
 
-    @property
-    @deprecate_pulse_dependency(is_property=True)
-    def instruction_schedule_map(self):
-        """Return the :class:`~qiskit.pulse.InstructionScheduleMap` for the
-        instructions defined in this backend's target."""
-        return self._instruction_schedule_map
-
-    @property
-    def _instruction_schedule_map(self):
-        """An alternative private path to be used internally to avoid pulse deprecation warnings."""
-        return self.target._get_instruction_schedule_map()
-
     def qubit_properties(
         self, qubit: Union[int, List[int]]
     ) -> Union[QubitProperties, List[QubitProperties]]:
@@ -531,77 +300,6 @@ class BackendV2(Backend, ABC):
             return self.target.qubit_properties[qubit]
         return [self.target.qubit_properties[q] for q in qubit]
 
-    @deprecate_pulse_dependency
-    def drive_channel(self, qubit: int):
-        """Return the drive channel for the given qubit.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Returns:
-            DriveChannel: The Qubit drive channel
-
-        Raises:
-            NotImplementedError: if the backend doesn't support querying the
-                measurement mapping
-        """
-        raise NotImplementedError
-
-    @deprecate_pulse_dependency
-    def measure_channel(self, qubit: int):
-        """Return the measure stimulus channel for the given qubit.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Returns:
-            MeasureChannel: The Qubit measurement stimulus line
-
-        Raises:
-            NotImplementedError: if the backend doesn't support querying the
-                measurement mapping
-        """
-        raise NotImplementedError
-
-    @deprecate_pulse_dependency
-    def acquire_channel(self, qubit: int):
-        """Return the acquisition channel for the given qubit.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Returns:
-            AcquireChannel: The Qubit measurement acquisition line.
-
-        Raises:
-            NotImplementedError: if the backend doesn't support querying the
-                measurement mapping
-        """
-        raise NotImplementedError
-
-    @deprecate_pulse_dependency
-    def control_channel(self, qubits: Iterable[int]):
-        """Return the secondary drive channel for the given qubit
-
-        This is typically utilized for controlling multiqubit interactions.
-        This channel is derived from other channels.
-
-        This is required to be implemented if the backend supports Pulse
-        scheduling.
-
-        Args:
-            qubits: Tuple or list of qubits of the form
-                ``(control_qubit, target_qubit)``.
-
-        Returns:
-            List[ControlChannel]: The multi qubit control line.
-
-        Raises:
-            NotImplementedError: if the backend doesn't support querying the
-                measurement mapping
-        """
-        raise NotImplementedError
-
     def set_options(self, **fields):
         """Set the options fields for the backend
 
@@ -633,10 +331,10 @@ class BackendV2(Backend, ABC):
 
     @property
     def provider(self):
-        """Return the backend Provider.
+        """Return the backend provider.
 
         Returns:
-            Provider: the Provider responsible for the backend.
+            provider: the provider responsible for the backend.
         """
         return self._provider
 
@@ -651,9 +349,8 @@ class BackendV2(Backend, ABC):
         class can handle either situation.
 
         Args:
-            run_input (QuantumCircuit or Schedule or ScheduleBlock or list): An
-                individual or a list of :class:`.QuantumCircuit`,
-                :class:`~qiskit.pulse.ScheduleBlock`, or :class:`~qiskit.pulse.Schedule` objects to
+            run_input (QuantumCircuit or list): An
+                individual or a list of :class:`.QuantumCircuit` objects to
                 run on the backend.
             options: Any kwarg options to pass to the backend for running the
                 config. If a key is also present in the options

qiskit/providers/basic_provider/__init__.py

@@ -20,7 +20,9 @@ BasicProvider: Python-based Simulators (:mod:`qiskit.providers.basic_provider`)
 A module of Python-based quantum simulators. Simulators can be accessed
 via the `BasicProvider` provider, e.g.:
 
-.. code-block::
+.. plot::
+   :include-source:
+   :nofigs:
 
    from qiskit.providers.basic_provider import BasicProvider
 

qiskit/providers/basic_provider/basic_provider.py

@@ -23,7 +23,6 @@ import logging
 
 from qiskit.exceptions import QiskitError
 from qiskit.providers.backend import Backend
-from qiskit.providers.provider import ProviderV1
 from qiskit.providers.exceptions import QiskitBackendNotFoundError
 from qiskit.providers.providerutils import filter_backends
 
@@ -35,7 +34,7 @@ logger = logging.getLogger(__name__)
 SIMULATORS = [BasicSimulator]
 
 
-class BasicProvider(ProviderV1):
+class BasicProvider:
     """Provider for test simulators."""
 
     def __init__(self) -> None:
@@ -44,12 +43,33 @@ class BasicProvider(ProviderV1):
         # Populate the list of test backends (simulators)
         self._backends = self._verify_backends()
 
-    def get_backend(self, name: str | None = None, **kwargs) -> Backend:
-        return super().get_backend(name=name, **kwargs)
-
-    def backends(
-        self, name: str | None = None, filters: Callable | None = None, **kwargs
-    ) -> list[Backend]:
+    def get_backend(self, name=None, **kwargs):
+        """Return a single backend matching the specified filtering.
+        Args:
+            name (str): name of the backend.
+            **kwargs: dict used for filtering.
+        Returns:
+            Backend: a backend matching the filtering.
+        Raises:
+            QiskitBackendNotFoundError: if no backend could be found or
+                more than one backend matches the filtering criteria.
+        """
+        backends = self.backends(name, **kwargs)
+        if len(backends) > 1:
+            raise QiskitBackendNotFoundError("More than one backend matches the criteria")
+        if not backends:
+            raise QiskitBackendNotFoundError("No backend matches the criteria")
+        return backends[0]
+
+    def backends(self, name: str | None = None, filters: Callable | None = None) -> list[Backend]:
+        """Return a list of backends matching the specified filtering.
+        Args:
+            name: name of the backend.
+            filters: callable for filtering.
+        Returns:
+            list[Backend]: a list of Backends that match the filtering
+                criteria.
+        """
         backends = self._backends.values()
         if name:
             available = [
@@ -59,7 +79,7 @@ class BasicProvider(ProviderV1):
                 raise QiskitBackendNotFoundError(
                     f"The '{name}' backend is not installed in your system."
                 )
-        return filter_backends(backends, filters=filters, **kwargs)
+        return filter_backends(backends, filters=filters)
 
     def _verify_backends(self) -> OrderedDict[str, Backend]:
         """