MhdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z mZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)ddl*m+Z+m,Z,m-Z-m.Z.m/Z/ddl0m1Z1ddl2m3Z3m4Z4m5Z5ej6dZ7ej6dZ8d$d%dZ9Gdde)Z: d&d'd#Z;dS)(znbclient implementation.) annotationsN)asynccontextmanagercontextmanager)Empty)dedent monotonic) KernelClient) KernelManager) NotebookNode)output_from_msg) AnyBoolCallableDictEnumIntegerListTypeUnicodedefault)LoggingConfigurable)CellControlSignalCellExecutionCompleteCellExecutionErrorCellTimeoutErrorDeadKernelError) OutputWidget) ensure_asyncrun_hookrun_syncz .*\r(?=[^\n])z[^\n]\bmsgdict[str, t.Any] | NonereturnstrcD|rld|vrh|d}d|vr\t|dtjr< tj|dd}|r|Sn#t$rYnwxYwtjdzS)z Get the timestamp for a message.headerdatez%Y-%m-%dT%H:%M:%S.%fZZ) isinstancedatetimestrftime Exceptionutcnow isoformat)r# msg_headerformatted_times O/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/nbclient/client.py timestampr4(s x3] Z  Jz&/A8CT$U$U  !)!2!;!;v&(?""#**)*       # # % % / / 1 1C 77s)A A,+A,c eZdZUdZeddeddZeddeddZ d e d <e d ed  dZ e ddeddZeded dZe d ed dZeeed dZe d ed dZeded dZeedZeded dZe d ed dZe ded dZe ded dZedd eddZedd eddZedd gded!"dZed#d$"dZe de!d%&Z"e#dded'dZ$e#dded(dZ%e#dded)dZ&e#dded*dZ'e#dded+dZ(e#dded,dZ)e#dded-dZ*e#dded.dZ+e,d/dd2Z-e ed3 Z.d4e d5<egd6d7 dZ/e ed8 Z0d4e d9<e ed: Z1ddfdB Z2ddCZ3ddEZ4ddFZ5e6e5Z7ddHZ8e6e8Z9ddJZ:e6e:Z;eddNZ?dddQZ@e6e@ZAddRZBddVZCdd^ZDddbZEddcZFddeZG dddgZHddhZI dddjZJe6eJZKeKZLddlZMddnZN dddqZOe6eOZPddrZQdduZRddvZSddwZTddxZUddzZVdd|ZWddZXddZYddZZxZ[S)NotebookClientz@ Encompasses a Client for executing cells in a notebook NTa The time to wait (in seconds) for output from executions. If a cell execution takes longer, a TimeoutError is raised. ``None`` or ``-1`` will disable the timeout. If ``timeout_func`` is set, it overrides ``timeout``. ) allow_nonehelpconfiga  A callable which, when given the cell source as input, returns the time to wait (in seconds) for output from cell executions. If a cell execution takes longer, a TimeoutError is raised. Returning ``None`` or ``-1`` will disable the timeout for the cell. Not setting ``timeout_func`` will cause the client to default to using the ``timeout`` trait for all cells. The ``timeout_func`` trait overrides ``timeout`` if it is not ``None``. ) default_valuer7r8z"t.Callable[..., int | None] | None timeout_funcFz If execution of a cell times out, interrupt the kernel and continue executing other cells rather than throwing an error and stopping. )r8a If a cell execution was interrupted after a timeout, don't wait for the execute_reply from the kernel (e.g. KeyboardInterrupt error). Instead, return an execute_reply with the given error, which should be of the following form:: { 'ename': str, # Exception name, as a string 'evalue': str, # Exception value, as a string 'traceback': list(str), # traceback frames, as strings } <z The time to wait (in seconds) for the kernel to start. If kernel startup takes longer, a RuntimeError is raised. a If ``False`` (default), when a cell raises an error the execution is stopped and a ``CellExecutionError`` is raised, except if the error name is in ``allow_error_names``. If ``True``, execution errors are ignored and the execution is continued until the end of the notebook. Output from exceptions is included in the cell output in both cases. z List of error names which won't stop the execution. Use this if the ``allow_errors`` option it too general and you want to allow only specific kinds of errors. a If False (default), errors from executing the notebook can be allowed with a ``raises-exception`` tag on a single cell, or the ``allow_errors`` or ``allow_error_names`` configurable options for all cells. An allowed error will be recorded in notebook output, and execution will continue. If an error occurs when it is not explicitly allowed, a ``CellExecutionError`` will be raised. If True, ``CellExecutionError`` will be raised for any error that occurs while executing the notebook. This overrides the ``allow_errors`` and ``allow_error_names`` options and the ``raises-exception`` cell tag. zskip-executionz^ Name of the cell tag to use to denote a cell that should be skipped. z Name of kernel to use to execute the cells. If not set, use the kernel_spec embedded in the notebook. a  If ``False`` (default), then the kernel will continue waiting for iopub messages until it receives a kernel idle message, or until a timeout occurs, at which point the currently executing cell will be skipped. If ``True``, then an error will be raised after the first timeout. This option generally does not need to be used, but may be useful in contexts where there is the possibility of executing notebooks with memory-consuming infinite loops. z If ``True`` (default), then the state of the Jupyter widgets created at the kernel will be stored in the metadata of the notebook. z If ``True`` (default), then the execution timings of each cell will be stored in the metadata of the notebook. a The time to wait (in seconds) for IOPub output. This generally doesn't need to be set, but on some slow networks (such as CI systems) the default timeout might not be long enough to get all messages. z The time to wait (in seconds) for Shell output before retrying. This generally doesn't need to be set, but if one needs to check for dead kernels at a faster rate this can help. graceful immediatea  If ``graceful`` (default), then the kernel is given time to clean up after executing all cells, e.g., to execute its ``atexit`` hooks. If ``immediate``, then the kernel is signaled to immediately terminate. )r;r8z:memory:aPath to file to use for SQLite history database for an IPython kernel. The specific value ``:memory:`` (including the colon at both end but not the back ticks), avoids creating a history file. Otherwise, IPython will create a history file for each kernel. When running kernels simultaneously (e.g. via multiprocessing) saving history a single SQLite file can result in database errors, so using ``:memory:`` is recommended in non-interactive contexts. z The kernel manager class to use.)r:klassr8z A callable which executes after the kernel manager and kernel client are setup, and cells are about to execute. Called with kwargs ``notebook``. z A callable which executes after the kernel is cleaned up. Called with kwargs ``notebook``. z A callable which executes when the notebook encounters an error. Called with kwargs ``notebook``. z A callable which executes before a cell is executed and before non-executing cells are skipped. Called with kwargs ``cell`` and ``cell_index``. z A callable which executes just before a code cell is executed. Called with kwargs ``cell`` and ``cell_index``. z A callable which executes after a cell execution is complete. It is called even when a cell results in a failure. Called with kwargs ``cell`` and ``cell_index``. z A callable which executes just after a code cell is executed, whether or not it results in an error. Called with kwargs ``cell``, ``cell_index`` and ``execute_reply``. a A callable which executes when a cell execution results in an error. This is executed even if errors are suppressed with ``cell_allows_errors``. Called with kwargs ``cell`, ``cell_index`` and ``execute_reply``. kernel_manager_classr%type[KernelManager]cddlm}|S)zBUse a dynamic default to avoid importing jupyter_client at startupr)AsyncKernelManager)jupyter_clientrG)selfrGs r3_kernel_manager_class_defaultz,NotebookClient._kernel_manager_class_defaults 655555!!aP mapping of locations of outputs with a given display_id tracks cell index and output index within cell.outputs for each appearance of the display_id { 'display_id': { cell_idx: [output_idx,] } } dict[str, t.Any]_display_id_map)z text/htmlzapplication/pdfz text/latexz image/svg+xmlz image/pngz image/jpegz text/markdownz text/plainz An ordered list of preferred output type, the first encountered will usually be used when converting discarding the others. z Additional resources used in the conversion process. For example, passing ``{'metadata': {'path': run_path}}`` sets the execution path to ``run_path``. resourceszY Merge all stream outputs with shared names into single streams. nbr kmKernelManager | Nonekwt.AnyNonec tjdi|||_||_|du|_d|_|ddtii|_d|j i|_ dS)aInitializes the execution manager. Parameters ---------- nb : NotebookNode Notebook being executed. km : KernelManager (optional) Optional kernel manager. If none is provided, a kernel manager will be created. Nz@jupyter-widgets/output OutputModelzjupyter.widget) super__init__rOrPowns_kmkcreset_execution_trackersrwidget_registryon_comm_open_jupyter_widgetcomm_open_handlers)rIrOrPrR __class__s r3rYzNotebookClient.__init__s 2 "(*4Z '+ %%''' % |'D=  d>5 rKcd|_d|_i|_i|_i|_t jt|_i|_ dS)z"Resets any per-execution trackers.Nr) task_poll_for_replycode_cells_executedrM widget_statewidget_buffers collections defaultdictlistoutput_hook_stack comm_objectsrIs r3r\z'NotebookClient.reset_execution_trackerssMAE #$ !9;PR)4(?(E(E.0rKr cD|js<|jjdid}|||_|js!||j|_n&||j|j|_|jJ|jS)zCreates a new kernel manager. Returns ------- km : KernelManager Kernel manager whose client class is asynchronous. kernelspecnameNr9) kernel_namer:)rorOmetadatagetrDr:rP)rIkns r3create_kernel_managerz$NotebookClient.create_kernel_managers &!%%lB77;;FCCB~#%  b//t{/CCDGG//Dt|j d{Vd|_d|_dSdSdS#t|jd{Vt|ddrA|j:t|j d{Vd|_d|_wxYw)NrB)nowzNo kernel is running!r[) rPshutdown_kernelr is_alive RuntimeErrorr&cleanup_resourcesgetattrr[ stop_channels)rIrues r3_async_cleanup_kernelz$NotebookClient._async_cleanup_kernelsw""""k1 !$'"2"2"4"455555555 E"47#:#:s#:#C#CDDDDDDDDD   &c!ff4454444  tw88::;; ; ; ; ; ; ; ;tT4(( TW-@"47#8#8#:#:;;;;;;;;;  -@-@tw88::;; ; ; ; ; ; ; ;tT4(( TW-@"47#8#8#:#:;;;;;;;;;s1AA32D 3 B=BD BD BF kwargscK|jJ|jdidpd}|r d|vr||d<td|jD}t |jdr.|jjr"|jr|s|xjd|jgz c_t|jj d d|ji|d{VdS) aQCreates a new kernel. Parameters ---------- kwargs : Any options for ``self.kernel_manager_class.start_kernel()``. Because that defaults to AsyncKernelManager, this will likely include options accepted by ``AsyncKernelManager.start_kernel()``, which includes ``cwd``. Nrppathcwdc3@K|]}|dVdS)z--HistoryManager.hist_fileN) startswith).0args r3 z8NotebookClient.async_start_new_kernel..s@& & =@CNN7 8 8& & & & & & rK ipykernelz--HistoryManager.hist_file=extra_argumentsrW) rPrNrqanyrhasattrripython_hist_filer start_kernel)rIr~ resource_pathhas_history_manager_args r3async_start_new_kernelz%NotebookClient.async_start_new_kernel s2w"""**:r::>>vFFN$  *U&00)F5M"%& & DHDX& & & # #  DG[ ) ) ]! ]& ],  ]  %[4CY%[%[$\ \ /47/__@T_X^__```````````rKr c vK|jJ |j|_t|jd{Vt|j|jd{Vn|#t$ro}|j d t|jddt|| d{Vd}~wwxYwd|j_t|j|jd{V|jS)zCreates a new kernel client. Returns ------- kc : KernelClient Kernel client as created by the kernel manager ``km``. NtimeoutzAError occurred while starting new kernel client for kernel {}: {} kernel_idFnotebook)rPclientr[r start_channelswait_for_readystartup_timeoutr.logerrorformatrzr&r} allow_stdinr!on_notebook_startrO)rIr|s r3async_start_new_kernel_clientz,NotebookClient.async_start_new_kernel_client*s^w""" gnn&&DGtw557788 8 8 8 8 8 8 8tw55d>R5SSTT T T T T T T T T    HNNSZZDG[$77Q    ,,.. . . . . . . .  $t-@@@@@@@@@@wsA=B DA*C??Dt.Generator[None, None, None]c+ZK|d|j}|j||_|jjs |jdi||j| dV|r|dSdS#|r|wwxYw)a' Context manager for setting up the kernel to execute a notebook. The assigns the Kernel Manager (``self.km``) if missing and Kernel Client(``self.kc``). When control returns from the yield it stops the client's zmq channels, and shuts down the kernel. cleanup_kcNrW) poprZrPrs has_kernelstart_new_kernelr[start_new_kernel_client_cleanup_kernel)rIr~rs r3 setup_kernelzNotebookClient.setup_kernelEsZZ dl;;  7?0022DGw! , !D ! + +F + + + 7?  ( ( * * * ' EEE '$$&&&&& ' 'z '$$&&&& 's 3BB*t.AsyncGenerator[None, None]c $K|dj}j_t jjdfd }tj} | tj || tj |n#t$rYnwxYwjjsjdi|d{Vjd{V dWVn5#t$r(}t%jjd{V|d}~wwxYw |rd{Vt%jjd{Vt jj |tj |tj dS#t$rYdSwxYw#|rd{Vt%jjd{Vt jj |tj |tj w#t$rYwwxYwxYw) a Context manager for setting up the kernel to execute a notebook. This assigns the Kernel Manager (``self.km``) if missing and Kernel Client(``self.kc``). When control returns from the yield it stops the client's zmq channels, and shuts down the kernel. Handlers for SIGINT and SIGTERM are also added to cleanup in case of unexpected shutdown. rNr%rTctj_t jjdS)zHandle signals.N)asyncio ensure_futurer}_async_cleanup_kernel_futureatexit unregisterrrksr3 on_signalz4NotebookClient.async_setup_kernel..on_signalys<070EdF`F`FbFb0c0cD -  d2 3 3 3 3 3rKrr%rTrW)rrZrPrsrregisterrrget_event_loopadd_signal_handlersignalSIGINTSIGTERMrxrrr[rr!on_notebook_errorrOr}on_notebook_completerremove_signal_handler)rIr~rrloopr|s` r3async_setup_kernelz!NotebookClient.async_setup_kernelcs(ZZ dl;; 7?0022DG ,--- 4 4 4 4 4 4 %''   # #FM9 = = =  # #FNI > > > >    D  w! 8-$-7777 7 7 7 7 7 7 7 7?4466 6 6 6 6 6 6 6  EEEEE   41DGDDD D D D D D D DG    30022222222244twGGG G G G G G G G  d2 3 3 3 **6=999**6>:::::     30022222222244twGGG G G G G G G G  d2 3 3 3 **6=999**6>::::    st2AB33 C?CD G( D<#D77D<<G(>G G%$G%(AJ>I?>J? J  J J  Jreset_kcboolc K|r!|jr|d{V||jdi|4d{V|jJ|jd|jzt|j d{V}| |d{V}|Kd|dvr|dd|j j d<n%tdt|dzt|j jD]+\}}||||jdzd{V,|dddd{Vn#1d{VswxYwY|j S) aT Executes each code cell. Parameters ---------- kwargs : Any option for ``self.kernel_manager_class.start_kernel()``. Because that defaults to AsyncKernelManager, this will likely include options accepted by ``jupyter_client.AsyncKernelManager.start_kernel()``, which includes ``cwd``. ``reset_kc`` if True, the kernel client will be reset and a new one will be created (default: False). Returns ------- nb : NotebookNode The executed notebook. Nz"Executing notebook with kernel: %s language_infocontentzMKernel info received message content has no "language_info" key. Content is: r)execution_countrW)rZr}r\rr[rinforor kernel_infoasync_wait_for_replyrOrprxr& enumeratecellsasync_execute_cellrcset_widgets_metadata)rIrr~msg_idinfo_msgindexcells r3 async_executezNotebookClient.async_executes(  /  /,,.. . . . . . . . %%'''*4*44V44 ( ( ( ( ( ( ( (7&&& HMM>AQQ R R R'(;(;(=(=>>>>>>>>F!66v>>>>>>>>H#"hy&9998@8KO8\DG$_55&(*-hy.A*B*BC )77   t--%1IA1M.  % % ' ' '' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( (*ws DE88 FFcxjrdfdjDdddijj_jjjddD]G\}}j|}|r$t||d<FdSdS) zSet with widget metadata.z)application/vnd.jupyter.widget-state+jsoncJi|]\}}d|v || S) _model_name)_serialize_widget_state)rmodel_idstaterIs r3 z7NotebookClient.set_widgets_metadata..sB+He(E11!$">">u"E"E111rKr)r version_major version_minorrbuffersN) rditemsrOrpwidgetsrerqrhvalues)rIkeywidgetrs` r3rz#NotebookClient.set_widgets_metadatas   ?;/3/@/F/F/H/H &'%&>> (DG  $ $w/7;  uww ? ? V-11#66?(,W^^-=-=(>(>F9%# ? ? ? ?rK display_idr&r#c||jvr#|jd||jdS|dddkr d|dd< t|}n4#t$r'|jd|dYdSwxYw|j|D]G\}}|jd|}|d }|D]$}|d ||d <|d ||d <%HdS) z&Update outputs with a given display_idzdisplay id %r not in %sNr(msg_typeupdate_display_data display_dataunhandled iopub msg: routputsdatarp)rMrdebugr ValueErrorrrrO) rIrr#outcell_idxoutput_indicesrr output_idxs r3_update_display_idz!NotebookClient._update_display_ids= T1 1 1 HNN4j$BV W W W F x= $(= = =(6CM* % !#&&CC    HNND3z?DD E E E FF )-(BE>8 CE>A'EE>EE>!E>>AGG parent_msg_id cell_indexintcK|jJ t|jjdd{V}|dd|kr* ||||n#t $rYdSwxYw})NTrrr)r[r iopub_channelrrqprocess_messager)rIrrr r#s r3_async_poll_output_msgz%NotebookClient._async_poll_output_msg(sw""" $TW%:%B%B4%B%P%PQQQQQQQQC?#''11]BB((dJ????,FF  s A88 BBcK tjdd{V |d{Vn3#t$r&|jJ|jYdSwxYwj)NTr)rsleeprrrbrrks r3_async_poll_kernel_alivez'NotebookClient._async_poll_kernel_alive5s -"" " " " " " " " --//////////"   /;;;(//111   s:,A*)A*NotebookNode | Nonecf|j|||}n|j}|r|dkrd}|S)Nr)r<r)rIrrs r3 _get_timeoutzNotebookClient._get_timeout?sF   (T-=''--GGlG 'A++GrKNone | dict[str, t.Any]cTK|jd|z|jri|jd|jJt |jd{V|jrdi|jddii}|SdS|Jtjd||)Nz(Timeout waiting for execute reply (%is).zInterrupting kernelrstatusrzCell execution timed out) rrinterrupt_on_timeoutrPr interrupt_kernelerror_on_timeoutrr)rIrr execute_replys r3rz$NotebookClient._async_handle_timeoutJs AGKLLL  $  HNN0 1 1 17&&&tw7799:: : : : : : : :$ %!*,Xt/D,XhPW,X,X Y $$4###">*GT rKcK|jJt|jd{Vs)|jdt ddS)Nz,Kernel died while waiting for execute reply. Kernel died)r[r rwrrrrks r3rz!NotebookClient._async_check_alive\sqw"""!$'"2"2"4"455555555 1 HNNI J J J!-00 0 1 1rKr$cK|jJ||}d} t|jj|jd{V}|dd|kr|SnZ#t$rM|d{V||jz }|r$||kr| ||d{VYnYnwxYwdS)zWait for a message reply.NrTrrr) r[rr rrshell_timeout_intervalrqrrr)rIrrrcummulative_timer#s r3rz#NotebookClient.async_wait_for_replybsJw"""##D))  .:G)11$:U1VV//))))))'++H55??J@   --///////// D$?? /'9944WdCCCCCCCCCE   ts8A??ACCrc8||tz dkrdSdS)NrTFr)rIrs r3_passed_deadlinezNotebookClient._passed_deadline~s%  Hy{{$:a$?$?4urK exec_replyc8K|dS|d}|ddkrdS|j o?|jp8|d|jvpd|jdgv}t |j|||d{V|stj||dS)Nrrrenameraises-exceptiontagsrr r) force_raise_errors allow_errorsrqallow_error_namesrpr! on_cell_errorrfrom_cell_and_msg)rIrr r#exec_reply_contentcell_allows_errorss r3_check_raise_for_errorz%NotebookClient._check_raise_for_errors  4' 2 h '7 2 24"&"99   C!%%g..$2HH C!T]%6%6vr%B%BB    TjPZ          " Q$6t=OPP P Q QrKr store_historyc  K|jJt|j||d{V|jdks|js|jd||S|j|j dgvr|jd||S|j r i|dd<|jd |j|j o#|j pd |j dgv}t|j||d{Vt|j|j|| d{V}t|j||d{V|xjd z c_||}g|_d |_t-j|}t-j||||} t-j||||| ||_ |jd{V} nt#t,j$r%| t=ddt>$r5} tA| tBs| #xYwd} ~ wwxYw|r||d<t|j"||| d{V|j#r|jrg} i} |jD]q}|ddkrN|d| vr#| |ddxx|dz cc<;| $||| |d<\| $|r| %D]}|d}tM|dtM|krR|d}tN(d|d|d<tM|dtM|kRtR(d|d|d<tU| D]\}}|ddkrz|ddkrntM| |dzkrX| |d zddkrC| |d zddkr.| +|d z}| ,||| |_|-||| d{V||j.d|<|S)a Executes a single code cell. To execute all cells see :meth:`execute`. Parameters ---------- cell : nbformat.NotebookNode The cell which is currently being processed. cell_index : int The position of the cell within the notebook object. execution_count : int The execution count to be assigned to the cell (default: Use kernel response) store_history : bool Determines if history should be stored in the kernel (default: False). Specific to ipython kernels, which can store command histories. Returns ------- output : dict The execution output payload (or None for no output). Raises ------ CellExecutionError If execution failed and should raise an exception, this will be raised with defaults about the failure. Returns ------- cell : NotebookNode The cell which was just processed. N)rr codezSkipping non-executing cell %sr'zSkipping tagged cell %srprzExecuting cell: %sr&)r1 stop_on_errorrFrrr( output_typestreamrntextr>stderrrstdoutr)/r[r! on_cell_start cell_typesourcestriprrskip_cells_with_tagrprqrr)r*on_cell_executer executeon_cell_completercrrclear_before_next_outputrrrrrrbCancelledErrorrrr.r+ron_cell_executedcoalesce_streamsappendrlen_RGX_BACKSPACEsub_RGX_CARRIAGERETURNrrinsertr0rO)rIrr rr1r/r exec_timeoutrrr#r| new_outputsstreamsoutputoldir9s r3rz!NotebookClient.async_execute_cellsPw"""t)LLLLLLLLLL >V # #4;+<+<+>+> # HNN;Z H H HK  #t}'8'8'D'D D D HNN4j A A AK   /,.D [ ) ,dk:::"&"99   T!3t}7H7HQS7T7T!T t+$:NNNNNNNNNN* GOO =L^H^           t,4JOOOOOOOOOO   A%  ((..  (-%!(!6t7T7T7V7V!W!W&4  ' ' tZ H H  $+#8  & &t\3GI_  $ $  #7777777JJ% ; ; ; ' ' ) ) )!-00d :    !!%6772(//111   6&5D" #  !S]            # 'T\# 'K/1G, / /-(H44f~00v/7776&>I7777#**622228v//&&v...."..** M MVn&.))CHH44 .C%3%7%7F6N%K%KF6N&.))CHH44 "5!8!8VF^!L!Lv'{33 6 6 6-(H4489S9SK((AE11'A.}=II'A.v6(BB!,Q!7!7#**1f555&DL))$ JGGGGGGGGG'+$ s** H88rexecute_resultrrrexecution_stateidlerprziopub.status.idlebusyziopub.status.busy execute_inputziopub.execute_input clear_outputcomm)rXr) rrrqrrr4rrYrrhandle_comm_msgrO)rIr#rr rrrSrs r3r zNotebookClient.process_message-s:z? ~x000i. }g... KK ,, 4=GY]]<0004  5(&___  # #J 4 4 4  ' '&-.?&@D" #   V8##,-77IRSVD$[12EFF./699IRSVD$[12EF_,,GPQT~~Z -.CD x  ()V33+---4  ' '   dlC < < < <   ( ( J  sJ ? ? ? ? E E E;;t|S*jII ItrKoutslist[NotebookNode]c|d}d}|dd}|j|r-|j|d}|||||dS t|}n.#t$r!|jd|YdSwxYw|jr=|jdg|dd<| |d|_|rS|j |i} | |g} | t||r| ||S) zHandle output.rNrrrzExecuting delayed clear_outputF)rqrirOr rrrrBrclear_display_id_mappingrM setdefaultrFrG) rIr\r#rr rrrhookcell_mapoutput_idx_lists r3rOzNotebookClient.outputrsy z?#'O,00::  !- 0 )-8 > >44   ( 2 HNN; < < <DG  ) )* 5 5 5,1D )  .+66z2FFH&11*bAAO  " "3t99 - - -   KK    s!A11'BBc|d}|dd}|j|r,|j|d}||||dS|dr#|jdd|_dS|jd g|dd<||dS) z Clear output.rrrr_NwaitzWait to clear outputTzImmediate clear output)rqrirYrrrBr`)rIr\r#r rrrbs r3rYzNotebookClient.clear_outputsi.O,00::  !- 0 )-8.s9FFF,-E!F)$$aFFFrKr comm_open target_namez!No handler found for comm target comm_msgN) store_widget_staterdraupdaterqre_get_buffer_datar_rjrr handle_msg) rIr\r#r rrrj new_bufferstargethandler comm_objects r3r[zNotebookClient.handle_comm_msgsi.v  " Aw$   ( ();R @ @ G GW V V Vxx'' A!),$"55535D'0FF151F1Fs1K1KFFF #G,33K@@@ z?k ) )^'' 66F-11&99G Qi.3%gcll =1rrorrrrrrrrvrrr rDrrrrr:r?rArDr,rrJrMdisplay_data_priorityrNrErYr\rsr}r"rrrrrrrrrrr@rrrrrrrrrwait_for_reply_wait_for_replyr"r0r execute_cellr rOrYr`r[rrtrrr^ __classcell__)r`s@r3r6r6<s g  V       cc 8;s V    888  cc!$ 4 V       cct V    " cc#&g V       cc4 V        cc V       cc V      cc!$"' V    ccd7799oo)))66O' V    cc"T V        cc V    ccD V    ccG  V       cc%W  V       ccd [! V       cc        cc 4=/Q! V       cc$8 V       cc! V       ccH V       cch V       cc x V       cc x V       ccH V       cc W #$$"""%$" )- V     ) ) )O    !D   cc!$#'$ V   ###It V          2 1 1 1 1(&h455Oaaaa8 x 6772'h'DEE'''^':7777r-----^h}%%G????*BBBB,-a-a-a-a^        9=$11118<0X233N$O QQQQ2'+" QQQQQf8.//LCCCCJ&&&&P6666,**** !;!;!;!;F        4444$$$$        rKr6rOr r str | NonerPrQr~rSc \i}|d|i|d<td|||d|S)a+Execute a notebook's code, updating outputs within the notebook object. This is a convenient wrapper around NotebookClient. It returns the modified notebook object. Parameters ---------- nb : NotebookNode The notebook object to be executed cwd : str, optional If supplied, the kernel will run in this directory km : AsyncKernelManager, optional If supplied, the specified kernel manager will be used for code execution. kwargs : Any other options for NotebookClient, e.g. timeout, kernel_name Nrrp)rOrNrPrW)r6r@)rOrrPr~rNs r3r@r@sE,I !' *  FR9 F Fv F F N N P PPrKr)r#r$r%r&)NN) rOr rrrPrQr~rSr%r )rsv""""""  ::::::::......000000!!!!!!''''''\\\\\\\\\\\\\\\\\\\\\\\\======('''''2222222222 bj!122J'' 88888(OOOOO(OOOh&#QQQQQQQrK