kernel.js
584 lines
| 19.6 KiB
| application/javascript
|
JavascriptLexer
|
r4609 | //---------------------------------------------------------------------------- | ||
// Copyright (C) 2008-2011 The IPython Development Team | ||||
// | ||||
// Distributed under the terms of the BSD License. The full license is in | ||||
// the file COPYING, distributed as part of this software. | ||||
//---------------------------------------------------------------------------- | ||||
|
r4349 | |||
//============================================================================ | ||||
// Kernel | ||||
//============================================================================ | ||||
|
r8768 | /** | ||
* @module IPython | ||||
* @namespace IPython | ||||
* @submodule Kernel | ||||
*/ | ||||
|
r4352 | var IPython = (function (IPython) { | ||
|
r13187 | "use strict"; | ||
|
r4352 | var utils = IPython.utils; | ||
|
r7168 | // Initialization and connection. | ||
|
r8768 | /** | ||
* A Kernel Class to communicate with the Python kernel | ||||
* @Class Kernel | ||||
*/ | ||||
|
r13035 | var Kernel = function (base_url) { | ||
|
r4352 | this.kernel_id = null; | ||
|
r4545 | this.shell_channel = null; | ||
this.iopub_channel = null; | ||||
|
r10366 | this.stdin_channel = null; | ||
|
r7168 | this.base_url = base_url; | ||
|
r4545 | this.running = false; | ||
|
r13102 | this.username = "username"; | ||
|
r13035 | this.session_id = utils.uuid(); | ||
|
r7168 | this._msg_callbacks = {}; | ||
|
r4612 | if (typeof(WebSocket) !== 'undefined') { | ||
|
r5479 | this.WebSocket = WebSocket; | ||
|
r4612 | } else if (typeof(MozWebSocket) !== 'undefined') { | ||
|
r5479 | this.WebSocket = MozWebSocket; | ||
|
r4611 | } else { | ||
|
r5253 | alert('Your browser does not have WebSocket support, please try Chrome, Safari or Firefox ≥ 6. Firefox 4 and 5 are also supported by you have to enable WebSockets in about:config.'); | ||
|
r13187 | } | ||
|
r11611 | this.bind_events(); | ||
|
r13187 | this.init_iopub_handlers(); | ||
|
r13221 | this.comm_manager = new IPython.CommManager(this); | ||
|
r4352 | }; | ||
|
r13217 | Kernel.prototype._get_msg = function (msg_type, content, metadata) { | ||
|
r4352 | var msg = { | ||
header : { | ||||
msg_id : utils.uuid(), | ||||
|
r4694 | username : this.username, | ||
|
r13035 | session : this.session_id, | ||
|
r4352 | msg_type : msg_type | ||
}, | ||||
|
r13217 | metadata : metadata || {}, | ||
|
r4352 | content : content, | ||
parent_header : {} | ||||
}; | ||||
return msg; | ||||
|
r5479 | }; | ||
|
r11611 | |||
|
r13187 | Kernel.prototype.bind_events = function () { | ||
|
r11611 | var that = this; | ||
$([IPython.events]).on('send_input_reply.Kernel', function(evt, data) { | ||||
that.send_input_reply(data); | ||||
}); | ||||
|
r13187 | }; | ||
// Initialize the iopub handlers | ||||
Kernel.prototype.init_iopub_handlers = function () { | ||||
var output_types = ['stream', 'display_data', 'pyout', 'pyerr']; | ||||
this._iopub_handlers = {}; | ||||
this.register_iopub_handler('status', $.proxy(this._handle_status_message, this)); | ||||
this.register_iopub_handler('clear_output', $.proxy(this._handle_clear_output, this)); | ||||
for (var i=0; i < output_types.length; i++) { | ||||
this.register_iopub_handler(output_types[i], $.proxy(this._handle_output_message, this)); | ||||
} | ||||
}; | ||||
|
r4352 | |||
|
r8768 | /** | ||
* Start the Python kernel | ||||
* @method start | ||||
*/ | ||||
|
r13103 | Kernel.prototype.start = function (params) { | ||
params = params || {}; | ||||
if (!this.running) { | ||||
var qs = $.param(params); | ||||
var url = this.base_url + '?' + qs; | ||||
$.post(url, | ||||
$.proxy(this._kernel_started, this), | ||||
'json' | ||||
); | ||||
|
r13187 | } | ||
|
r13103 | }; | ||
|
r4545 | |||
|
r8768 | /** | ||
* Restart the python kernel. | ||||
* | ||||
* Emit a 'status_restarting.Kernel' event with | ||||
* the current object as parameter | ||||
* | ||||
* @method restart | ||||
*/ | ||||
|
r7168 | Kernel.prototype.restart = function () { | ||
|
r8677 | $([IPython.events]).trigger('status_restarting.Kernel', {kernel: this}); | ||
|
r4545 | if (this.running) { | ||
this.stop_channels(); | ||||
|
r13693 | var url = utils.url_join_encode(this.kernel_url, "restart"); | ||
|
r4545 | $.post(url, | ||
|
r13103 | $.proxy(this._kernel_started, this), | ||
|
r4545 | 'json' | ||
); | ||||
|
r13187 | } | ||
|
r4352 | }; | ||
|
r7168 | Kernel.prototype._kernel_started = function (json) { | ||
|
r13015 | console.log("Kernel started: ", json.id); | ||
|
r4545 | this.running = true; | ||
|
r13015 | this.kernel_id = json.id; | ||
|
r10807 | var ws_url = json.ws_url; | ||
|
r13187 | if (ws_url.match(/wss?:\/\//) === null) { | ||
|
r10979 | // trailing 's' in https will become wss for secure web sockets | ||
|
r13187 | var prot = location.protocol.replace('http', 'ws') + "//"; | ||
|
r10979 | ws_url = prot + location.host + ws_url; | ||
|
r13187 | } | ||
|
r10807 | this.ws_url = ws_url; | ||
|
r13693 | this.kernel_url = utils.url_join_encode(this.base_url, this.kernel_id); | ||
|
r4545 | this.start_channels(); | ||
|
r4352 | }; | ||
|
r7168 | |||
|
r9222 | Kernel.prototype._websocket_closed = function(ws_url, early) { | ||
this.stop_channels(); | ||||
|
r13103 | $([IPython.events]).trigger('websocket_closed.Kernel', | ||
|
r9222 | {ws_url: ws_url, kernel: this, early: early} | ||
); | ||||
|
r5479 | }; | ||
|
r4352 | |||
|
r8768 | /** | ||
* Start the `shell`and `iopub` channels. | ||||
* Will stop and restart them if they already exist. | ||||
* | ||||
* @method start_channels | ||||
*/ | ||||
|
r4545 | Kernel.prototype.start_channels = function () { | ||
|
r5253 | var that = this; | ||
|
r4545 | this.stop_channels(); | ||
|
r4572 | var ws_url = this.ws_url + this.kernel_url; | ||
|
r9222 | console.log("Starting WebSockets:", ws_url); | ||
|
r4611 | this.shell_channel = new this.WebSocket(ws_url + "/shell"); | ||
|
r10366 | this.stdin_channel = new this.WebSocket(ws_url + "/stdin"); | ||
|
r4611 | this.iopub_channel = new this.WebSocket(ws_url + "/iopub"); | ||
|
r12254 | |||
|
r5253 | var already_called_onclose = false; // only alert once | ||
|
r8839 | var ws_closed_early = function(evt){ | ||
|
r5253 | if (already_called_onclose){ | ||
return; | ||||
} | ||||
already_called_onclose = true; | ||||
if ( ! evt.wasClean ){ | ||||
|
r5255 | that._websocket_closed(ws_url, true); | ||
|
r5253 | } | ||
|
r5479 | }; | ||
|
r8839 | var ws_closed_late = function(evt){ | ||
|
r5253 | if (already_called_onclose){ | ||
return; | ||||
} | ||||
already_called_onclose = true; | ||||
if ( ! evt.wasClean ){ | ||||
|
r5255 | that._websocket_closed(ws_url, false); | ||
|
r5253 | } | ||
|
r5479 | }; | ||
|
r10366 | var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel]; | ||
for (var i=0; i < channels.length; i++) { | ||||
|
r12254 | channels[i].onopen = $.proxy(this._ws_opened, this); | ||
|
r10366 | channels[i].onclose = ws_closed_early; | ||
} | ||||
|
r5253 | // switch from early-close to late-close message after 1s | ||
|
r9222 | setTimeout(function() { | ||
|
r10366 | for (var i=0; i < channels.length; i++) { | ||
if (channels[i] !== null) { | ||||
channels[i].onclose = ws_closed_late; | ||||
} | ||||
|
r9222 | } | ||
|
r5253 | }, 1000); | ||
|
r10366 | this.shell_channel.onmessage = $.proxy(this._handle_shell_reply, this); | ||
|
r13187 | this.iopub_channel.onmessage = $.proxy(this._handle_iopub_message, this); | ||
|
r10366 | this.stdin_channel.onmessage = $.proxy(this._handle_input_request, this); | ||
|
r4545 | }; | ||
|
r4352 | |||
|
r8768 | /** | ||
|
r12254 | * Handle a websocket entering the open state | ||
* sends session and cookie authentication info as first message. | ||||
* Once all sockets are open, signal the Kernel.status_started event. | ||||
* @method _ws_opened | ||||
*/ | ||||
Kernel.prototype._ws_opened = function (evt) { | ||||
// send the session id so the Session object Python-side | ||||
// has the same identity | ||||
evt.target.send(this.session_id + ':' + document.cookie); | ||||
var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel]; | ||||
for (var i=0; i < channels.length; i++) { | ||||
// if any channel is not ready, don't trigger event. | ||||
if ( !channels[i].readyState ) return; | ||||
} | ||||
// all events ready, trigger started event. | ||||
$([IPython.events]).trigger('status_started.Kernel', {kernel: this}); | ||||
}; | ||||
/** | ||||
* Stop the websocket channels. | ||||
|
r8768 | * @method stop_channels | ||
*/ | ||||
|
r4545 | Kernel.prototype.stop_channels = function () { | ||
|
r10366 | var channels = [this.shell_channel, this.iopub_channel, this.stdin_channel]; | ||
for (var i=0; i < channels.length; i++) { | ||||
if ( channels[i] !== null ) { | ||||
|
r13187 | channels[i].onclose = null; | ||
|
r10366 | channels[i].close(); | ||
} | ||||
|
r13187 | } | ||
|
r10366 | this.shell_channel = this.iopub_channel = this.stdin_channel = null; | ||
|
r4545 | }; | ||
|
r7168 | // Main public methods. | ||
|
r13187 | |||
// send a message on the Kernel's shell channel | ||||
|
r13217 | Kernel.prototype.send_shell_message = function (msg_type, content, callbacks, metadata) { | ||
var msg = this._get_msg(msg_type, content, metadata); | ||||
|
r13187 | this.shell_channel.send(JSON.stringify(msg)); | ||
this.set_callbacks_for_msg(msg.header.msg_id, callbacks); | ||||
return msg.header.msg_id; | ||||
|
r13207 | }; | ||
|
r7168 | |||
|
r8768 | /** | ||
|
r13208 | * Get info on an object | ||
|
r8768 | * | ||
* @param objname {string} | ||||
|
r13208 | * @param callback {function} | ||
* @method object_info | ||||
|
r8768 | * | ||
|
r13212 | * When calling this method, pass a callback function that expects one argument. | ||
* The callback will be passed the complete `object_info_reply` message documented | ||||
* [here](http://ipython.org/ipython-doc/dev/development/messaging.html#object-information) | ||||
|
r8768 | */ | ||
|
r13208 | Kernel.prototype.object_info = function (objname, callback) { | ||
var callbacks; | ||||
if (callback) { | ||||
callbacks = { shell : { reply : callback } }; | ||||
} | ||||
|
r13187 | if (typeof(objname) !== null && objname !== null) { | ||
|
r5409 | var content = { | ||
oname : objname.toString(), | ||||
|
r11694 | detail_level : 0, | ||
|
r5409 | }; | ||
|
r13187 | return this.send_shell_message("object_info_request", content, callbacks); | ||
|
r5409 | } | ||
return; | ||||
|
r13187 | }; | ||
|
r5397 | |||
|
r8768 | /** | ||
* Execute given code into kernel, and pass result to callback. | ||||
* | ||||
* @async | ||||
* @method execute | ||||
* @param {string} code | ||||
|
r13212 | * @param [callbacks] {Object} With the following keys (all optional) | ||
* @param callbacks.shell.reply {function} | ||||
* @param callbacks.shell.payload.[payload_name] {function} | ||||
* @param callbacks.iopub.output {function} | ||||
* @param callbacks.iopub.clear_output {function} | ||||
* @param callbacks.input {function} | ||||
|
r8768 | * @param {object} [options] | ||
* @param [options.silent=false] {Boolean} | ||||
* @param [options.user_expressions=empty_dict] {Dict} | ||||
* @param [options.user_variables=empty_list] {List od Strings} | ||||
* @param [options.allow_stdin=false] {Boolean} true|false | ||||
* | ||||
* @example | ||||
* | ||||
* The options object should contain the options for the execute call. Its default | ||||
* values are: | ||||
* | ||||
* options = { | ||||
* silent : true, | ||||
* user_variables : [], | ||||
* user_expressions : {}, | ||||
* allow_stdin : false | ||||
* } | ||||
* | ||||
* When calling this method pass a callbacks structure of the form: | ||||
* | ||||
* callbacks = { | ||||
|
r13212 | * shell : { | ||
* reply : execute_reply_callback, | ||||
* payload : { | ||||
* set_next_input : set_next_input_callback, | ||||
* } | ||||
* }, | ||||
* iopub : { | ||||
* output : output_callback, | ||||
* clear_output : clear_output_callback, | ||||
* }, | ||||
* input : raw_input_callback | ||||
|
r8768 | * } | ||
* | ||||
|
r13212 | * Each callback will be passed the entire message as a single arugment. | ||
* Payload handlers will be passed the corresponding payload and the execute_reply message. | ||||
|
r8768 | */ | ||
|
r7176 | Kernel.prototype.execute = function (code, callbacks, options) { | ||
|
r4352 | var content = { | ||
code : code, | ||||
|
r7176 | silent : true, | ||
|
r11857 | store_history : false, | ||
|
r4352 | user_variables : [], | ||
|
r4975 | user_expressions : {}, | ||
|
r10368 | allow_stdin : false | ||
|
r4352 | }; | ||
|
r10594 | callbacks = callbacks || {}; | ||
|
r13207 | if (callbacks.input !== undefined) { | ||
|
r10368 | content.allow_stdin = true; | ||
} | ||||
|
r13187 | $.extend(true, content, options); | ||
|
r8677 | $([IPython.events]).trigger('execution_request.Kernel', {kernel: this, content:content}); | ||
|
r13187 | return this.send_shell_message("execute_request", content, callbacks); | ||
|
r5479 | }; | ||
|
r4352 | |||
|
r8768 | /** | ||
|
r13212 | * When calling this method, pass a function to be called with the `complete_reply` message | ||
|
r13208 | * as its only argument when it arrives. | ||
|
r8768 | * | ||
|
r13208 | * `complete_reply` is documented | ||
|
r8768 | * [here](http://ipython.org/ipython-doc/dev/development/messaging.html#complete) | ||
* | ||||
* @method complete | ||||
* @param line {integer} | ||||
* @param cursor_pos {integer} | ||||
|
r13208 | * @param callback {function} | ||
|
r8768 | * | ||
*/ | ||||
|
r13208 | Kernel.prototype.complete = function (line, cursor_pos, callback) { | ||
var callbacks; | ||||
if (callback) { | ||||
callbacks = { shell : { reply : callback } }; | ||||
} | ||||
|
r4388 | var content = { | ||
text : '', | ||||
line : line, | ||||
|
r11695 | block : null, | ||
|
r4388 | cursor_pos : cursor_pos | ||
}; | ||||
|
r13187 | return this.send_shell_message("complete_request", content, callbacks); | ||
|
r5479 | }; | ||
|
r4388 | |||
|
r4352 | Kernel.prototype.interrupt = function () { | ||
|
r4545 | if (this.running) { | ||
|
r8677 | $([IPython.events]).trigger('status_interrupting.Kernel', {kernel: this}); | ||
|
r4545 | $.post(this.kernel_url + "/interrupt"); | ||
|
r13187 | } | ||
|
r4349 | }; | ||
|
r4496 | Kernel.prototype.kill = function () { | ||
|
r4545 | if (this.running) { | ||
this.running = false; | ||||
var settings = { | ||||
cache : false, | ||||
|
r5479 | type : "DELETE" | ||
|
r4545 | }; | ||
$.ajax(this.kernel_url, settings); | ||||
|
r13187 | } | ||
|
r4496 | }; | ||
|
r10368 | Kernel.prototype.send_input_reply = function (input) { | ||
|
r10366 | var content = { | ||
value : input, | ||||
}; | ||||
$([IPython.events]).trigger('input_reply.Kernel', {kernel: this, content:content}); | ||||
var msg = this._get_msg("input_reply", content); | ||||
this.stdin_channel.send(JSON.stringify(msg)); | ||||
return msg.header.msg_id; | ||||
}; | ||||
// Reply handlers | ||||
|
r7168 | |||
|
r13187 | Kernel.prototype.register_iopub_handler = function (msg_type, callback) { | ||
this._iopub_handlers[msg_type] = callback; | ||||
}; | ||||
Kernel.prototype.get_iopub_handler = function (msg_type) { | ||||
// get iopub handler for a specific message type | ||||
return this._iopub_handlers[msg_type]; | ||||
}; | ||||
|
r7168 | Kernel.prototype.get_callbacks_for_msg = function (msg_id) { | ||
|
r13187 | // get callbacks for a specific message | ||
return this._msg_callbacks[msg_id]; | ||||
|
r7168 | }; | ||
|
r12555 | Kernel.prototype.clear_callbacks_for_msg = function (msg_id) { | ||
if (this._msg_callbacks[msg_id] !== undefined ) { | ||||
delete this._msg_callbacks[msg_id]; | ||||
} | ||||
}; | ||||
|
r13207 | |||
/* Set callbacks for a particular message. | ||||
* Callbacks should be a struct of the following form: | ||||
* shell : { | ||||
* | ||||
* } | ||||
*/ | ||||
|
r7168 | Kernel.prototype.set_callbacks_for_msg = function (msg_id, callbacks) { | ||
|
r13187 | if (callbacks) { | ||
|
r13207 | // shallow-copy mapping, because we will modify it at the top level | ||
var cbcopy = this._msg_callbacks[msg_id] = {}; | ||||
cbcopy.shell = callbacks.shell; | ||||
cbcopy.iopub = callbacks.iopub; | ||||
cbcopy.input = callbacks.input; | ||||
this._msg_callbacks[msg_id] = cbcopy; | ||||
|
r13187 | } | ||
|
r12555 | }; | ||
|
r7168 | |||
Kernel.prototype._handle_shell_reply = function (e) { | ||||
|
r8839 | var reply = $.parseJSON(e.data); | ||
|
r8677 | $([IPython.events]).trigger('shell_reply.Kernel', {kernel: this, reply:reply}); | ||
|
r7168 | var content = reply.content; | ||
|
r7952 | var metadata = reply.metadata; | ||
|
r13207 | var parent_id = reply.parent_header.msg_id; | ||
var callbacks = this.get_callbacks_for_msg(parent_id); | ||||
if (!callbacks || !callbacks.shell) { | ||||
return; | ||||
|
r13187 | } | ||
|
r13207 | var shell_callbacks = callbacks.shell; | ||
// clear callbacks on shell | ||||
delete callbacks.shell; | ||||
delete callbacks.input; | ||||
if (!callbacks.iopub) { | ||||
this.clear_callbacks_for_msg(parent_id); | ||||
} | ||||
if (shell_callbacks.reply !== undefined) { | ||||
shell_callbacks.reply(reply); | ||||
} | ||||
if (content.payload && shell_callbacks.payload) { | ||||
this._handle_payloads(content.payload, shell_callbacks.payload, reply); | ||||
|
r7168 | } | ||
}; | ||||
|
r13207 | Kernel.prototype._handle_payloads = function (payloads, payload_callbacks, msg) { | ||
var l = payloads.length; | ||||
|
r7168 | // Payloads are handled by triggering events because we don't want the Kernel | ||
// to depend on the Notebook or Pager classes. | ||||
for (var i=0; i<l; i++) { | ||||
|
r13207 | var payload = payloads[i]; | ||
var callback = payload_callbacks[payload.source]; | ||||
if (callback) { | ||||
callback(payload, msg); | ||||
|
r7168 | } | ||
|
r13187 | } | ||
|
r7168 | }; | ||
|
r13187 | Kernel.prototype._handle_status_message = function (msg) { | ||
var execution_state = msg.content.execution_state; | ||||
|
r13231 | var parent_id = msg.parent_header.msg_id; | ||
// dispatch status msg callbacks, if any | ||||
var callbacks = this.get_callbacks_for_msg(parent_id); | ||||
if (callbacks && callbacks.iopub && callbacks.iopub.status) { | ||||
try { | ||||
callbacks.iopub.status(msg); | ||||
} catch (e) { | ||||
|
r14499 | console.log("Exception in status msg handler", e, e.stack); | ||
|
r13231 | } | ||
} | ||||
|
r13187 | if (execution_state === 'busy') { | ||
$([IPython.events]).trigger('status_busy.Kernel', {kernel: this}); | ||||
} else if (execution_state === 'idle') { | ||||
|
r13231 | // clear callbacks on idle, there can be no more | ||
|
r13207 | if (callbacks !== undefined) { | ||
delete callbacks.iopub; | ||||
delete callbacks.input; | ||||
if (!callbacks.shell) { | ||||
this.clear_callbacks_for_msg(parent_id); | ||||
} | ||||
} | ||||
|
r13231 | // trigger status_idle event | ||
|
r13187 | $([IPython.events]).trigger('status_idle.Kernel', {kernel: this}); | ||
} else if (execution_state === 'restarting') { | ||||
// autorestarting is distinct from restarting, | ||||
// in that it means the kernel died and the server is restarting it. | ||||
// status_restarting sets the notification widget, | ||||
// autorestart shows the more prominent dialog. | ||||
$([IPython.events]).trigger('status_autorestarting.Kernel', {kernel: this}); | ||||
$([IPython.events]).trigger('status_restarting.Kernel', {kernel: this}); | ||||
} else if (execution_state === 'dead') { | ||||
this.stop_channels(); | ||||
$([IPython.events]).trigger('status_dead.Kernel', {kernel: this}); | ||||
} | ||||
}; | ||||
// handle clear_output message | ||||
Kernel.prototype._handle_clear_output = function (msg) { | ||||
var callbacks = this.get_callbacks_for_msg(msg.parent_header.msg_id); | ||||
|
r13207 | if (!callbacks || !callbacks.iopub) { | ||
|
r13187 | return; | ||
} | ||||
|
r13214 | var callback = callbacks.iopub.clear_output; | ||
|
r13207 | if (callback) { | ||
callback(msg); | ||||
|
r13187 | } | ||
}; | ||||
|
r7168 | |||
|
r13187 | |||
// handle an output message (pyout, display_data, etc.) | ||||
Kernel.prototype._handle_output_message = function (msg) { | ||||
var callbacks = this.get_callbacks_for_msg(msg.parent_header.msg_id); | ||||
|
r13207 | if (!callbacks || !callbacks.iopub) { | ||
|
r7168 | return; | ||
} | ||||
|
r13207 | var callback = callbacks.iopub.output; | ||
if (callback) { | ||||
callback(msg); | ||||
|
r13187 | } | ||
}; | ||||
// dispatch IOPub messages to respective handlers. | ||||
// each message type should have a handler. | ||||
Kernel.prototype._handle_iopub_message = function (e) { | ||||
var msg = $.parseJSON(e.data); | ||||
var handler = this.get_iopub_handler(msg.header.msg_type); | ||||
if (handler !== undefined) { | ||||
handler(msg); | ||||
} | ||||
|
r7168 | }; | ||
|
r10366 | Kernel.prototype._handle_input_request = function (e) { | ||
var request = $.parseJSON(e.data); | ||||
var header = request.header; | ||||
var content = request.content; | ||||
var metadata = request.metadata; | ||||
var msg_type = header.msg_type; | ||||
if (msg_type !== 'input_request') { | ||||
console.log("Invalid input request!", request); | ||||
return; | ||||
} | ||||
|
r10368 | var callbacks = this.get_callbacks_for_msg(request.parent_header.msg_id); | ||
|
r13207 | if (callbacks) { | ||
if (callbacks.input) { | ||||
callbacks.input(request); | ||||
|
r10368 | } | ||
|
r13187 | } | ||
|
r10366 | }; | ||
|
r4352 | IPython.Kernel = Kernel; | ||
return IPython; | ||||
}(IPython)); | ||||