B íº]\BLã@sÐdZddlmZddlmZyddlmZWn ek rLddlmZYnXddl m Z m Z m Z m Z mZmZmZmZmZddlmZddlmZd d lmZGd d „d eƒZd ZGdd„deƒZddd„ZdS)zQModule containing a preprocessor that executes the code cells and updates outputsé)Údedent)Úcontextmanager)ÚEmpty) ÚListÚUnicodeÚBoolÚEnumÚAnyÚTypeÚDictÚIntegerÚdefault)Úoutput_from_msgé)Ú Preprocessoré)ÚConversionExceptioncs<eZdZdZ‡fdd„Zdd„Zdd„Zedd „ƒZ‡Z S) ÚCellExecutionErrorzâ Custom exception to propagate exceptions that are raised during notebook execution to the caller. This is mostly useful when using nbconvert as a library, since it allows to deal with failures gracefully. cstt|ƒ |¡||_dS)N)ÚsuperrÚ__init__Ú traceback)Úselfr)Ú __class__©ú>lib/python3.7/site-packages/nbconvert/preprocessors/execute.pyrszCellExecutionError.__init__cCs"| ¡}t|tƒs| dd¡}|S)NÚutf8Úreplace)Ú __unicode__Ú isinstanceÚstrÚencode)rÚsrrrÚ__str__"s  zCellExecutionError.__str__cCs|jS)N)r)rrrrr(szCellExecutionError.__unicode__c Cs8d | dg¡¡}|tj||| dd¡| dd¡dƒS)zvInstantiate from a code cell object and a message contents (message is either execute_reply or error) Ú rÚenamezÚevalueÚ)Úcellrr$r%)ÚjoinÚgetÚ exec_err_msgÚformat)Úclsr'ÚmsgÚtbrrrÚfrom_cell_and_msg+s  z$CellExecutionError.from_cell_and_msg) Ú__name__Ú __module__Ú __qualname__Ú__doc__rr"rÚ classmethodr/Ú __classcell__rr)rrrs  rz‰An error occurred while executing the following cell: ------------------ {cell.source} ------------------ {traceback} {ename}: {evalue} csŒeZdZdZeddedƒdjddZeddedƒd jddZ e d ed ƒd jddZ ed edƒd jddZ e d edƒd jddZ e d edƒd jddZeeƒƒZededƒd jddZe d edƒd jddZedd edƒdjddZeddgdedƒdjddZedddZedƒdd„ƒZeedƒd Zd d!„Zed/d"d#„ƒZd0‡fd$d%„ Z d&d'„Z!d(d)„Z"d1d*d+„Z#d2d-d.„Z$‡Z%S)3ÚExecutePreprocessorz. Executes all the cells in a notebook éTaO The time to wait (in seconds) for output from executions. If a cell execution takes longer, an exception (TimeoutError on python 3+, RuntimeError on python 2) is raised. `None` or `-1` will disable the timeout. If `timeout_func` is set, it overrides `timeout`. )Ú allow_noneÚhelp)ÚconfigNaX 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, an exception (TimeoutError on python 3+, RuntimeError on python 2) is raised. Returning `None` or `-1` will disable the timeout for the cell. Not setting `timeout_func` will cause the preprocessor to default to using the `timeout` trait for all cells. The `timeout_func` trait overrides `timeout` if it is not `None`. )Ú default_valuer8r9Fz· If execution of a cell times out, interrupt the kernel and continue executing other cells rather than throwing an error and stopping. )r9é<z¢ The time to wait (in seconds) for the kernel to start. If kernel startup takes longer, a RuntimeError is raised. aq If `False` (default), when a cell raises an error the execution is stopped and a `CellExecutionError` is raised. 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. 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` configurable option 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 both the `allow_errors` option and the `raises-exception` cell tag. r&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. é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. ZgracefulÚ 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;r9z The kernel manager class to use.)r:r9Úkernel_manager_classcCs2yddlm}Wntk r,tdƒ‚YnX|S)zBUse a dynamic default to avoid importing jupyter_client at startupr)Ú KernelManagerzW`nbconvert --execute` requires the jupyter_client package: `pip install jupyter_client`)Zjupyter_clientr@Ú ImportError)rr@rrrÚ_kernel_manager_class_defaultÊs z1ExecutePreprocessor._kernel_manager_class_defaultaP 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,] } } cKs |js |jj di¡ dd¡|_|j|j|jd}|jfd|ji|—Ž| ¡}|  ¡y|j |j dWn&t k r|  ¡| ¡‚YnXd|_||fS)a9Creates a new kernel manager and kernel client. Parameters ---------- kwargs : Any options for `self.kernel_manager_class.start_kernel()`. Because that defaults to KernelManager, this will likely include options accepted by `KernelManager.start_kernel()``, which includes `cwd`. Returns ------- km : KernelManager A kernel manager as created by self.kernel_manager_class. kc : KernelClient Kernel client as created by the kernel manager `km`. Z kernelspecÚnameZpython)Ú kernel_namer:Úextra_arguments)ÚtimeoutF)rDÚnbÚmetadatar)r?r:Ú start_kernelrEÚclientÚstart_channelsÚwait_for_readyÚstartup_timeoutÚ RuntimeErrorÚ stop_channelsÚshutdown_kernelÚ allow_stdin)rÚkwargsÚkmÚkcrrrÚstart_new_kernelàs  z$ExecutePreprocessor.start_new_kernelc cs:| di¡ dd¡pd}||_i|_|dkr|j|d\|_|_z||j|jfVWd|j ¡|jj|jdkdxdD]}t||ƒqzWXn¦||_|j s²|j fd |j it —Ž|  ¡|_|j ¡y|jj|jd Wn tk rú|j ¡‚YnXd |j_z||j|jfVWdxdD]}t||ƒq WXdS) aj Context manager for setting up the class to execute a notebook. The assigns `nb` to `self.nb` where it will be modified in-place. It also creates and assigns the Kernel Manager (`self.km`) and Kernel Client(`self.kc`). It is intended to yield to a block that will execute codeself. When control returns from the yield it stops the client's zmq channels, shuts down the kernel, and removes the now unused attributes. Parameters ---------- nb : NotebookNode Notebook being executed. resources : dictionary Additional resources used in the conversion process. For example, passing ``{'metadata': {'path': run_path}}`` sets the execution path to ``run_path``. km : KernerlManager (optional) Optional kernel manaher. If none is provided, a kernel manager will be created. Returns ------- nb : NotebookNode The executed notebook. resources : dictionary Additional resources used in the conversion process. rHÚpathr&N)Úcwdr>)Znow)rGrSrTrE)rFF)r)rGÚ_display_id_maprUrSrTrOrPÚdelattrZ has_kernelrIrErRrJrKrLrMrNrQ)rrGÚ resourcesrSrVÚattrrrrÚsetup_preprocessors4       z&ExecutePreprocessor.setup_preprocessorc sn|j|||dP|j d|j¡tt|ƒ ||¡\}}| |j  ¡¡}|dd|j d<WdQRX||fS)a Preprocess notebook executing each code cell. The input argument `nb` is modified in-place. Parameters ---------- nb : NotebookNode Notebook being executed. resources : dictionary Additional resources used in the conversion process. For example, passing ``{'metadata': {'path': run_path}}`` sets the execution path to ``run_path``. km: KernelManager (optional) Optional kernel manager. If none is provided, a kernel manager will be created. Returns ------- nb : NotebookNode The executed notebook. resources : dictionary Additional resources used in the conversion process. )rSz"Executing notebook with kernel: %sÚcontentZ language_infoN) r\ÚlogÚinforDrr6Ú preprocessÚ_wait_for_replyrTZ kernel_inforH)rrGrZrSZinfo_msg)rrrr`Fs zExecutePreprocessor.preprocesscCs¨|jdks|j ¡s||fS| ||¡\}}||_|jpHd|j dg¡k}|jsT|s x"|D]}|j dkrZt   ||¡‚qZW|dk r |dddkr t   ||d¡‚||fS)z} Executes a single code cell. See base.py for details. To execute all cells see :meth:`preprocess`. Úcodezraises-exceptionZtagsÚerrorNr]Ústatus) Z cell_typeÚsourceÚstripÚrun_cellÚoutputsÚ allow_errorsrHr)Úforce_raise_errorsZ output_typerr/)rr'rZÚ cell_indexZreplyrhZcell_allows_errorsÚoutrrrÚpreprocess_cellhs   z#ExecutePreprocessor.preprocess_cellc CsÖ||jkr |j d||j¡dS|dddkrÚexecute_resultrqrpZ transientrvrpzunhandled iopub msg: )rTZexecuterer^rsrarhZ iopub_channelr{Ú iopub_timeoutrZwarningÚraise_on_iopub_timeoutrNr)rXruÚ startswithrwrrtrcÚ setdefaultÚappendÚlen) rr'rkryZ exec_replyZoutsr-ror]rvZcell_maprlZoutput_idx_listrrrrgµsf               zExecutePreprocessor.run_cell)N)N)N)r)&r0r1r2r3r rÚtagrFr rzrr|rMrirjrrrErDrr€rrPr r?r rBr rXrUrr\r`rmrwrargr5rr)rrr6@sx             # B" r6NcKs6i}|dk rd|i|d<tf|Ž}|j|||ddS)a0Execute a notebook's code, updating outputs within the notebook object. This is a convenient wrapper around ExecutePreprocessor. 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 : KernelManager, optional If supplied, the specified kernel manager will be used for code execution. kwargs : Any other options for ExecutePreprocessor, e.g. timeout, kernel_name NrVrH)rSr)r6r`)rGrWrSrRrZZeprrrÚ executenbs   r‡)NN)r3ÚtextwraprÚ contextlibrZqueuerrAZQueueZ traitletsrrrrr r r r r Z nbformat.v4rÚbaserZutils.exceptionsrrr*r6r‡rrrrÚs"  ,   'D