gPcdZddlmZddlmZddlZddlmZmZmZm Z ddl m Z ddl m Z ddlmZdd lmZdd lmZGd d ZGd deeZGddZGddeeZdS)z)Backend abstract interface for providers.)ABC)abstractmethodN)ListUnionIterableTuple)Provider) BackendStatus) Instruction)deprecate_func)deprecate_pulse_dependencyceZdZdZdZdS)Backenda2Base common type for all versioned Backend abstract classes. Note this class should not be inherited from directly, it is intended to be used for type checking. When implementing a provider you should use the versioned abstract classes as the parent class and not this class directly. rN)__name__ __module__ __qualname____doc__versionN/granary/edev/quantum/lib/python3.11/site-packages/qiskit/providers/backend.pyrrsGGGrrceZdZdZdZedddddZeed Z d Z d Z d Z d Z dZdZdZdZedZedZdS) BackendV1aAbstract 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 z1.2zin the 2.0 releaseaIf 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).)sinceremoval_timelineadditional_msgNc ||_||_||_|r:|D]#}||jjvrt d|d$|jjdi|dSdS)a 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. Options field  is not valid for this backendNr)_configuration_default_options_options _providerdataAttributeError update_config)self configurationproviderfieldsfields r__init__zBackendV1.__init__Ls4,--// !  2 a a 222()_%)_)_)_```3 'DM ' 1 1& 1 1 1 1 1  2 2rcdSazReturn 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 Nrclss rr"zBackendV1._default_optionsosrc |D]*}t|j|std|d+|jjdi|dSaSet 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 rr Nrhasattrr#r&update_optionsr(r+r,s r set_optionszBackendV1.set_options~k ] ]E4=%00 ]$%[e%[%[%[\\\ ]$ $..v.....rc|jS)zReturn the backend configuration. Returns: BackendConfiguration: the configuration for the backend. )r!r(s rr)zBackendV1.configurations ""rcdS)zReturn the backend properties. Returns: BackendProperties: the configuration for the backend. If the backend does not support properties, it returns ``None``. Nrr;s r propertieszBackendV1.propertiess trc|jSzwReturn the backend Provider. Returns: Provider: the Provider responsible for the backend. r$r;s rr*zBackendV1.providers ~rcNt|ddddS)zkReturn the backend status. Returns: BackendStatus: the status of the backend. 1Tr) backend_namebackend_version operational pending_jobs status_msg)r namer;s rstatuszBackendV1.statuss2      rc|jjS)z]Return the backend name. Returns: str: the name of the backend. )r!rDr;s rrIzBackendV1.names "//rc*|SN)rIr;s r__str__zBackendV1.__str__syy{{rcLd|jjd|dS)aNOfficial 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__ ) __class__rrIr;s r__repr__zBackendV1.__repr__s*?4>*>>diikk>>>>rc|jSzReturn 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. r#r;s roptionszBackendV1.options }rc dS)a?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 Nrr( run_inputrVs rrunz BackendV1.runs < rrM)rrrrrr r- classmethodrr"r8r)r=r*rJrIrNrRpropertyrVr[rrrrr*s6>G^-]22226   ^[  ///&###    000 ? ? ?X  ^   rrc$eZdZdZdZddZdZdS)QubitPropertiesaA representation of the properties of a qubit on a backend. This class provides the optional properties that a backend can provide for a qubit. These represent the set of qubit properties that Qiskit can currently work with if present. However if your backend provides additional properties of qubits you should subclass this to add additional custom attributes for those custom/additional properties provided by the backend. t1t2 frequencyNc0||_||_||_dS)zCreate a new :class:`QubitProperties` object. Args: t1: The T1 time for a qubit in seconds t2: The T2 time for a qubit in seconds frequency: The frequency of a qubit in Hz Nr`)r(rarbrcs rr-zQubitProperties.__init__s"rc8d|jd|jd|jdS)NzQubitProperties(t1=z, t2=z , frequency=)r`r;s rrRzQubitProperties.__repr__s)]TW]]47]]DN]]]]r)NNN)rrrr __slots__r-rRrrrr_r_sM*I # # # #^^^^^rr_c neZdZdZdZ d&dedededejdef d Ze d e e e e e ffd Ze d e e fd Ze d e efd Ze edZe d e fdZe dZe dZe edZeedZe d eedffdZe d efdZe d e e e fdZe eddZe dZ dee e e fd ee!e e!ffdZ"ede fdZ#ede fdZ$ede fdZ%ed e&e fd!Z'd"Z(e d#Z)e d$Z*ed%Z+dS)' BackendV2a Abstract class for Backends This abstract class is to be used for all Backend objects created by a provider. This version differs from earlier abstract Backend classes in that the configuration attribute no longer exists. Instead, attributes exposing equivalent required immutable properties of the backend device are added. For example ``backend.configuration().n_qubits`` is accessible from ``backend.num_qubits`` now. 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. 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 :func:`~.transpile` or :func:`~.generate_preset_pass_manager` the transpilation process will default to using the output from those methods as the scheduling stage and the translation compilation stage. This enables a backend which has custom requirements for compilation to specify a stage plugin for these stages to enable custom transformation of the circuit to ensure it is runnable on the backend. These hooks are enabled by default and should only be used to enable extra compilation steps if they are **required** to ensure a circuit is executable on the backend or have the expected level of performance. These methods are passed no input arguments and are expected to return a ``str`` representing the method name which should be a stage plugin (see: :mod:`qiskit.transpiler.preset_passmanagers.plugin` for more details on plugins). The typical expected use case is for a backend provider to implement a stage plugin for ``translation`` or ``scheduling`` that contains the custom compilation passes and then for the hook methods on the backend object to return the plugin name so that :func:`~.transpile` will use it by default when targetting the backend. Subclasses of this should override the public method :meth:`run` and the internal :meth:`_default_options`: .. automethod:: _default_options Nr*rI description online_daterEc ||_||_|r8|D]#}||jjvrt d|d$|jjdi|||_ ||_ ||_ ||_ d|_ dS)a$Initialize a BackendV2 based backend Args: provider: An optional backwards reference to the :class:`~qiskit.providers.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 backend_version: An optional backend version string. This differs from the :attr:`~qiskit.providers.BackendV2.version` attribute as :attr:`~qiskit.providers.BackendV2.version` is for the abstract :attr:`~qiskit.providers.Backend` abstract interface version of the object while ``backend_version`` is for versioning the backend itself. fields: kwargs for the values to use to override the default options. Raises: AttributeError: If a field is specified that's outside the backend's options rr Nr) r"r#r$r%r&r'rIrkrlrE _coupling_map)r(r*rIrkrlrEr+r,s rr-zBackendV2.__init__Hs@--// !  2 a a 222()_%)_)_)_```3 'DM ' 1 1& 1 1 1 "&2&0. "rreturnc|jjS)zRA list of Instruction tuples on the backend of the form ``(instruction, (qubits)``)target instructionsr;s rrrzBackendV2.instructions{s{''rc4t|jjS)zSA list of :class:`~qiskit.circuit.Instruction` instances that the backend supports.)listrq operationsr;s rruzBackendV2.operationssDK*+++rc4t|jjS)z6A list of instruction names that the backend supports.)rtrqoperation_namesr;s rrwzBackendV2.operation_namessDK/000rcdS)z\A :class:`qiskit.transpiler.Target` object for the backend. :rtype: Target Nrr;s rrqzBackendV2.targets  rc|jjS)z,Return the number of qubits the backend has.)rq num_qubitsr;s rrzzBackendV2.num_qubitss{%%rcZ|j|j|_|jS)z9Return the :class:`~qiskit.transpiler.CouplingMap` object)rnrqbuild_coupling_mapr;s r coupling_mapzBackendV2.coupling_maps,   %!%!?!?!A!AD !!rc4|jS)zCReturn the :class:`~qiskit.transpiler.InstructionDurations` object.)rq durationsr;s rinstruction_durationszBackendV2.instruction_durationss{$$&&&rcdS)zThe maximum number of circuits (or Pulse schedules) that can be run in a single job. If there is no limit this will return None Nrr;s r max_circuitszBackendV2.max_circuitss  rcdSr/rr0s rr"zBackendV2._default_optionss  rc|jjS)a*Return the system time resolution of input signals This is required to be implemented if the backend supports Pulse scheduling. Returns: The input signal timestep in seconds. If the backend doesn't define ``dt``, ``None`` will be returned. )rqdtr;s rrz BackendV2.dts{~rct)aReturn the system time resolution of output signals Returns: The output signal timestep in seconds. Raises: NotImplementedError: if the backend doesn't support querying the output signal timestep NotImplementedErrorr;s rdtmz BackendV2.dtms "!rct)asReturn the grouping of measurements which are multiplexed This is required to be implemented if the backend supports Pulse scheduling. Returns: The grouping of measurements which are multiplexed Raises: NotImplementedError: if the backend doesn't support querying the measurement mapping rr;s rmeas_mapzBackendV2.meas_map "!rT) is_propertyc|jS)zwReturn the :class:`~qiskit.pulse.InstructionScheduleMap` for the instructions defined in this backend's target.)_instruction_schedule_mapr;s rinstruction_schedule_mapz"BackendV2.instruction_schedule_maps --rc4|jS)zVAn alternative private path to be used internally to avoid pulse deprecation warnings.)rq_get_instruction_schedule_mapr;s rrz#BackendV2._instruction_schedule_maps{88:::rqubitcjjtt|trjj|Sfd|DS)a_Return QubitProperties for a given qubit. If there are no defined or the backend doesn't support querying these details this method does not need to be implemented. Args: qubit: The qubit to get the :class:`.QubitProperties` object for. This can be a single integer for 1 qubit or a list of qubits and a list of :class:`.QubitProperties` objects will be returned in the same order Returns: The :class:`~.QubitProperties` object for the specified qubit. If a list of qubits is provided a list will be returned. If properties are missing for a qubit this can be ``None``. Raises: NotImplementedError: if the backend doesn't support querying the qubit properties Nc4g|]}jj|Sr)rqqubit_properties).0qr(s r z.BackendV2.qubit_properties..s#???A ,Q/???r)rqrr isinstanceintr(rs` rrzBackendV2.qubit_propertiessR8 ; ' /% % eS ! ! 7;/6 6????????rct)aZReturn 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 rrs r drive_channelzBackendV2.drive_channelrrct)asReturn 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 rrs rmeasure_channelzBackendV2.measure_channel&rrct)arReturn 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 rrs racquire_channelzBackendV2.acquire_channel6rrqubitsct)amReturn 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 r)r(rs rcontrol_channelzBackendV2.control_channelFs *"!rc |D]*}t|j|std|d+|jjdi|dSr3r4r7s rr8zBackendV2.set_options]r9rc|jSrTrUr;s rrVzBackendV2.optionsprWrc|jSr?r@r;s rr*zBackendV2.providerzs ~rc dS)aRun 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 ScheduleBlock or list): An individual or a list of :class:`.QuantumCircuit`, :class:`~qiskit.pulse.ScheduleBlock`, or :class:`~qiskit.pulse.Schedule` 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 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 NrrYs rr[z BackendV2.runs 0 r)NNNNN),rrrrrr strdatetimer-r]rrr rrrrurwrrqrzr}rrr\r"rfloatrrrr rrr_rrrrrrr8rVr*r[rrrriris..`G")-# 1"1"1"1" 1" & 1"  1"1"1"1"f(d5eCj)@#AB(((X(,D-,,,X,1c111X1  ^X &C&&&X&""X" ''X'  ^X    ^[   E%+&   X  "U " " "X " "$tCy/ " " "X "D111..21X. ;;X; @3S >* @ _ 55 6 @ @ @ @D  "3 " " "  "  "S " " "  "  "S " " "  " "hsm""" ",///&XX  ^   rri)rabcrrrtypingrrrrqiskit.providers.providerr %qiskit.providers.models.backendstatusr qiskit.circuit.gater qiskit.utilsr qiskit.utils.deprecate_pulser rrr_rirrrrs0/////////////......??????++++++''''''CCCCCC        L L L L L L L L ^^^^^^^^^8F F F F F F F F F F r