gjdZddlmZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z ddlmZmZmZmZmZmZddlZddlZddlmZddlmZddlmZmZdd l m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)dd l*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ee2e2fZ3 ee!ee3fZ4 GddZ5dJdZ6GddZ7dZ8e/ddde8e5e7 dKdLd2Z9dMd8Z:dNdOd:Z;dPd<ZdSdEZ?dTdIZ@ee5e&fZA ee7e&fZBdS)Ua ========= Schedules ========= .. currentmodule:: qiskit.pulse Schedules are Pulse programs. They describe instruction sequences for the control hardware. The Schedule is one of the most fundamental objects to this pulse-level programming module. A ``Schedule`` is a representation of a *program* in Pulse. Each schedule tracks the time of each instruction occuring in parallel over multiple signal *channels*. .. autosummary:: :toctree: ../stubs/ Schedule ScheduleBlock ) annotationsN)CallableIterable)ListTupleUnionDictAnySequence)ParameterVector) Parameter)ParameterExpressionParameterValueType)Channel) PulseErrorUnassignedReferenceError) Instruction Reference)instruction_duration_validation)ReferenceManager)is_main_process) deprecate_arg)deprecate_pulse_funcceZdZdZdZejZedddd^d Z e d_d`dZ e dadZ e dbdZejdZe dcdZe dddZe dddZe dddZe dedZe dfdZe dgd!Ze dhd#Zdid&Zdid'Zdid(Zdjdkd+Zdldmd/Zd_dnd0Zdod1Z dldpd5Zdqd6Z d_drd7Z! dldsd8Z"ddddd9d:dtdEZ#ddddd9d:dtdFZ$dudHZ%dvdIZ&dwdLZ'dMZ( dxdydNZ)dzdOZ* d{d|dRZ+d}dUZ,dddVZ-d~dXZ.d~dYZ/dodZZ0dd\Z1dad]Z2dS)Schedulea3A quantum program *schedule* with exact time constraints for its instructions, operating over all input signal *channels* and supporting special syntaxes for building. Pulse program representation for the original Qiskit Pulse model [1]. Instructions are not allowed to overlap in time on the same channel. This overlap constraint is immediately evaluated when a new instruction is added to the ``Schedule`` object. It is necessary to specify the absolute start time and duration for each instruction so as to deterministically fix its execution time. The ``Schedule`` program supports some syntax sugar for easier programming. - Appending an instruction to the end of a channel .. code-block:: python from qiskit.pulse import Schedule, Gaussian, DriveChannel, Play sched = Schedule() sched += Play(Gaussian(160, 0.1, 40), DriveChannel(0)) - Appending an instruction shifted in time by a given amount .. code-block:: python sched = Schedule() sched += Play(Gaussian(160, 0.1, 40), DriveChannel(0)) << 30 - Merge two schedules .. code-block:: python sched1 = Schedule() sched1 += Play(Gaussian(160, 0.1, 40), DriveChannel(0)) sched2 = Schedule() sched2 += Play(Gaussian(160, 0.1, 40), DriveChannel(1)) sched2 = sched1 | sched2 A :obj:`.PulseError` is immediately raised when the overlap constraint is violated. In the schedule representation, we cannot parametrize the duration of instructions. Thus, we need to create a new schedule object for each duration. To parametrize an instruction's duration, the :class:`~qiskit.pulse.ScheduleBlock` representation may be used instead. References: [1]: https://arxiv.org/abs/2004.06755 schedNnamemetadata schedules5'ScheduleComponent' | tuple[int, 'ScheduleComponent']r str | Noner dict | Nonecddlm}|e|jtt |jz}t jdkr,ts|dtj j z }||_ ||_ t|ts|t!d|pi|_d|_i|_g|_|D]3} |\}}n#t $rd|}}YnwxYw|||4dS)aCreate an empty schedule. Args: *schedules: Child Schedules of this parent Schedule. May either be passed as the list of schedules, or a list of ``(start_time, schedule)`` pairs. name: Name of this schedule. Defaults to an autogenerated string if not provided. metadata: Arbitrary key value metadata to associate with the schedule. This gets stored as free-form data in a dict in the :attr:`~qiskit.pulse.Schedule.metadata` attribute. It will not be directly used in the schedule. Raises: TypeError: if metadata is not a dict. rParameterManagerNwin32-;Only a dictionary or None is accepted for schedule metadata)qiskit.pulse.parameter_managerr&prefixstrnextinstances_countersysplatformrmpcurrent_processpid_name_parameter_manager isinstancedict TypeError _metadata _duration _timeslots _children_mutable_insert)selfrrr r& sched_pairtimers K/granary/edev/quantum/lib/python3.11/site-packages/qiskit/pulse/schedule.py__init__zSchedule.__init__}s?( DCCCCC <;T$*@%A%A!B!BBD|w&&/@/@&6B.004666 "2"2"4"4(D)) [h.BYZZ Z!R&(@B# . .J ,( ee , , ,e ,  u - - - -  . .s CC$#C$ other_programr return 'Schedule'c |p|j}|jr|j}nd}|||S#t$r*}t |jd|jjd|d}~wwxYw)aCreate new schedule object with metadata of another schedule object. Args: other_program: Qiskit program that provides metadata to new object. name: Name of new schedule. Name of ``schedule`` is used by default. Returns: New schedule object with name and metadata. Raises: PulseError: When `other_program` does not provide necessary information. Nr- cannot be initialized from the program data .)rrcopyAttributeErrorr__name__ __class__)clsrCrrexs rAinitialize_fromzSchedule.initialize_froms -=-D% (166883D8444 4   <77 *3777  s8; A/%A**A/r,c|jS)zName of this Scheduler4r>s rArz Schedule.name zdict[str, Any]c|jSaThe user provided metadata associated with the schedule. User provided ``dict`` of metadata for the schedule. The metadata contents do not affect the semantics of the program but are used to influence the execution of the schedule. It is expected to be passed between all transforms of the schedule and that providers will associate any schedule metadata with the results it returns from the execution of that schedule. r9rRs rArzSchedule.metadata ~rTcdt|ts|td|pi|_dSzUpdate the schedule metadataNr)r6r7r8r9r>rs rArzSchedule.metadata:(D)) [h.BYZZ Z!RrT TimeSlotsc|jS)zTime keeping attribute.r;rRs rA timeslotszSchedule.timeslotss rTintc|jS)zDuration of this schedule.)r:rRs rAdurationzSchedule.durations ~rTc |j|jS)zStarting time of this schedule.) ch_start_timechannelsrRs rA start_timezSchedule.start_times"t!4=11rTc|jS)zStopping time of this schedule.rerRs rA stop_timezSchedule.stop_times }rTtuple[Channel, ...]cNt|jS)z)Returns channels that this schedule uses.)tupler;keysrRs rArhzSchedule.channelss T_))++,,,rT+tuple[tuple[int, 'ScheduleComponent'], ...]c*t|jS)aReturn the child schedule components of this ``Schedule`` in the order they were added to the schedule. Notes: Nested schedules are returned as-is. If you want to collect only instructions, use :py:meth:`~Schedule.instructions` instead. Returns: A tuple, where each element is a two-tuple containing the initial scheduled time of each ``NamedValue`` and the component itself. )ror<rRs rAchildrenzSchedule.childrensT^$$$rT#tuple[tuple[int, Instruction], ...]chd}tt||S),Get the time-ordered instructions from self.cj|d}|d|jtd|jDfS)Nrc3$K|] }|jV dSNr).0chans rA z5Schedule.instructions..key..s$;`;`$DI;`;`;`;`;`;`rT)resortedrh)time_inst_pairinsts rAkeyz"Schedule.instructions..keys;!!$D!!$dmV;`;`RVR_;`;`;`5`5`` `rT)r)ror _instructions)r>rs rA instructionszSchedule.instructions s= a a aVD..00c:::;;;rTset[Parameter]c|jjS)z1Parameters which determine the schedule behavior.)r5 parametersrRs rArzSchedule.parameterss&11rTrhrc|j|SzReturn the time of the end of the last instruction over the supplied channels. Args: *channels: Channels within ``self`` to include. ) ch_stop_timer>rhs rA ch_durationzSchedule.ch_durations !t (++rTcv fd|D}td|DS#t$rYdSwxYw)zReturn the time of the start of the first instruction over the supplied channels. Args: *channels: Channels within ``self`` to include. c3DK|]}|jv j|VdSrzrar|r}r>s rAr~z)Schedule.ch_start_time..)8ddDTXTcLcLcdod3LcLcLcLcddrTc32K|]}|ddVdS)rNr| intervalss rAr~z)Schedule.ch_start_time..*s*GG9y|AGGGGGGrTr)min ValueErrorr>rhchan_intervalss` rArgzSchedule.ch_start_time"s`  dddddddNGGGGGGG G   11  &* 88cv fd|D}td|DS#t$rYdSwxYw)zReturn maximum start time over supplied channels. Args: *channels: Channels within ``self`` to include. c3DK|]}|jv j|VdSrzrars rAr~z(Schedule.ch_stop_time..6rrTc32K|]}|ddVdS)rxNrrs rAr~z(Schedule.ch_stop_time..7s+HHIy}Q'HHHHHHrTr)maxrrs` rArzSchedule.ch_stop_time/s`  dddddddNHHHHHHH H   11 rrr@c#`K|jD]#\}}|||zEd{V$dS)aPIterable for flattening Schedule tree. Args: time: Shifted time due to parent. Yields: Iterable[Tuple[int, Instruction]]: Tuple containing the time each :class:`~qiskit.pulse.Instruction` starts at and the flattened :class:`~qiskit.pulse.Instruction` s. N)rsr)r>r@ insert_time child_scheds rArzSchedule._instructions<sZ)-  E E $K"00 1CDD D D D D D D D D E ErTFinplaceboolc^|r||S|||S)a*Return a schedule shifted forward by ``time``. Args: time: Time to shift by. name: Name of the new schedule. Defaults to the name of self. inplace: Perform operation inplace on this schedule. Otherwise return a new ``Schedule``. r{)_mutable_shift_immutable_shift)r>r@rrs rAshiftzSchedule.shiftJs9  -&&t,, ,$$T$555rTclt||}|||d|S)zReturn a new schedule shifted forward by `time`. Args: time: Time to shift by name: Name of the new schedule if call was mutable. Defaults to name of self Tr)rrOinsert)r>r@r shift_scheds rArzSchedule._immutable_shiftWs:..tT:: 4t444rTc.ttstdi}|jD]\}}fd|D||<t ||jz|_||_fd|jD|_|S)zReturn this schedule shifted forward by `time`. Args: time: Time to shift by Raises: PulseError: if ``time`` is not an integer. 'Schedule start time must be an integer.c<g|]}|dz|dzfSrrxr)r|tsr@s rA z+Schedule._mutable_shift..qs.SSS1 bedl;SSSrTc$g|] \}}|z|f Srr)r| orig_timechildr@s rArz+Schedule._mutable_shift..ws(ZZZ8H 59t+U3ZZZrT) r6rcrr;items_check_nonnegative_timeslotr:rsr<)r>r@rbr} ch_timeslotss ` rArzSchedule._mutable_shiftcs$$$ HFGG G "&/"7"7"9"9 T T D,SSSSlSSSIdOO#I...$.#ZZZZDMZZZ rTrischedule'ScheduleComponent'cb|r|||S||||S)aReturn a new schedule with ``schedule`` inserted into ``self`` at ``start_time``. Args: start_time: Time to insert the schedule. schedule: Schedule to insert. name: Name of the new schedule. Defaults to the name of self. inplace: Perform operation inplace on this schedule. Otherwise return a new ``Schedule``. r{)r=_immutable_insert)r>rirrrs rArzSchedule.insertzs=  >'' H== =%%j(%FFFrTc||||j||f|j||S)zMutably insert `schedule` into `self` at `start_time`. Args: start_time: Time to insert the second schedule. schedule: Schedule to mutably insert. )_add_timeslotsr<appendr5update_parameter_table)r>rirs rAr=zSchedule._mutable_insertsQ J111 z84555 66x@@@ rTct||}|d|||||S)aReturn a new schedule with ``schedule`` inserted into ``self`` at ``start_time``. Args: start_time: Time to insert the schedule. schedule: Schedule to insert. name: Name of the new ``Schedule``. Defaults to name of ``self``. r)rrOr=)r>rirr new_scheds rArzSchedule._immutable_insertsK,,T488 !!!T***!!*h777rTct|jt|jz}|j|}|||||S)a1Return a new schedule with ``schedule`` inserted at the maximum time over all channels shared between ``self`` and ``schedule``. .. math:: t = \textrm{max}(\texttt{x.stop_time} |\texttt{x} \in \texttt{self.channels} \cap \texttt{schedule.channels}) Args: schedule: Schedule to be appended. name: Name of the new ``Schedule``. Defaults to name of ``self``. inplace: Perform operation inplace on this schedule. Otherwise return a new ``Schedule``. )rr)setrhrr)r>rrrcommon_channelsr@s rArzSchedule.appendsL"dm,,s83D/E/EE t /2{{4g{FFFrTT)rhinstruction_types time_rangesrcheck_subroutine filter_funcsrIterable[Channel] | Noner#Iterable[abc.ABCMeta] | abc.ABCMetar Iterable[tuple[int, int]] | NonerIterable[Interval] | Nonercvddlm}m}|||||} | |||| d|S)aReturn a new ``Schedule`` with only the instructions from this ``Schedule`` which pass though the provided filters; i.e. an instruction will be retained iff every function in ``filter_funcs`` returns ``True``, the instruction occurs on a channel type contained in ``channels``, the instruction type is contained in ``instruction_types``, and the period over which the instruction operates is *fully* contained in one specified in ``time_ranges`` or ``intervals``. If no arguments are provided, ``self`` is returned. Args: filter_funcs: A list of Callables which take a (int, Union['Schedule', Instruction]) tuple and return a bool. channels: For example, ``[DriveChannel(0), AcquireChannel(0)]``. instruction_types: For example, ``[PulseInstruction, AcquireInstruction]``. time_ranges: For example, ``[(0, 5), (6, 10)]``. intervals: For example, ``[(0, 5), (6, 10)]``. check_subroutine: Set `True` to individually filter instructions inside of a subroutine defined by the :py:class:`~qiskit.pulse.instructions.Call` instruction. rcomposite_filterfilter_instructionsFfiltersnegaterecurse_subroutinesqiskit.pulse.filtersrrextend r>rhrrrrrrrrs rAfilterzSchedule.filtersj8 ONNNNNNN""8-> YWW|$$$"" '%EU    rTcvddlm}m}|||||} | |||| d|S)aReturn a ``Schedule`` with only the instructions from this Schedule *failing* at least one of the provided filters. This method is the complement of :py:meth:`~Schedule.filter`, so that:: self.filter(args) | self.exclude(args) == self Args: filter_funcs: A list of Callables which take a (int, Union['Schedule', Instruction]) tuple and return a bool. channels: For example, ``[DriveChannel(0), AcquireChannel(0)]``. instruction_types: For example, ``[PulseInstruction, AcquireInstruction]``. time_ranges: For example, ``[(0, 5), (6, 10)]``. intervals: For example, ``[(0, 5), (6, 10)]``. check_subroutine: Set `True` to individually filter instructions inside of a subroutine defined by the :py:class:`~qiskit.pulse.instructions.Call` instruction. rrTrrrs rAexcludezSchedule.excludesj2 ONNNNNNN""8-> YWW|$$$"" '$DT    rTNonectjttjst dt |}t |j|jz|_|j D]r}||j vrFdkr#tj |||j |<nfd||D|j |<Rt||D] \}}|dz|j |ddkr<|j | fd|||dDn |dz|dzf}t|j ||}|j |||#t$rB}t d|jpd d |jpd d d |d |dd|dd |d}~wwxYwtt#|j dS)a;Update all time tracking within this schedule based on the given schedule. Args: time: The time to insert the schedule into self. schedule: The schedule to insert into self. Raises: PulseError: If timeslots overlap or an invalid start time is provided. rrc<g|]}|dz|dzfSrrr|ir@s rArz+Schedule._add_timeslots..s;000781adTk2000rTrrxc<g|]}|dz|dzfSrrrs rArz+Schedule._add_timeslots..%s.\\\!A$+qtd{3\\\rTNzSchedule(name='z*') cannot be inserted into Schedule(name='z ') at time z$ because its instruction on channel z scheduled from time z to z' overlaps with an existing instruction.)np issubdtypetypeintegerr_get_timeslotsrr:rerhr;rI enumerater_find_insertion_indexrrr) r>r@rother_timeslotschannelidxintervalindexrNs ` rArzSchedule._add_timeslotss}T$ZZ44 HFGG G(22T^TH4E-EFF(  Gdo--199/3y9Q/R/RDOG,,0000r@rrchannel_timeslotsrrrs rA_remove_timeslotszSchedule._remove_timeslots7su$$$ HFGG G( - -Gdo-- !X!X!X!XYYY $ 8 ,X66O+G4  $! ( d 2HQK$4FGH+,=xHHE(/8;;)--e444  NXa[NNHQKNN&NN;C=NNN % -##G,,,- - -rToldnewc^||||||dS)a Replace the timeslots of ``old`` if present with the timeslots of ``new``. Args: time: The time to remove the timeslots for the ``schedule`` component. old: Instruction to replace. new: Instruction to replace with. N)rr)r>r@rrs rA_replace_timeslotszSchedule._replace_timeslots\s6 tS))) D#&&&&&rTc~|j|jD]\}}|||dS)z3Regenerate timeslots based on current instructions.N)r;clearrr)r>t0rs rA_renew_timeslotszSchedule._renew_timeslotsgsO ) * *HB   D ) ) ) ) * *rTcddlm}g}|}|jD]d\}}||kr-|||f||8|||f||e|r$||_||_||S t |} |D]\}} | || d| S#t$r} td|d|d| d} ~ wwxYw) a9Return a ``Schedule`` with the ``old`` instruction replaced with a ``new`` instruction. The replacement matching is based on an instruction equality check. .. code-block:: from qiskit import pulse d0 = pulse.DriveChannel(0) sched = pulse.Schedule() old = pulse.Play(pulse.Constant(100, 1.0), d0) new = pulse.Play(pulse.Constant(100, 0.1), d0) sched += old sched = sched.replace(old, new) assert sched == pulse.Schedule(new) Only matches at the top-level of the schedule tree. If you wish to perform this replacement over all instructions in the schedule tree. Flatten the schedule prior to running:: .. code-block:: sched = pulse.Schedule() sched += pulse.Schedule(old) sched = sched.replace(old, new) assert sched == pulse.Schedule(new) Args: old: Instruction to replace. new: Instruction to replace with. inplace: Replace instruction by mutably modifying this ``Schedule``. Returns: The modified schedule with ``old`` replaced by ``new``. Raises: PulseError: If the ``Schedule`` after replacements will has a timing overlap. rr%TrzReplacement of z with z% results in overlapping instructions.N) r*r&rsrrr<r5rrrOrr) r>rrrr& new_childrennew_parametersr@rrrerrs rAreplacezSchedule.replacemsnj DCCCCC ))++= = =KD%||##T3K00055c::::##T5M22255e<<<<  )DN&4D #  ! ! # # #K $44T:: ".??JD$$$T4$>>>>      [c[[[[[ s&;C"" D,DDc4|jSz1Return True iff the instruction is parameterized.)r5is_parameterizedrRs rArzSchedule.is_parameterizeds&77999rT value_dictddict[ParameterExpression | ParameterVector | str, ParameterValueType | Sequence[ParameterValueType]]c|s+tj|}||dS|j||S)aAssign the parameters in this schedule according to the input. Args: value_dict: A mapping from parameters or parameter names (parameter vector or parameter vector name) to either numeric values (list of numeric values) or another parameter expression (list of parameter expressions). inplace: Set ``True`` to override this instance with new parameter. Returns: Schedule with updated parameters. Tr pulse_programr)rIdeepcopyassign_parametersr5)r>rr new_schedules rAr zSchedule.assign_parameterssR& L=..L11*d1KK K&88tXb8cccrTparameter_namelist[Parameter]c6|j|S)afGet parameter object bound to this schedule by string name. Because different ``Parameter`` objects can have the same name, this method returns a list of ``Parameter`` s for the provided name. Args: parameter_name: Name of parameter. Returns: Parameter objects that have corresponding name. )r5get_parameters)r>r s rArzSchedule.get_parameterss&55nEEErTc*t|jSz.Return number of instructions in the schedule.)lenrrRs rA__len__zSchedule.__len__s4$%%%rTotherc,||SzPReturn a new schedule with ``other`` inserted within ``self`` at ``start_time``.rr>rs rA__add__zSchedule.__add__{{5!!!rTc.|d|S)z?Return a new schedule which is the union of `self` and `other`.r)rrs rA__or__zSchedule.__or__s{{1e$$$rTc,||S)z;Return a new schedule which is shifted forward by ``time``.)r)r>r@s rA __lshift__zSchedule.__lshift__szz$rTobjectc`t|t|tfsdSt|jt|jkrdSt |jt |jkrdStdt|j|jDS)aTest if two Schedule are equal. Equality is checked by verifying there is an equal instruction at every time in ``other`` for every instruction in this ``Schedule``. .. warning:: This does not check for logical equivalency. Ie., ```python >>> Delay(10, DriveChannel(0)) + Delay(10, DriveChannel(0)) == Delay(20, DriveChannel(0)) False ``` Fc3(K|] \}}||kVdSrzr)r| self_inst other_insts rAr~z"Schedule.__eq__..s?  % :  #      rT) r6rrrrhrrallziprs rA__eq__zSchedule.__eq__s"%$t**k!:;; 5 t}  U^!4!4 4 45 t ! !S);%<%< < <5  ),T->@R)S)S      rTc|jrt|jnd}dd|jddD}t |jdkr|dz }|jjd|d|d S) Nrrc,g|]}t|Srreprr|instrs rArz%Schedule.__repr__..s!R!R!R%$u++!R!R!RrT2, ...(, name="z"))r4formatjoinrrrLrK)r>rrs rA__repr__zSchedule.__repr__s%)Z7vdj!!!Ryy!R!R4;LSbS;Q!R!R!RSS t ! !B & & G #L.)JJLJJ$JJJJrT)r r!rr"rr#rz)rCr rr"rDrErDr,rDrU)rDr_rDrcrDrm)rDrq)rDrtrDrrhrrDrcr)r@rc)NF)r@rcrr"rrrDrE)r@rcrr"rDrE)r@rcrDrE) rircrrrr"rrrDrE)rircrrrDrE)rircrrrr"rDrE)rrrr"rrrDrE)rrrhrrrrrrrrrrDrE)r@rcrrrDr)r@rcrr)r@rcrrrr)F)rrrrrrrDrErDrT)rrrrrDrEr r,rDr)rrrDrErr rDr)3rK __module__ __qualname____doc__r+ itertoolscountr.rrB classmethodrOpropertyrrsetterrbrerirlrhrsrrrrgrrrrrrr=rrrrrrrrrrr rrrrrr'r5rrTrArrCs11hF( )) $ ,.,.,.,.,.,.\[8X   X _((_( XX222X2X---X- % % %X %<<<X<222X2,,,,         E E E E E 6 6 6 6 6     6  GGGGG(      $W\GGGGG0.2AE8argskwargsrLrIs rAwrapperz-_require_schedule_conversion..wrapper*sA======x))$//A$AAA&AAArT) functoolswraps)rIrPs` rA_require_schedule_conversionrS$s? _XBBBBB NrTc0eZdZdZdZdZejZe dGdHd Z e dIdJdZ e dKdZe dLdZejdZe dZdMdZe edNdZe dOdZe edPdZe dQdZe dRd Ze dSd"ZedTd%Z dUdVd)Zddd&d*dWd1Zddd&d*dWd2Z dXdYd5ZdMd6ZdMd7Z dXdZd:Z! dXd[d=Z"d\d@Z#dNdAZ$d]dDZ%dKdEZ&d^dFZ'dS)_ ScheduleBlocka]Time-ordered sequence of instructions with alignment context. :class:`.ScheduleBlock` supports lazy scheduling of context instructions, i.e. their timeslots is always generated at runtime. This indicates we can parametrize instruction durations as well as other parameters. In contrast to :class:`.Schedule` being somewhat static, :class:`.ScheduleBlock` is a dynamic representation of a pulse program. .. rubric:: Pulse Builder The Qiskit pulse builder is a domain specific language that is developed on top of the schedule block. Use of the builder syntax will improve the workflow of pulse programming. See :ref:`pulse_builder` for a user guide. .. rubric:: Alignment contexts A schedule block is always relatively scheduled. Instead of taking individual instructions with absolute execution time ``t0``, the schedule block defines a context of scheduling and instructions under the same context are scheduled in the same manner (alignment). Several contexts are available in :ref:`pulse_alignments`. A schedule block is instantiated with one of these alignment contexts. The default context is :class:`AlignLeft`, for which all instructions are left-justified, in other words, meaning they use as-soon-as-possible scheduling. If you need an absolute-time interval in between instructions, you can explicitly insert :class:`~qiskit.pulse.instructions.Delay` instructions. .. rubric:: Nested blocks A schedule block can contain other nested blocks with different alignment contexts. This enables advanced scheduling, where a subset of instructions is locally scheduled in a different manner. Note that a :class:`.Schedule` instance cannot be directly added to a schedule block. To add a :class:`.Schedule` instance, wrap it in a :class:`.Call` instruction. This is implicitly performed when a schedule is added through the :ref:`pulse_builder`. .. rubric:: Unsupported operations Because the schedule block representation lacks timeslots, it cannot perform particular :class:`.Schedule` operations such as :meth:`insert` or :meth:`shift` that require instruction start time ``t0``. In addition, :meth:`exclude` and :meth:`filter` methods are not supported because these operations may identify the target instruction with ``t0``. Except for these operations, :class:`.ScheduleBlock` provides full compatibility with :class:`.Schedule`. .. rubric:: Subroutine The timeslots-free representation offers much greater flexibility for writing pulse programs. Because :class:`.ScheduleBlock` only cares about the ordering of the child blocks we can add an undefined pulse sequence as a subroutine of the main program. If your program contains the same sequence multiple times, this representation may reduce the memory footprint required by the program construction. Such a subroutine is realized by the special compiler directive :class:`~qiskit.pulse.instructions.Reference` that is defined by a unique set of reference key strings to the subroutine. The (executable) subroutine is separately stored in the main program. Appended reference directives are resolved when the main program is executed. Subroutines must be assigned through :meth:`assign_references` before execution. One way to reference a subroutine in a schedule is to use the pulse builder's :func:`~qiskit.pulse.builder.reference` function to declare an unassigned reference. In this example, the program is called with the reference key "grand_child". You can call a subroutine without specifying a substantial program. .. code-block:: from qiskit import pulse from qiskit.circuit.parameter import Parameter amp1 = Parameter("amp1") amp2 = Parameter("amp2") with pulse.build() as sched_inner: pulse.play(pulse.Constant(100, amp1), pulse.DriveChannel(0)) with pulse.build() as sched_outer: with pulse.align_right(): pulse.reference("grand_child") pulse.play(pulse.Constant(200, amp2), pulse.DriveChannel(0)) # Now assign the inner pulse program to this reference sched_outer.assign_references({("grand_child",): sched_inner}) print(sched_outer.parameters) .. code-block:: text {Parameter(amp1), Parameter(amp2)} The outer program now has the parameter ``amp2`` from the inner program, indicating that the inner program's data has been made available to the outer program. The program calling the "grand_child" has a reference program description which is accessed through :attr:`ScheduleBlock.references`. .. code-block:: print(sched_outer.references) .. code-block:: text ReferenceManager: - ('grand_child',): ScheduleBlock(Play(Constant(duration=100, amp=amp1,... Finally, you may want to call this program from another program. Here we try a different approach to define subroutine. Namely, we call a subroutine from the root program with the actual program ``sched2``. .. code-block:: amp3 = Parameter("amp3") with pulse.build() as main: pulse.play(pulse.Constant(300, amp3), pulse.DriveChannel(0)) pulse.call(sched_outer, name="child") print(main.parameters) .. code-block:: text {Parameter(amp1), Parameter(amp2), Parameter(amp3} This implicitly creates a reference named "child" within the root program and assigns ``sched_outer`` to it. Note that the root program is only aware of its direct references. .. code-block:: print(main.references) .. code-block:: text ReferenceManager: - ('child',): ScheduleBlock(ScheduleBlock(ScheduleBlock(Play(Con... As you can see the main program cannot directly assign a subroutine to the "grand_child" because this subroutine is not called within the root program, i.e. it is indirectly called by "child". However, the returned :class:`.ReferenceManager` is a dict-like object, and you can still reach to "grand_child" via the "child" program with the following chained dict access. .. code-block:: main.references[("child", )].references[("grand_child", )] Note that :attr:`ScheduleBlock.parameters` still collects all parameters also from the subroutine once it's assigned. )_parentr4_reference_managerr5_alignment_context_blocksr9blockNrr"rr#cddlm}ddlm}|e|jt t |jz}tj dkr,ts|dtj j z }d|_||_||_t#|_|p ||_g|_|j|jt-|t.s|t1d|pi|_dS)aCreate an empty schedule block. Args: name: Name of this schedule. Defaults to an autogenerated string if not provided. metadata: Arbitrary key value metadata to associate with the schedule. This gets stored as free-form data in a dict in the :attr:`~qiskit.pulse.ScheduleBlock.metadata` attribute. It will not be directly used in the schedule. alignment_context (AlignmentKind): ``AlignmentKind`` instance that manages scheduling of instructions in this block. Raises: TypeError: if metadata is not a dict. rr%) AlignLeftNr'r(r))r*r&rMr\r+r,r-r.r/r0rr1r2r3rVr4r5rrWrXrYrr6r7r8r9)r>rralignment_contextr&r\s rArBzScheduleBlock.__init__s$ DCCCCC555555 <;T$*@%A%A!B!BBD|w&&/@/@&6B.004666.2  "2"2"4"4"2"4"4"3"Byy{{/1  66t7NOOO(D)) [h.BYZZ Z!RrTrCr rD'ScheduleBlock'c |p|j}|jr|j}nd} |j}n#t$rd}YnwxYw||||S#t$r*}t |jd|jjd|d}~wwxYw)aCreate new schedule object with metadata of another schedule object. Args: other_program: Qiskit program that provides metadata to new object. name: Name of new schedule. Name of ``block`` is used by default. Returns: New block object with name and metadata. Raises: PulseError: When ``other_program`` does not provide necessary information. N)rrr]rGrH)rrrIr]rJrrKrL)rMrCrrr]rNs rArOzScheduleBlock.initialize_from s -=-D% (16688 )$1$C!!! ) ) )$(!!! )3D8GXYYY Y   <77 *3777  s7,A7A AAAA B !%BB r,c|jS)zReturn name of this schedulerQrRs rArzScheduleBlock.name,rSrTrUc|jSrWrXrRs rArzScheduleBlock.metadata1rYrTcdt|ts|td|pi|_dSr[r\r]s rArzScheduleBlock.metadata>r^rTc|jS)zNReturn alignment instance that allocates block component to generate schedule.)rXrRs rAr]zScheduleBlock.alignment_contextEs &&rTrc"|jjD]}t|trdS|jD]_}t|t r|sdS/ t|jtsdSN#t$rYdSwxYwdS)z.Return ``True`` if all durations are assigned.FT) rX_context_paramsr6rblocksrUis_schedulablerercr)r> context_paramelms rArgzScheduleBlock.is_schedulableJs"4D  M-)<== uu ; ! !C#}-- !))++! 55!!%clC88%$uu%/!!! 555!tsA== B  B rcc|jS)z Duration of this schedule block.rkrRs rArezScheduleBlock.duration^s }rTrmct}|jD]F}t|trt d|jd|t|jz}Gt|S)z/Returns channels that this schedule block uses.z,This schedule contains unassigned reference z@ and channels are ambiguous. Please assign the subroutine first.)rrfr6rrref_keysrhro)r>chansris rArhzScheduleBlock.channelsds"ee; . .C#y)) .V3<VVVC ---EEU||rTtuple[tuple[int, Instruction]]c|jS)rv)rrRs rArzScheduleBlock.instructionsqs   rTtuple['BlockComponent', ...]cg}|jD]N}t|tr"|j|jdp|}||Ot|S)aDGet the block elements added to self. .. note:: The sequence of elements is returned in order of addition. Because the first element is schedule first, e.g. FIFO, the returned sequence is roughly time-ordered. However, in the parallel alignment context, especially in the as-late-as-possible scheduling, or :class:`.AlignRight` context, the actual timing of when the instructions are issued is unknown until the :class:`.ScheduleBlock` is scheduled and converted into a :class:`.Schedule`. N)rYr6r referencesgetrlrro)r>rfris rArfzScheduleBlock.blockswsl<  C#y)) Eo))#,==D MM#    V}}rTrct}||jjz}|jD]}|||jz}|S)z,Return unassigned parameters with raw names.)rr5rrrvalues)r> out_params subroutines rArzScheduleBlock.parameterssXUU d-88 /0022 0 0J! */ /JJrTrc6|j |jjS|jS)z0Return a reference manager of the current scope.)rVrrrWrRs rArrzScheduleBlock.referencess  < #<* *&&rTrhrc|j|Sr)rrs rArzScheduleBlock.ch_durations t**rTT'BlockComponent'rcHt|ttfstd|jjd|s;t j|}|p|j|_ | |d|St|tr|j |j vrd|j |j <nt|trt j|}|r|j7t!|jD]!}|j |j |j |j <"nB|jD]\}}||j |<|j||_|j ||j||S)aNReturn a new schedule block with ``block`` appended to the context block. The execution time is automatically assigned when the block is converted into schedule. Args: block: ScheduleBlock to be appended. name: Name of the new ``Schedule``. Defaults to name of ``self``. inplace: Perform operation inplace on this schedule. Otherwise, return a new ``Schedule``. Returns: Schedule block with appended schedule. Raises: PulseError: When invalid schedule type is specified. zAppended `schedule` zI is invalid type. Only `Instruction` and `ScheduleBlock` can be accepted.TrN)r6rUrrrLrKrIr rr4rrrlrr is_referencedrV_get_referencesrYrWrrr5r)r>rZrrrrefrls rArzScheduleBlock.appends$%-!=>> Ju'?JJJ   }T**H!.TYHN OOE4O 0 0 0O eY ' ' !EN$/,Q,Q.2DOEN + + } - - !M%((E""$$ 5=, /u}==WW8=8H8V 55W */)A)G)G)I)I88 #4711,22444 EM E""" 66u=== rT)rhrrrCallable[..., bool]rrrrcrddlm}m}|||}|||||d|S)aReturn a new ``ScheduleBlock`` with only the instructions from this ``ScheduleBlock`` which pass though the provided filters; i.e. an instruction will be retained if every function in ``filter_funcs`` returns ``True``, the instruction occurs on a channel type contained in ``channels``, and the instruction type is contained in ``instruction_types``. .. warning:: Because ``ScheduleBlock`` is not aware of the execution time of the context instructions, filtering out some instructions may change the execution time of the remaining instructions. If no arguments are provided, ``self`` is returned. Args: filter_funcs: A list of Callables which take a ``Instruction`` and return a bool. channels: For example, ``[DriveChannel(0), AcquireChannel(0)]``. instruction_types: For example, ``[PulseInstruction, AcquireInstruction]``. check_subroutine: Set `True` to individually filter instructions inside a subroutine defined by the :py:class:`~qiskit.pulse.instructions.Call` instruction. Returns: ``ScheduleBlock`` consisting of instructions that matches with filtering condition. rrFrrr>rhrrrrrrs rArzScheduleBlock.filtersf< ONNNNNNN""8->??|$$$"" '%EU    rTcrddlm}m}|||}|||||d|S)aReturn a new ``ScheduleBlock`` with only the instructions from this ``ScheduleBlock`` *failing* at least one of the provided filters. This method is the complement of :py:meth:`~ScheduleBlock.filter`, so that:: self.filter(args) + self.exclude(args) == self in terms of instructions included. .. warning:: Because ``ScheduleBlock`` is not aware of the execution time of the context instructions, excluding some instructions may change the execution time of the remaining instructions. Args: filter_funcs: A list of Callables which take a ``Instruction`` and return a bool. channels: For example, ``[DriveChannel(0), AcquireChannel(0)]``. instruction_types: For example, ``[PulseInstruction, AcquireInstruction]``. check_subroutine: Set `True` to individually filter instructions inside of a subroutine defined by the :py:class:`~qiskit.pulse.instructions.Call` instruction. Returns: ``ScheduleBlock`` consisting of instructions that do not match with at least one of filtering conditions. rrTrrrs rArzScheduleBlock.exclude sf: ONNNNNNN""8->??|$$$"" '$DT    rTrrc|s,tj|}|||dS||jvr|St }t |t rNtj|}||j|j ||_ |j D]5\}}||vr'tjd|d|jdt 0|||<6|j |j|jg}|jD]9} | |kr|} |j| || :||_|j |} | j | j } | j t+| jD]} || j|j| j<|S)aReturn a ``ScheduleBlock`` with the ``old`` component replaced with a ``new`` component. Args: old: Schedule block component to replace. new: Schedule block component to replace with. inplace: Replace instruction by mutably modifying this ``ScheduleBlock``. Returns: The modified schedule block with ``old`` replaced by ``new``. Trz Reference z$ conflicts with substituted program z:. Existing reference has been replaced with new reference.)rIr rrYrr6rUupdaterrrWrrVrwarningswarnr UserWarningr5rrXrr}rl) r>rrrrall_referencesref_keyrwnew_elmsrirootr~s rArzScheduleBlock.replace3s" <}T**H##Cd#;; ; dl " "K*++ c= ) ) -$$C  ! !#. 1 1 1  " ( ( * * *CK#'?#8#8#:#: 1 1 GZ.(( OOOchOOO &0N7 # # %%''' 66t7NOOO< ! !Cczz  # : :3 ? ? ? OOC  l&rrr rws rAr zScheduleBlock.assign_parameterss, L=..L11*d1KK K 11Q[1\\\188:: N NJ!  ( (J ( M M M M rTsubroutine_dict,dict[str | tuple[str, ...], 'ScheduleBlock']c|s+tj|}||dS|D]~\}}||jvrTdt t|j}td|d|tj||j|<|S)a Assign schedules to references. It is only capable of assigning a schedule block to immediate references which are directly referred within the current scope. Let's see following example: .. code-block:: python from qiskit import pulse with pulse.build() as nested_prog: pulse.delay(10, pulse.DriveChannel(0)) with pulse.build() as sub_prog: pulse.reference("A") with pulse.build() as main_prog: pulse.reference("B") In above example, the ``main_prog`` can refer to the subroutine "root::B" and the reference of "B" to program "A", i.e., "B::A", is not defined in the root namespace. This prevents breaking the reference "root::B::A" by the assignment of "root::B". For example, if a user could indirectly assign "root::B::A" from the root program, one can later assign another program to "root::B" that doesn't contain "A" within it. In this situation, a reference "root::B::A" would still live in the reference manager of the root. However, the subroutine "root::B::A" would no longer be used in the actual pulse program. To assign subroutine "A" to ``nested_prog`` as a nested subprogram of ``main_prog``, you must first assign "A" of the ``sub_prog``, and then assign the ``sub_prog`` to the ``main_prog``. .. code-block:: python sub_prog.assign_references({("A", ): nested_prog}, inplace=True) main_prog.assign_references({("B", ): sub_prog}, inplace=True) Alternatively, you can also write .. code-block:: python main_prog.assign_references({("B", ): sub_prog}, inplace=True) main_prog.references[("B", )].assign_references({("A", ): nested_prog}, inplace=True) Here :attr:`.references` returns a dict-like object, and you can mutably update the nested reference of the particular subroutine. .. note:: Assigned programs are deep-copied to prevent an unexpected update. Args: subroutine_dict: A mapping from reference key to schedule block of the subroutine. inplace: Set ``True`` to override this instance with new subroutine. Returns: Schedule block with assigned subroutine. Raises: PulseError: When reference key is not defined in the current scope. TrrzReference instruction with z% doesn't exist in the current scope: ) rIr assign_referencesrrrr4mapr+ unassignedr)r>rrr rrwunassigned_keyss rArzScheduleBlock.assign_referencessB Q=..L11/41PP P.4466 = =OC$/))"&))Cdo6P6P6R6R,S,S"T"T ?#??-<??$(=#<#.s%JJJ>1I1I11I1I1IrT)r)r>r matcheds ` rArzScheduleBlock.get_parameterss&>KJJJdoJJJrTc*t|jSr)rrfrRs rArzScheduleBlock.__len__s4;rTrr ct|t|sdS|j|jkrdSt|t|krdSddlm}t j||||dsdSdS)aTest if two ScheduleBlocks are equal. Equality is checked by verifying there is an equal instruction at every time in ``other`` for every instruction in this ``ScheduleBlock``. This check is performed by converting the instruction representation into directed acyclic graph, in which execution order of every instruction is evaluated correctly across all channels. Also ``self`` and ``other`` should have the same alignment context. .. warning:: This does not check for logical equivalency. Ie., ```python >>> Delay(10, DriveChannel(0)) + Delay(10, DriveChannel(0)) == Delay(20, DriveChannel(0)) False ``` Fr) block_to_dagc||kSrzr)xys rAz&ScheduleBlock.__eq__..>s qTUvrTT)r6rr]rqiskit.pulse.transforms.dagrrxis_isomorphic_node_match)r>rdags rAr'zScheduleBlock.__eq__s(%d,, 5  !U%< < <5 t99E " "5 DCCCCC*33t99cc%jjBUBUVV 5trTc "|jrt|jnd}dd|jddD}t |jdkr|dz }|jjd|d|d t|jd S) Nrrc,g|]}t|Srr*r,s rArz*ScheduleBlock.__repr__..EsFFFEDKKFFFrTr.r/r0r1r2z ", transform=)) r4r3r4rfrrLrKr+r])r>rrfs rAr5zScheduleBlock.__repr__Cs%)Z7vdj!!!RFFT["5EFFFGG t{  b g F~& : : : : : :t566 : : : rTc,||Srrrs rArzScheduleBlock.__add__MrrT)NNN)rr"rr#rz)rCr rr"rDr^r6r7r=r8r9)rDrn)rDrpr:)rDrr;)NT)rZrzrr"rrrDr^)rrrhrrrrrr>)rrzrrzrrrDr^)rrrrrDr^)rrrrrDr^r?r@)rrzrDr^)(rKrArBrC __slots__r+rDrEr.rrBrFrOrGrrrHr]rgrSrerhrrfrrrrrrrrrr|r rrrr'r5rrrTrArUrU3s|UUnIF( ))W[,(,(,(,(,(\[BX   X _((_( ''X'(!"!X   X !!!!"!X!X&   X '''X' "+++"!+QU;;;;;@.2AE!% % % % % % % T.2AE!% $ $ $ $ $ $ T BBBBBH$$$$(((( %%%%%TNNNNN`    D    %%%%N    """"""rTrUcfd}|S)aA function decorator to attach the function to specified classes as a method. .. note:: For developer: A method attached through this decorator may hurt readability of the codebase, because the method may not be detected by a code editor. Thus, this decorator should be used to a limited extent, i.e. huge helper method. By using this decorator wisely, we can reduce code maintenance overhead without losing readability of the codebase. c~tjfd}D]}t|j|S)Nc|i|Srzr)rNrOmethods rArPz2_common_method..decorator..wrapper]s64*6** *rT)rQrRsetattrrK)rrPrMclassess` rA decoratorz!_common_method..decorator\s_   + + + + !  + 3 3C C' 2 2 2 2 rTr)rrs` rA_common_methodrRs$ rT show_barriers plot_barriersz1.4) new_aliassincedtTmpl2dstyledict[str, Any] | None time_rangetuple[int, int] | None time_unitr,disable_channelslist[Channel] | None show_snapshotrshow_framechangeshow_waveform_info plot_barrierplotteraxis Any | None show_barrierc >ddlm} ~ | |||||||||| | |  S)a Plot the schedule. Args: style: Stylesheet options. This can be dictionary or preset stylesheet classes. See :py:class:`~qiskit.visualization.pulse_v2.stylesheets.IQXStandard`, :py:class:`~qiskit.visualization.pulse_v2.stylesheets.IQXSimple`, and :py:class:`~qiskit.visualization.pulse_v2.stylesheets.IQXDebugging` for details of preset stylesheets. backend (Optional[BaseBackend]): Backend object to play the input pulse program. If provided, the plotter may use to make the visualization hardware aware. time_range: Set horizontal axis limit. Tuple ``(tmin, tmax)``. time_unit: The unit of specified time range either ``dt`` or ``ns``. The unit of `ns` is available only when ``backend`` object is provided. disable_channels: A control property to show specific pulse channel. Pulse channel instances provided as a list are not shown in the output image. show_snapshot: Show snapshot instructions. show_framechange: Show frame change instructions. The frame change represents instructions that modulate phase or frequency of pulse channels. show_waveform_info: Show additional information about waveforms such as their name. plot_barrier: Show barrier lines. plotter: Name of plotter API to generate an output image. One of following APIs should be specified:: mpl2d: Matplotlib API for 2D image generation. Matplotlib API to generate 2D image. Charts are placed along y axis with vertical offset. This API takes matplotlib.axes.Axes as ``axis`` input. ``axis`` and ``style`` kwargs may depend on the plotter. axis: Arbitrary object passed to the plotter. If this object is provided, the plotters use a given ``axis`` instead of internally initializing a figure object. This object format depends on the plotter. See plotter argument for details. show_barrier: DEPRECATED. Show barrier lines. Returns: Visualization output data. The returned data type depends on the ``plotter``. If matplotlib family is specified, this will be a ``matplotlib.pyplot.Figure`` data. r) pulse_drawer) programrbackendrrrrrrrrr)qiskit.visualizationr)r>rrrrrrrrrrrrrs rAdrawrhsWr211111 <)#)-!     rTrlist[Interval]rIntervalrcclt||}||}||krtd|d||S)a0Find the index of an interval. Args: intervals: A sorted list of non-overlapping Intervals. interval: The interval for which the index into intervals will be found. Returns: The index of the interval. Raises: PulseError: If the interval does not exist. zThe interval: z does not exist in intervals: )_locate_interval_indexr)rrrfound_intervals rArrsM #9h 7 7Eu%N!!](]]R[]]^^^ LrTrc|rt|dkr|St|dz}||}|d|dkr ||krt|d|||St||d|||zS)aUsing binary search on start times, find an interval. Args: intervals: A sorted list of non-overlapping Intervals. interval: The interval for which the index into intervals will be found. index: A running tally of the index, for recursion. The user should not pass a value. Returns: The index into intervals that new_interval would be inserted to maintain a sorted list of intervals. rxrN)r)rr)rrrmid_idxmids rArrs I!++ )nn!G G C{c!f(c//%i&985QQQQ%i&985SZ?[[[[rT new_intervalct||}|t|krDt|||rtd|d||dkr|n|dzS|S)a)Using binary search on start times, return the index into `intervals` where the new interval belongs, or raise an error if the new interval overlaps with any existing ones. Args: intervals: A sorted list of non-overlapping Intervals. new_interval: The interval for which the index into intervals will be found. Returns: The index into intervals that new_interval should be inserted to maintain a sorted list of intervals. Raises: PulseError: If new_interval overlaps with the given intervals. z$New interval overlaps with existing.rxr)rr _overlapsr)rrrs rArrsv #9l ; ;E s9~~ Yu%| 4 4 ECDD D$Q9U+;A+>>>uuEAIM LrTfirstsecondc|d|dcxkr |dkrnndS|d|dkr||}}|d|dkS)zReturn True iff first and second overlap. Note: first.stop may equal second.start, since Interval stop times are exclusive. rrxFr)rrs rArrsf Qx6!9))))q )))))u Qx&)v !9uQx rTrbr_c|D],\}}|r%|dddkrtd|d-dS)zwTest that a channel has no negative timeslots. Raises: PulseError: If a channel timeslot is negative. rzAn instruction on z has a negative starting time.N)rr)rbr}chan_timeslotss rArrsi !* 1 1\\n  \a #a'' !Zd!Z!Z!Z[[[\\rTrrct|tr*|jtfd|jD}n=t|t r|j}n tdt|d|S)zGenerate timeslots from given schedule component. Args: schedule: Input schedule component. Raises: PulseError: When invalid schedule type is specified. ci|]}|dfg Sr<r)r|rres rA z"_get_timeslots..s!OOO'W8}oOOOrTzInvalid schedule type z is specified.) r6rrerrhrrbrr)rrbres @rArr s(K((R$'111OOOOX=NOOO Hh ' 'R& P$x..PPPQQQ rT block_elmslist['BlockComponent']set[Reference]ct}|D]Y}t|tr|t|jz}/t|t r||Z|S)zRecursively get reference instructions in the current scope. Args: block_elms: List of schedule block elements to investigate. Returns: A set of unique reference instructions. )rr6rUr}rYradd)rrrris rAr}r} soJ   c= ) ) /#+66 6JJ Y ' ' NN3    rT)rIrrDr) NNNrNTTTTrNT)rrrrrr,rrrrrrrrrrrr,rrrr)rrrrrDrcr<)rrrrrrcrDrc)rrrrrDrc)rrrrrDr)rbr_)rrrDr_)rrrDr)CrC __future__rabcrIrQrDmultiprocessingr1r/rcollections.abcrrtypingrrrr r r numpyr rustworkxrqiskit.circuitr qiskit.circuit.parameterr "qiskit.circuit.parameterexpressionrrqiskit.pulse.channelsrqiskit.pulse.exceptionsrrqiskit.pulse.instructionsrrqiskit.pulse.utilsrqiskit.pulse.reference_managerrqiskit.utils.multiprocessingr qiskit.utilsrqiskit.utils.deprecate_pulserrcrr_rrSrUrrrrrrrrr}ScheduleComponentBlockComponentrrTrArs$#"""""  ........::::::::::::::::******......VVVVVVVV))))))HHHHHHHH<<<<<<<<>>>>>>;;;;;;888888&&&&&&====== c?Z $x.( ) B^ K^ K^ K^ K^ K^ K^ K^ KB    \ "\ "\ "\ "\ "\ "\ "\ "~,/GGG-(($( )--1!#GGGG)(HGGT(\\\\\.(      \ \ \ \*4(K/00}k1266rT