Merge pull request #7757 from jasongrout/custom-serialization

Custom serialization

IPython/html/static/widgets/js/init.js

@@ -1,34 +1,34 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     "widgets/js/manager",
+    "widgets/js/widget",
     "widgets/js/widget_link",
     "widgets/js/widget_bool",
     "widgets/js/widget_button",
     "widgets/js/widget_box",
     "widgets/js/widget_float",
     "widgets/js/widget_image",
     "widgets/js/widget_int",
     "widgets/js/widget_output",
     "widgets/js/widget_selection",
     "widgets/js/widget_selectioncontainer",
     "widgets/js/widget_string",
-], function(widgetmanager, linkModels) {
-    for (var target_name in linkModels) {
-        if (linkModels.hasOwnProperty(target_name)) {
-            widgetmanager.WidgetManager.register_widget_model(target_name, linkModels[target_name]);
-        }
-    }
-
-    // Register all of the loaded views with the widget manager.
+], function(widgetmanager, widget) {
+    // Register all of the loaded models and views with the widget manager.
     for (var i = 2; i < arguments.length; i++) {
-        for (var target_name in arguments[i]) {
-            if (arguments[i].hasOwnProperty(target_name)) {
-                widgetmanager.WidgetManager.register_widget_view(target_name, arguments[i][target_name]);
+        var module = arguments[i];
+        for (var target_name in module) {
+            if (module.hasOwnProperty(target_name)) {
+                var target = module[target_name];
+                if (target.prototype instanceof widget.WidgetModel) {
+                    widgetmanager.WidgetManager.register_widget_model(target_name, target);
+                } else if (target.prototype instanceof widget.WidgetView) {
+                    widgetmanager.WidgetManager.register_widget_view(target_name, target);
+                }
             }
         }
     }
-
     return {'WidgetManager': widgetmanager.WidgetManager}; 
 });

IPython/html/static/widgets/js/widget.js

@@ -1,763 +1,780 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define(["widgets/js/manager",
         "underscore",
         "backbone",
         "jquery",
         "base/js/utils",
         "base/js/namespace",
 ], function(widgetmanager, _, Backbone, $, utils, IPython){
     "use strict";
 
     var WidgetModel = Backbone.Model.extend({
         constructor: function (widget_manager, model_id, comm) {
             /**
              * Constructor
              *
              * Creates a WidgetModel instance.
              *
              * Parameters
              * ----------
              * widget_manager : WidgetManager instance
              * model_id : string
              *      An ID unique to this model.
              * comm : Comm instance (optional)
              */
             this.widget_manager = widget_manager;
             this.state_change = Promise.resolve();
             this._buffered_state_diff = {};
             this.pending_msgs = 0;
             this.msg_buffer = null;
             this.state_lock = null;
             this.id = model_id;
             this.views = {};
             this._resolve_received_state = {};
 
             if (comm !== undefined) {
                 // Remember comm associated with the model.
                 this.comm = comm;
                 comm.model = this;
 
                 // Hook comm messages up to model.
                 comm.on_close($.proxy(this._handle_comm_closed, this));
                 comm.on_msg($.proxy(this._handle_comm_msg, this));
 
                 // Assume the comm is alive.
                 this.set_comm_live(true);
             } else {
                 this.set_comm_live(false);
             }
 
             // Listen for the events that lead to the websocket being terminated.
             var that = this;
             var died = function() {
                 that.set_comm_live(false);
             };
             widget_manager.notebook.events.on('kernel_disconnected.Kernel', died);
             widget_manager.notebook.events.on('kernel_killed.Kernel', died);
             widget_manager.notebook.events.on('kernel_restarting.Kernel', died);
             widget_manager.notebook.events.on('kernel_dead.Kernel', died);
 
             return Backbone.Model.apply(this);
         },
 
-        send: function (content, callbacks) {
+        send: function (content, callbacks, buffers) {
             /**
              * Send a custom msg over the comm.
              */
             if (this.comm !== undefined) {
                 var data = {method: 'custom', content: content};
-                this.comm.send(data, callbacks);
+                this.comm.send(data, callbacks, {}, buffers);
                 this.pending_msgs++;
             }
         },
 
         request_state: function(callbacks) {
             /** 
              * Request a state push from the back-end.
              */
             if (!this.comm) {
                 console.error("Could not request_state because comm doesn't exist!");
                 return;
             }
 
             var msg_id = this.comm.send({method: 'request_state'}, callbacks || this.widget_manager.callbacks());
 
             // Promise that is resolved when a state is received
             // from the back-end.
             var that = this;
             var received_state = new Promise(function(resolve) {
                 that._resolve_received_state[msg_id] = resolve;
             });
             return received_state;
         },
 
         set_comm_live: function(live) {
             /** 
              * Change the comm_live state of the model.
              */
             if (this.comm_live === undefined || this.comm_live != live) {
                 this.comm_live = live;
                 this.trigger(live ? 'comm:live' : 'comm:dead', {model: this});
             }
         },
 
         close: function(comm_closed) {
             /**
              * Close model
              */
             if (this.comm && !comm_closed) {
                 this.comm.close();
             }
             this.stopListening();
             this.trigger('destroy', this);
             delete this.comm.model; // Delete ref so GC will collect widget model.
             delete this.comm;
             delete this.model_id; // Delete id from model so widget manager cleans up.
             _.each(this.views, function(v, id, views) {
                 v.then(function(view) {
                     view.remove();
                     delete views[id];
                 });
             });
         },
 
         _handle_comm_closed: function (msg) {
             /** 
              * Handle when a widget is closed.
              */
             this.trigger('comm:close');
             this.close(true);
         },
 
         _handle_comm_msg: function (msg) {
             /**
              * Handle incoming comm msg.
              */
             var method = msg.content.data.method;
+            
             var that = this;
             switch (method) {
                 case 'update':
                     this.state_change = this.state_change
                         .then(function() {
-                            return that.set_state(msg.content.data.state);
+                            var state = msg.content.data.state || {};
+                            var buffer_keys = msg.content.data.buffers || [];
+                            var buffers = msg.buffers || [];
+                            for (var i=0; i<buffer_keys.length; i++) {
+                                state[buffer_keys[i]] = buffers[i];
+                            }
+
+                            // deserialize fields that have custom deserializers
+                            var serializers = that.constructor.serializers;
+                            if (serializers) {
+                                for (var k in state) {
+                                    if (serializers[k] && serializers[k].deserialize) {
+                                        state[k] = (serializers[k].deserialize)(state[k], that);
+                                    }
+                                }
+                            }
+                            return utils.resolve_promises_dict(state);
+                        }).then(function(state) {
+                            return that.set_state(state);
                         }).catch(utils.reject("Couldn't process update msg for model id '" + String(that.id) + "'", true))
                         .then(function() {
                             var parent_id = msg.parent_header.msg_id;
                             if (that._resolve_received_state[parent_id] !== undefined) {
                                 that._resolve_received_state[parent_id].call();
                                 delete that._resolve_received_state[parent_id];
                             }
                         }).catch(utils.reject("Couldn't resolve state request promise", true));
                     break;
                 case 'custom':
-                    this.trigger('msg:custom', msg.content.data.content);
+                    this.trigger('msg:custom', msg.content.data.content, msg.buffers);
                     break;
                 case 'display':
                     this.state_change = this.state_change.then(function() {
                         that.widget_manager.display_view(msg, that);
                     }).catch(utils.reject('Could not process display view msg', true));
                     break;
             }
         },
 
         set_state: function (state) {
             var that = this;
             // Handle when a widget is updated via the python side.
-            return this._unpack_models(state).then(function(state) {
+            return new Promise(function(resolve, reject) {
                 that.state_lock = state;
                 try {
                     WidgetModel.__super__.set.call(that, state);
                 } finally {
                     that.state_lock = null;
                 }
+                resolve();
             }).catch(utils.reject("Couldn't set model state", true));
         },
 
         get_state: function() {
             // Get the serializable state of the model.
-            var state = this.toJSON();
-            for (var key in state) {
-                if (state.hasOwnProperty(key)) {
-                    state[key] = this._pack_models(state[key]);
-                }
-            }
-            return state;
+            // Equivalent to Backbone.Model.toJSON()
+            return _.clone(this.attributes);
         },
-
+        
         _handle_status: function (msg, callbacks) {
             /**
              * Handle status msgs.
              *
              * execution_state : ('busy', 'idle', 'starting')
              */
             if (this.comm !== undefined) {
                 if (msg.content.execution_state ==='idle') {
                     // Send buffer if this message caused another message to be
                     // throttled.
                     if (this.msg_buffer !== null &&
                         (this.get('msg_throttle') || 3) === this.pending_msgs) {
                         var data = {method: 'backbone', sync_method: 'update', sync_data: this.msg_buffer};
                         this.comm.send(data, callbacks);
                         this.msg_buffer = null;
                     } else {
                         --this.pending_msgs;
                     }
                 }
             }
         },
 
         callbacks: function(view) {
             /**
              * Create msg callbacks for a comm msg.
              */
             var callbacks = this.widget_manager.callbacks(view);
 
             if (callbacks.iopub === undefined) {
                 callbacks.iopub = {};
             }
 
             var that = this;
             callbacks.iopub.status = function (msg) {
                 that._handle_status(msg, callbacks);
             };
             return callbacks;
         },
 
         set: function(key, val, options) {
             /**
              * Set a value.
              */
             var return_value = WidgetModel.__super__.set.apply(this, arguments);
 
             // Backbone only remembers the diff of the most recent set()
             // operation.  Calling set multiple times in a row results in a 
             // loss of diff information.  Here we keep our own running diff.
             this._buffered_state_diff = $.extend(this._buffered_state_diff, this.changedAttributes() || {});
             return return_value;
         },
 
         sync: function (method, model, options) {
             /**
              * Handle sync to the back-end.  Called when a model.save() is called.
              *
              * Make sure a comm exists.
+
+             * Parameters
+             * ----------
+             * method : create, update, patch, delete, read
+             *   create/update always send the full attribute set
+             *   patch - only send attributes listed in options.attrs, and if we are queuing
+             *     up messages, combine with previous messages that have not been sent yet
+             * model : the model we are syncing
+             *   will normally be the same as `this`
+             * options : dict
+             *   the `attrs` key, if it exists, gives an {attr: value} dict that should be synced,
+             *   otherwise, sync all attributes
+             * 
              */
             var error = options.error || function() {
                 console.error('Backbone sync error:', arguments);
             };
             if (this.comm === undefined) {
                 error();
                 return false;
             }
 
-            // Delete any key value pairs that the back-end already knows about.
-            var attrs = (method === 'patch') ? options.attrs : model.toJSON(options);
+            var attrs = (method === 'patch') ? options.attrs : model.get_state(options);
+
+            // the state_lock lists attributes that are currently be changed right now from a kernel message
+            // we don't want to send these non-changes back to the kernel, so we delete them out of attrs
+            // (but we only delete them if the value hasn't changed from the value stored in the state_lock
             if (this.state_lock !== null) {
                 var keys = Object.keys(this.state_lock);
                 for (var i=0; i<keys.length; i++) {
                     var key = keys[i];
                     if (attrs[key] === this.state_lock[key]) {
                         delete attrs[key];
                     }
                 }
             }
-
-            // Only sync if there are attributes to send to the back-end.
-            attrs = this._pack_models(attrs);
+            
             if (_.size(attrs) > 0) {
 
                 // If this message was sent via backbone itself, it will not
                 // have any callbacks.  It's important that we create callbacks
                 // so we can listen for status messages, etc...
                 var callbacks = options.callbacks || this.callbacks();
 
                 // Check throttle.
                 if (this.pending_msgs >= (this.get('msg_throttle') || 3)) {
                     // The throttle has been exceeded, buffer the current msg so
                     // it can be sent once the kernel has finished processing 
                     // some of the existing messages.
                     
                     // Combine updates if it is a 'patch' sync, otherwise replace updates
                     switch (method) {
                         case 'patch':
                             this.msg_buffer = $.extend(this.msg_buffer || {}, attrs);
                             break;
                         case 'update':
                         case 'create':
                             this.msg_buffer = attrs;
                             break;
                         default:
                             error();
                             return false;
                     }
                     this.msg_buffer_callbacks = callbacks;
 
                 } else {
                     // We haven't exceeded the throttle, send the message like 
                     // normal.
-                    var data = {method: 'backbone', sync_data: attrs};
-                    this.comm.send(data, callbacks);
+                    this.send_sync_message(attrs, callbacks);
                     this.pending_msgs++;
                 }
             }
             // Since the comm is a one-way communication, assume the message 
             // arrived.  Don't call success since we don't have a model back from the server
             // this means we miss out on the 'sync' event.
             this._buffered_state_diff = {};
         },
 
+
+        send_sync_message: function(attrs, callbacks) {
+            // prepare and send a comm message syncing attrs
+            var that = this;
+            // first, build a state dictionary with key=the attribute and the value
+            // being the value or the promise of the serialized value
+            var serializers = this.constructor.serializers;
+            if (serializers) {
+                for (k in attrs) {
+                    if (serializers[k] && serializers[k].serialize) {
+                        attrs[k] = (serializers[k].serialize)(attrs[k], this);
+                    }
+                }
+            }
+            utils.resolve_promises_dict(attrs).then(function(state) {
+                // get binary values, then send
+                var keys = Object.keys(state);
+                var buffers = [];
+                var buffer_keys = [];
+                for (var i=0; i<keys.length; i++) {
+                    var key = keys[i];
+                    var value = state[key];
+                    if (value.buffer instanceof ArrayBuffer
+                        || value instanceof ArrayBuffer) {
+                        buffers.push(value);
+                        buffer_keys.push(key);
+                        delete state[key];
+                    }
+                }
+                that.comm.send({method: 'backbone', sync_data: state, buffer_keys: buffer_keys}, callbacks, {}, buffers);
+            }).catch(function(error) {
+                that.pending_msgs--;
+                return (utils.reject("Couldn't send widget sync message", true))(error);
+            });
+        },
+        
         save_changes: function(callbacks) {
             /**
              * Push this model's state to the back-end
              *
              * This invokes a Backbone.Sync.
              */
             this.save(this._buffered_state_diff, {patch: true, callbacks: callbacks});
         },
 
-        _pack_models: function(value) {
-            /**
-             * Replace models with model ids recursively.
-             */
-            var that = this;
-            var packed;
-            if (value instanceof Backbone.Model) {
-                return "IPY_MODEL_" + value.id;
-
-            } else if ($.isArray(value)) {
-                packed = [];
-                _.each(value, function(sub_value, key) {
-                    packed.push(that._pack_models(sub_value));
-                });
-                return packed;
-            } else if (value instanceof Date || value instanceof String) {
-                return value;
-            } else if (value instanceof Object) {
-                packed = {};
-                _.each(value, function(sub_value, key) {
-                    packed[key] = that._pack_models(sub_value);
-                });
-                return packed;
-
-            } else {
-                return value;
-            }
-        },
-
-        _unpack_models: function(value) {
-            /**
-             * Replace model ids with models recursively.
-             */
-            var that = this;
-            var unpacked;
-            if ($.isArray(value)) {
-                unpacked = [];
-                _.each(value, function(sub_value, key) {
-                    unpacked.push(that._unpack_models(sub_value));
-                });
-                return Promise.all(unpacked);
-            } else if (value instanceof Object) {
-                unpacked = {};
-                _.each(value, function(sub_value, key) {
-                    unpacked[key] = that._unpack_models(sub_value);
-                });
-                return utils.resolve_promises_dict(unpacked);
-            } else if (typeof value === 'string' && value.slice(0,10) === "IPY_MODEL_") {
-                // get_model returns a promise already
-                return this.widget_manager.get_model(value.slice(10, value.length));
-            } else {
-                return Promise.resolve(value);
-            }
-        },
-
         on_some_change: function(keys, callback, context) {
             /**
              * on_some_change(["key1", "key2"], foo, context) differs from
              * on("change:key1 change:key2", foo, context).
              * If the widget attributes key1 and key2 are both modified, 
              * the second form will result in foo being called twice
              * while the first will call foo only once.
              */
             this.on('change', function() {
                 if (keys.some(this.hasChanged, this)) {
                     callback.apply(context);
                 }
             }, this);
 
-       },
+        },
+
+        toJSON: function(options) {
+            /**
+             * Serialize the model.  See the types.js deserialization function
+             * and the kernel-side serializer/deserializer
+             */
+            return "IPY_MODEL_"+this.id;
+        }
     });
     widgetmanager.WidgetManager.register_widget_model('WidgetModel', WidgetModel);
 
 
     var WidgetView = Backbone.View.extend({
         initialize: function(parameters) {
             /**
              * Public constructor.
              */
             this.model.on('change',this.update,this);
 
             // Bubble the comm live events.
             this.model.on('comm:live', function() {
                 this.trigger('comm:live', this);
             }, this);
             this.model.on('comm:dead', function() {
                 this.trigger('comm:dead', this);
             }, this);
 
             this.options = parameters.options;
             this.on('displayed', function() { 
                 this.is_displayed = true; 
             }, this);
         },
 
         update: function(){
             /**
              * Triggered on model change.
              *
              * Update view to be consistent with this.model
              */
         },
 
         create_child_view: function(child_model, options) {
             /**
              * Create and promise that resolves to a child view of a given model
              */
             var that = this;
             options = $.extend({ parent: this }, options || {});
-            return this.model.widget_manager.create_view(child_model, options).catch(utils.reject("Couldn't create child view"), true);
+            return this.model.widget_manager.create_view(child_model, options).catch(utils.reject("Couldn't create child view", true));
         },
 
         callbacks: function(){
             /**
              * Create msg callbacks for a comm msg.
              */
             return this.model.callbacks(this);
         },
 
         render: function(){
             /**
              * Render the view.
              *
              * By default, this is only called the first time the view is created
              */
         },
 
-        send: function (content) {
+        send: function (content, buffers) {
             /**
              * Send a custom msg associated with this view.
              */
-            this.model.send(content, this.callbacks());
+            this.model.send(content, this.callbacks(), buffers);
         },
 
         touch: function () {
             this.model.save_changes(this.callbacks());
         },
 
         after_displayed: function (callback, context) {
             /**
              * Calls the callback right away is the view is already displayed
              * otherwise, register the callback to the 'displayed' event.
              */
             if (this.is_displayed) {
                 callback.apply(context);
             } else {
                 this.on('displayed', callback, context);
             }
         },
 
         remove: function () {
             // Raise a remove event when the view is removed.
             WidgetView.__super__.remove.apply(this, arguments);
             this.trigger('remove');
         }
     });
 
 
     var DOMWidgetView = WidgetView.extend({
         initialize: function (parameters) {
             /**
              * Public constructor
              */
             DOMWidgetView.__super__.initialize.apply(this, [parameters]);
             this.model.on('change:visible', this.update_visible, this);
             this.model.on('change:_css', this.update_css, this);
 
             this.model.on('change:_dom_classes', function(model, new_classes) {
                 var old_classes = model.previous('_dom_classes');
                 this.update_classes(old_classes, new_classes);
             }, this);
 
             this.model.on('change:color', function (model, value) { 
                 this.update_attr('color', value); }, this);
 
             this.model.on('change:background_color', function (model, value) { 
                 this.update_attr('background', value); }, this);
 
             this.model.on('change:width', function (model, value) { 
                 this.update_attr('width', value); }, this);
 
             this.model.on('change:height', function (model, value) { 
                 this.update_attr('height', value); }, this);
 
             this.model.on('change:border_color', function (model, value) { 
                 this.update_attr('border-color', value); }, this);
 
             this.model.on('change:border_width', function (model, value) { 
                 this.update_attr('border-width', value); }, this);
 
             this.model.on('change:border_style', function (model, value) { 
                 this.update_attr('border-style', value); }, this);
 
             this.model.on('change:font_style', function (model, value) { 
                 this.update_attr('font-style', value); }, this);
 
             this.model.on('change:font_weight', function (model, value) { 
                 this.update_attr('font-weight', value); }, this);
 
             this.model.on('change:font_size', function (model, value) { 
                 this.update_attr('font-size', this._default_px(value)); }, this);
 
             this.model.on('change:font_family', function (model, value) { 
                 this.update_attr('font-family', value); }, this);
 
             this.model.on('change:padding', function (model, value) { 
                 this.update_attr('padding', value); }, this);
 
             this.model.on('change:margin', function (model, value) { 
                 this.update_attr('margin', this._default_px(value)); }, this);
 
             this.model.on('change:border_radius', function (model, value) { 
                 this.update_attr('border-radius', this._default_px(value)); }, this);
 
             this.after_displayed(function() {
                 this.update_visible(this.model, this.model.get("visible"));
                 this.update_classes([], this.model.get('_dom_classes'));
                 
                 this.update_attr('color', this.model.get('color'));
                 this.update_attr('background', this.model.get('background_color'));
                 this.update_attr('width', this.model.get('width'));
                 this.update_attr('height', this.model.get('height'));
                 this.update_attr('border-color', this.model.get('border_color'));
                 this.update_attr('border-width', this.model.get('border_width'));
                 this.update_attr('border-style', this.model.get('border_style'));
                 this.update_attr('font-style', this.model.get('font_style'));
                 this.update_attr('font-weight', this.model.get('font_weight'));
                 this.update_attr('font-size', this._default_px(this.model.get('font_size')));
                 this.update_attr('font-family', this.model.get('font_family'));
                 this.update_attr('padding', this.model.get('padding'));
                 this.update_attr('margin', this._default_px(this.model.get('margin')));
                 this.update_attr('border-radius', this._default_px(this.model.get('border_radius')));
 
                 this.update_css(this.model, this.model.get("_css"));
             }, this);
         },
 
         _default_px: function(value) {
             /**
              * Makes browser interpret a numerical string as a pixel value.
              */
-            if (/^\d+\.?(\d+)?$/.test(value.trim())) {
+            if (value && /^\d+\.?(\d+)?$/.test(value.trim())) {
                 return value.trim() + 'px';
             }
             return value;
         },
 
         update_attr: function(name, value) {
             /**
              * Set a css attr of the widget view.
              */
             this.$el.css(name, value);
         },
 
         update_visible: function(model, value) {
             /**
              * Update visibility
              */
             switch(value) {
                 case null: // python None
                     this.$el.show().css('visibility', 'hidden'); break;
                 case false:
                     this.$el.hide(); break;
                 case true:
                     this.$el.show().css('visibility', ''); break;
             }
          },
 
         update_css: function (model, css) {
             /**
              * Update the css styling of this view.
              */
             if (css === undefined) {return;}
             for (var i = 0; i < css.length; i++) {
                 // Apply the css traits to all elements that match the selector.
                 var selector = css[i][0];
                 var elements = this._get_selector_element(selector);
                 if (elements.length > 0) {
                     var trait_key = css[i][1];
                     var trait_value = css[i][2];
                     elements.css(trait_key ,trait_value);
                 }
             }
         },
 
         update_classes: function (old_classes, new_classes, $el) {
             /**
              * Update the DOM classes applied to an element, default to this.$el.
              */
             if ($el===undefined) {
                 $el = this.$el;
             }
             _.difference(old_classes, new_classes).map(function(c) {$el.removeClass(c);})
             _.difference(new_classes, old_classes).map(function(c) {$el.addClass(c);})
         },
 
         update_mapped_classes: function(class_map, trait_name, previous_trait_value, $el) {
             /**
              * Update the DOM classes applied to the widget based on a single
              * trait's value.
              *
              * Given a trait value classes map, this function automatically
              * handles applying the appropriate classes to the widget element
              * and removing classes that are no longer valid.
              *
              * Parameters
              * ----------
              * class_map: dictionary
              *  Dictionary of trait values to class lists.
              *  Example:
              *      {
              *          success: ['alert', 'alert-success'],
              *          info: ['alert', 'alert-info'],
              *          warning: ['alert', 'alert-warning'],
              *          danger: ['alert', 'alert-danger']
              *      };
              * trait_name: string
              *  Name of the trait to check the value of.
              * previous_trait_value: optional string, default ''
              *  Last trait value
              * $el: optional jQuery element handle, defaults to this.$el
              *  Element that the classes are applied to.
              */
             var key = previous_trait_value;
             if (key === undefined) {
                 key = this.model.previous(trait_name);
             }
             var old_classes = class_map[key] ? class_map[key] : [];
             key = this.model.get(trait_name);
             var new_classes = class_map[key] ? class_map[key] : [];
 
             this.update_classes(old_classes, new_classes, $el || this.$el);
         },
         
         _get_selector_element: function (selector) {
             /**
              * Get the elements via the css selector.
              */
             var elements;
             if (!selector) {
                 elements = this.$el;
             } else {
                 elements = this.$el.find(selector).addBack(selector);
             }
             return elements;
         },
 
         typeset: function(element, text){
             utils.typeset.apply(null, arguments);
         },
     });
 
 
     var ViewList = function(create_view, remove_view, context) {
         /**
          * - create_view and remove_view are default functions called when adding or removing views
          * - create_view takes a model and returns a view or a promise for a view for that model
          * - remove_view takes a view and destroys it (including calling `view.remove()`)
          * - each time the update() function is called with a new list, the create and remove
          *   callbacks will be called in an order so that if you append the views created in the
          *   create callback and remove the views in the remove callback, you will duplicate 
          *   the order of the list.
          * - the remove callback defaults to just removing the view (e.g., pass in null for the second parameter)
          * - the context defaults to the created ViewList.  If you pass another context, the create and remove
          *   will be called in that context.
          */
 
         this.initialize.apply(this, arguments);
     };
 
     _.extend(ViewList.prototype, {
         initialize: function(create_view, remove_view, context) {
             this._handler_context = context || this;
             this._models = [];
             this.views = []; // list of promises for views
             this._create_view = create_view;
             this._remove_view = remove_view || function(view) {view.remove();};
         },
 
         update: function(new_models, create_view, remove_view, context) {
             /**
              * the create_view, remove_view, and context arguments override the defaults
              * specified when the list is created.
              * after this function, the .views attribute is a list of promises for views
              * if you want to perform some action on the list of views, do something like
              * `Promise.all(myviewlist.views).then(function(views) {...});`
              */
             var remove = remove_view || this._remove_view;
             var create = create_view || this._create_view;
             context = context || this._handler_context;
             var i = 0;
             // first, skip past the beginning of the lists if they are identical
             for (; i < new_models.length; i++) {
                 if (i >= this._models.length || new_models[i] !== this._models[i]) {
                     break;
                 }
             }
             
             var first_removed = i;
             // Remove the non-matching items from the old list.
             var removed = this.views.splice(first_removed, this.views.length-first_removed);
             for (var j = 0; j < removed.length; j++) {
                 removed[j].then(function(view) {
                     remove.call(context, view)
                 });
             }
 
             // Add the rest of the new list items.
             for (; i < new_models.length; i++) {
                 this.views.push(Promise.resolve(create.call(context, new_models[i])));
             }
             // make a copy of the input array
             this._models = new_models.slice();
         },
 
         remove: function() {
             /**
              * removes every view in the list; convenience function for `.update([])`
              * that should be faster
              * returns a promise that resolves after this removal is done
              */
             var that = this;
             return Promise.all(this.views).then(function(views) {
                 for (var i = 0; i < that.views.length; i++) {
                     that._remove_view.call(that._handler_context, views[i]);
                 }
                 that.views = [];
                 that._models = [];
             });
         },
     });
 
     var widget = {
         'WidgetModel': WidgetModel,
         'WidgetView': WidgetView,
         'DOMWidgetView': DOMWidgetView,
         'ViewList': ViewList,
     };
 
     // For backwards compatability.
     $.extend(IPython, widget);
 
     return widget;
 });

IPython/html/static/widgets/js/widget_box.js

@@ -1,154 +1,187 b''
 // Copyright (c) IPython Development Team.
 // Distributed under the terms of the Modified BSD License.
 
 define([
     "widgets/js/widget",
     "jqueryui",
+    "underscore",
     "base/js/utils",
     "bootstrap",
-], function(widget, $, utils){
+], function(widget, $, _, utils){
     "use strict";
+    var unpack_models = function unpack_models(value, model) {
+        /**
+         * Replace model ids with models recursively.
+         */
+        var unpacked;
+        if ($.isArray(value)) {
+            unpacked = [];
+            _.each(value, function(sub_value, key) {
+                unpacked.push(unpack_models(sub_value, model));
+            });
+            return Promise.all(unpacked);
+        } else if (value instanceof Object) {
+            unpacked = {};
+            _.each(value, function(sub_value, key) {
+                unpacked[key] = unpack_models(sub_value, model);
+            });
+            return utils.resolve_promises_dict(unpacked);
+        } else if (typeof value === 'string' && value.slice(0,10) === "IPY_MODEL_") {
+            // get_model returns a promise already
+            return model.widget_manager.get_model(value.slice(10, value.length));
+        } else {
+            return Promise.resolve(value);
+        }
+    };
+
+    var BoxModel = widget.WidgetModel.extend({}, {
+        serializers: _.extend({
+            children: {deserialize: unpack_models}
+        }, widget.WidgetModel.serializers)
+    });
 
     var BoxView = widget.DOMWidgetView.extend({
         initialize: function(){
             /**
              * Public constructor
              */
             BoxView.__super__.initialize.apply(this, arguments);
             this.children_views = new widget.ViewList(this.add_child_model, null, this);
             this.listenTo(this.model, 'change:children', function(model, value) {
                 this.children_views.update(value);
             }, this);
             this.listenTo(this.model, 'change:overflow_x', function(model, value) {
                 this.update_overflow_x();
             }, this);
             this.listenTo(this.model, 'change:overflow_y', function(model, value) {
                 this.update_overflow_y();
             }, this);
             this.listenTo(this.model, 'change:box_style', function(model, value) {
                 this.update_box_style();
             }, this);
         },
 
         update_attr: function(name, value) {
             /**
              * Set a css attr of the widget view.
              */
             this.$box.css(name, value);
         },
 
         render: function(){
             /**
              * Called when view is rendered.
              */
             this.$box = this.$el;
             this.$box.addClass('widget-box');
             this.children_views.update(this.model.get('children'));
             this.update_overflow_x();
             this.update_overflow_y();
             this.update_box_style('');
         },
 
         update_overflow_x: function() {
             /**
              * Called when the x-axis overflow setting is changed.
              */
             this.$box.css('overflow-x', this.model.get('overflow_x'));
         },
 
         update_overflow_y: function() {
             /**
              * Called when the y-axis overflow setting is changed.
              */
             this.$box.css('overflow-y', this.model.get('overflow_y'));
         },
 
         update_box_style: function(previous_trait_value) {
             var class_map = {
                 success: ['alert', 'alert-success'],
                 info: ['alert', 'alert-info'],
                 warning: ['alert', 'alert-warning'],
                 danger: ['alert', 'alert-danger']
             };
             this.update_mapped_classes(class_map, 'box_style', previous_trait_value, this.$box);
         },
         
         add_child_model: function(model) {
             /**
              * Called when a model is added to the children list.
              */
             var that = this;
             var dummy = $('<div/>');
             that.$box.append(dummy);
             return this.create_child_view(model).then(function(view) {
                 dummy.replaceWith(view.el);
 
                 // Trigger the displayed event of the child view.
                 that.after_displayed(function() {
                     view.trigger('displayed');
                 });
                 return view;
             }).catch(utils.reject("Couldn't add child view to box", true));
         },
         
         remove: function() {
             /**
              * We remove this widget before removing the children as an optimization
              * we want to remove the entire container from the DOM first before
              * removing each individual child separately.
              */
             BoxView.__super__.remove.apply(this, arguments);
             this.children_views.remove();
         },
     });
 
 
     var FlexBoxView = BoxView.extend({
         render: function(){
             FlexBoxView.__super__.render.apply(this);
             this.listenTo(this.model, 'change:orientation', this.update_orientation, this);
             this.listenTo(this.model, 'change:flex', this._flex_changed, this);
             this.listenTo(this.model, 'change:pack', this._pack_changed, this);
             this.listenTo(this.model, 'change:align', this._align_changed, this);
             this._flex_changed();
             this._pack_changed();
             this._align_changed();
             this.update_orientation();
         },
 
         update_orientation: function(){
             var orientation = this.model.get("orientation");
             if (orientation == "vertical") {
                 this.$box.removeClass("hbox").addClass("vbox");
             } else {
                 this.$box.removeClass("vbox").addClass("hbox");
             }
         },
 
         _flex_changed: function(){
             if (this.model.previous('flex')) {
                 this.$box.removeClass('box-flex' + this.model.previous('flex'));
             }
             this.$box.addClass('box-flex' + this.model.get('flex'));
         },
 
         _pack_changed: function(){
             if (this.model.previous('pack')) {
                 this.$box.removeClass(this.model.previous('pack'));
             }
             this.$box.addClass(this.model.get('pack'));
         },
 
         _align_changed: function(){
             if (this.model.previous('align')) {
                 this.$box.removeClass('align-' + this.model.previous('align'));
             }
             this.$box.addClass('align-' + this.model.get('align'));
         },
     });
 
     return {
+        'unpack_models': unpack_models,
+        'BoxModel': BoxModel,
         'BoxView': BoxView,
         'FlexBoxView': FlexBoxView,
     };
 });

IPython/html/tests/util.js

@@ -1,832 +1,845 b''
 //
 // Utility functions for the HTML notebook's CasperJS tests.
 //
 casper.get_notebook_server = function () {
     // Get the URL of a notebook server on which to run tests.
     var port = casper.cli.get("port");
     port = (typeof port === 'undefined') ? '8888' : port;
     return casper.cli.get("url") || ('http://127.0.0.1:' + port);
 };
 
 casper.open_new_notebook = function () {
     // Create and open a new notebook.
     var baseUrl = this.get_notebook_server();
     this.start(baseUrl);
     this.waitFor(this.page_loaded);
     this.waitForSelector('#kernel-python2 a, #kernel-python3 a');
     this.thenClick('#kernel-python2 a, #kernel-python3 a');
     
     this.waitForPopup('');
 
     this.withPopup('', function () {this.waitForSelector('.CodeMirror-code');});
     this.then(function () {
         this.open(this.popups[0].url);
     });
     this.waitFor(this.page_loaded);
 
     // Hook the log and error methods of the console, forcing them to
     // serialize their arguments before printing.  This allows the
     // Objects to cross into the phantom/slimer regime for display.
     this.thenEvaluate(function(){
         var serialize_arguments = function(f, context) {
             return function() {
                 var pretty_arguments = [];
                 for (var i = 0; i < arguments.length; i++) {
                     var value = arguments[i];
                     if (value instanceof Object) {
                         var name = value.name || 'Object';
                         // Print a JSON string representation of the object.
                         // If we don't do this, [Object object] gets printed
                         // by casper, which is useless.  The long regular
                         // expression reduces the verbosity of the JSON.
                         pretty_arguments.push(name + ' {' + JSON.stringify(value, null, '  ')
                             .replace(/(\s+)?({)?(\s+)?(}(\s+)?,?)?(\s+)?(\s+)?\n/g, '\n')
                             .replace(/\n(\s+)?\n/g, '\n'));
                     } else {
                         pretty_arguments.push(value);
                     }
                 }
                 f.apply(context, pretty_arguments);
             };
         };
         console.log = serialize_arguments(console.log, console);
         console.error = serialize_arguments(console.error, console);
     });
 
     // Make sure the kernel has started
     this.waitFor(this.kernel_running);
     // track the IPython busy/idle state
     this.thenEvaluate(function () {
         require(['base/js/namespace', 'base/js/events'], function (IPython, events) {
         
             events.on('kernel_idle.Kernel',function () {
                 IPython._status = 'idle';
             });
             events.on('kernel_busy.Kernel',function () {
                 IPython._status = 'busy';
             });
         });
     });
 
     // Because of the asynchronous nature of SlimerJS (Gecko), we need to make
     // sure the notebook has actually been loaded into the IPython namespace
     // before running any tests.
     this.waitFor(function() {
         return this.evaluate(function () {
             return IPython.notebook;
         });
     });
 };
 
 casper.page_loaded = function() {
     // Return whether or not the kernel is running.
     return this.evaluate(function() {
         return typeof IPython !== "undefined" &&
             IPython.page !== undefined;
     });
 };
 
 casper.kernel_running = function() {
     // Return whether or not the kernel is running.
     return this.evaluate(function() {
         return IPython &&
         IPython.notebook &&
         IPython.notebook.kernel &&
         IPython.notebook.kernel.is_connected();
     });
 };
 
 casper.kernel_disconnected = function() {
     return this.evaluate(function() {
         return IPython.notebook.kernel.is_fully_disconnected();
     });
 };
 
 casper.wait_for_kernel_ready = function () {
     this.waitFor(this.kernel_running);
     this.thenEvaluate(function () {
         IPython._kernel_ready = false;
         IPython.notebook.kernel.kernel_info(
             function () {
                 IPython._kernel_ready = true;
             });
     });
     this.waitFor(function () {
         return this.evaluate(function () {
             return IPython._kernel_ready;
         });
     });
 };
 
 casper.shutdown_current_kernel = function () {
     // Shut down the current notebook's kernel.
     this.thenEvaluate(function() {
         IPython.notebook.session.delete();
     });
     // We close the page right after this so we need to give it time to complete.
     this.wait(1000);
 };
 
 casper.delete_current_notebook = function () {
     // Delete created notebook.
 
     // For some unknown reason, this doesn't work?!?
     this.thenEvaluate(function() {
         IPython.notebook.delete();
     });
 };
 
 casper.wait_for_busy = function () {
     // Waits for the notebook to enter a busy state.
     this.waitFor(function () {
         return this.evaluate(function () {
             return IPython._status == 'busy';
         });
     });
 };
 
 casper.wait_for_idle = function () {
     // Waits for the notebook to idle.
     this.waitFor(function () {
         return this.evaluate(function () {
             return IPython._status == 'idle';
         });
     });
 };
 
 casper.wait_for_output = function (cell_num, out_num) {
     // wait for the nth output in a given cell
     this.wait_for_idle();
     out_num = out_num || 0;
     this.then(function() {
         this.waitFor(function (c, o) {
             return this.evaluate(function get_output(c, o) {
                 var cell = IPython.notebook.get_cell(c);
                 return cell.output_area.outputs.length > o;
             },
             // pass parameter from the test suite js to the browser code js
             {c : cell_num, o : out_num});
         });
     },
     function then() { },
     function timeout() {
         this.echo("wait_for_output timed out!");
     });
 };
 
 casper.wait_for_widget = function (widget_info) {
     // wait for a widget msg que to reach 0
     //
     // Parameters
     // ----------
     // widget_info : object
     //      Object which contains info related to the widget.  The model_id property
     //      is used to identify the widget.
 
     // Clear the results of a previous query, if they exist.  Make sure a
     // dictionary exists to store the async results in.
     this.thenEvaluate(function(model_id) {
         if (window.pending_msgs === undefined) { 
             window.pending_msgs = {}; 
         } else {
             window.pending_msgs[model_id] = -1;
         } 
     }, {model_id: widget_info.model_id});
 
     // Wait for the pending messages to be 0.
     this.waitFor(function () {
         var pending = this.evaluate(function (model_id) {
 
             // Get the model.  Once the model is had, store it's pending_msgs
             // count in the window's dictionary.
             IPython.notebook.kernel.widget_manager.get_model(model_id)
             .then(function(model) {     
                 window.pending_msgs[model_id] = model.pending_msgs; 
             });
 
             // Return the pending_msgs result.
             return window.pending_msgs[model_id];
         }, {model_id: widget_info.model_id});
 
         if (pending === 0) {
             return true;
         } else {
             return false;
         }
     });
 };
 
 casper.get_output_cell = function (cell_num, out_num) {
     // return an output of a given cell
     out_num = out_num || 0;
     var result = casper.evaluate(function (c, o) {
         var cell = IPython.notebook.get_cell(c);
         return cell.output_area.outputs[o];
     },
     {c : cell_num, o : out_num});
     if (!result) {
         var num_outputs = casper.evaluate(function (c) {
             var cell = IPython.notebook.get_cell(c);
             return cell.output_area.outputs.length;
         },
         {c : cell_num});
         this.test.assertTrue(false,
             "Cell " + cell_num + " has no output #" + out_num + " (" + num_outputs + " total)"
         );
     } else {
         return result;
     }
 };
 
 casper.get_cells_length = function () {
     // return the number of cells in the notebook
     var result = casper.evaluate(function () {
         return IPython.notebook.get_cells().length;
     });
     return result;
 };
 
 casper.set_cell_text = function(index, text){
     // Set the text content of a cell.
     this.evaluate(function (index, text) {
         var cell = IPython.notebook.get_cell(index);
         cell.set_text(text);
     }, index, text);
 };
 
 casper.get_cell_text = function(index){
     // Get the text content of a cell.
     return this.evaluate(function (index) {
         var cell = IPython.notebook.get_cell(index);
         return cell.get_text();
     }, index);
 };
 
 casper.insert_cell_at_bottom = function(cell_type){
     // Inserts a cell at the bottom of the notebook
     // Returns the new cell's index.
     return this.evaluate(function (cell_type) {
         var cell = IPython.notebook.insert_cell_at_bottom(cell_type);
         return IPython.notebook.find_cell_index(cell);
     }, cell_type);
 };
 
 casper.append_cell = function(text, cell_type) { 
     // Insert a cell at the bottom of the notebook and set the cells text.
     // Returns the new cell's index.
     var index = this.insert_cell_at_bottom(cell_type);
     if (text !== undefined) {
         this.set_cell_text(index, text);
     }
     return index;
 };
 
 casper.execute_cell = function(index, expect_failure){
     // Asynchronously executes a cell by index.
     // Returns the cell's index.
     
     if (expect_failure === undefined) expect_failure = false;
     var that = this;
     this.then(function(){
         that.evaluate(function (index) {
             var cell = IPython.notebook.get_cell(index);
             cell.execute();
         }, index);
     });
     this.wait_for_idle();
     
     this.then(function () {
         var error = that.evaluate(function (index) {
             var cell = IPython.notebook.get_cell(index);
             var outputs = cell.output_area.outputs;
             for (var i = 0; i < outputs.length; i++) {
                 if (outputs[i].output_type == 'error') {
                     return outputs[i];
                 }
             }
             return false;
         }, index);
         if (error === null) {
             this.test.fail("Failed to check for error output");
         }
         if (expect_failure && error === false) {
             this.test.fail("Expected error while running cell");
         } else if (!expect_failure && error !== false) {
             this.test.fail("Error running cell:\n" + error.traceback.join('\n'));
         }
     });
     return index;
 };
 
 casper.execute_cell_then = function(index, then_callback, expect_failure) {
     // Synchronously executes a cell by index.
     // Optionally accepts a then_callback parameter.  then_callback will get called
     // when the cell  has finished executing.
     // Returns the cell's index.
     var return_val = this.execute_cell(index, expect_failure);
 
     this.wait_for_idle();
 
     var that = this;
     this.then(function(){ 
         if (then_callback!==undefined) {
             then_callback.apply(that, [index]);
         }
     });
 
     return return_val;
 };
 
+casper.append_cell_execute_then = function(text, then_callback, expect_failure) {
+    // Append a code cell and execute it, optionally calling a then_callback
+    var c = this.append_cell(text);
+    return this.execute_cell_then(c, then_callback, expect_failure);
+};
+
+casper.assert_output_equals = function(text, output_text, message) {
+    // Append a code cell with the text, then assert the output is equal to output_text
+    this.append_cell_execute_then(text, function(index) {
+        this.test.assertEquals(this.get_output_cell(index).text.trim(), output_text, message);
+    });
+};
+
 casper.wait_for_element = function(index, selector){
     // Utility function that allows us to easily wait for an element 
     // within a cell.  Uses JQuery selector to look for the element.
     var that = this;
     this.waitFor(function() {
         return that.cell_element_exists(index, selector);
     });
 };
 
 casper.cell_element_exists = function(index, selector){
     // Utility function that allows us to easily check if an element exists 
     // within a cell.  Uses JQuery selector to look for the element.
     return casper.evaluate(function (index, selector) {
         var $cell = IPython.notebook.get_cell(index).element;
         return $cell.find(selector).length > 0;
     }, index, selector);
 };
 
 casper.cell_element_function = function(index, selector, function_name, function_args){
     // Utility function that allows us to execute a jQuery function on an 
     // element within a cell.
     return casper.evaluate(function (index, selector, function_name, function_args) {
         var $cell = IPython.notebook.get_cell(index).element;
         var $el = $cell.find(selector);
         return $el[function_name].apply($el, function_args);
     }, index, selector, function_name, function_args);
 };
 
 casper.validate_notebook_state = function(message, mode, cell_index) {
     // Validate the entire dual mode state of the notebook.  Make sure no more than
     // one cell is selected, focused, in edit mode, etc...
 
     // General tests.
     this.test.assertEquals(this.get_keyboard_mode(), this.get_notebook_mode(),
         message + '; keyboard and notebook modes match');
     // Is the selected cell the only cell that is selected?
     if (cell_index!==undefined) {
         this.test.assert(this.is_only_cell_selected(cell_index),
             message + '; cell ' + cell_index + ' is the only cell selected');
     }
 
     // Mode specific tests.
     if (mode==='command') {
         // Are the notebook and keyboard manager in command mode?
         this.test.assertEquals(this.get_keyboard_mode(), 'command',
             message + '; in command mode');
         // Make sure there isn't a single cell in edit mode.
         this.test.assert(this.is_only_cell_edit(null),
             message + '; all cells in command mode');
         this.test.assert(this.is_cell_editor_focused(null),
             message + '; no cell editors are focused while in command mode');
 
     } else if (mode==='edit') {
         // Are the notebook and keyboard manager in edit mode?
         this.test.assertEquals(this.get_keyboard_mode(), 'edit',
             message + '; in edit mode');
         if (cell_index!==undefined) {
             // Is the specified cell the only cell in edit mode?
             this.test.assert(this.is_only_cell_edit(cell_index),
                 message + '; cell ' + cell_index + ' is the only cell in edit mode '+ this.cells_modes());
             // Is the specified cell the only cell with a focused code mirror?
             this.test.assert(this.is_cell_editor_focused(cell_index),
                 message + '; cell ' + cell_index + '\'s editor is appropriately focused');
         }
 
     } else {
         this.test.assert(false, message + '; ' + mode + ' is an unknown mode');
     }
 };
 
 casper.select_cell = function(index) {
     // Select a cell in the notebook.
     this.evaluate(function (i) {
         IPython.notebook.select(i);
     }, {i: index});
 };
 
 casper.click_cell_editor = function(index) {
     // Emulate a click on a cell's editor.
     
     // Code Mirror does not play nicely with emulated brower events.  
     // Instead of trying to emulate a click, here we run code similar to
     // the code used in Code Mirror that handles the mousedown event on a
     // region of codemirror that the user can focus.
     this.evaluate(function (i) {
         var cm = IPython.notebook.get_cell(i).code_mirror;
         if (cm.options.readOnly != "nocursor" && (document.activeElement != cm.display.input)){
             cm.display.input.focus();
         }
     }, {i: index});
 };
 
 casper.set_cell_editor_cursor = function(index, line_index, char_index) {
     // Set the Code Mirror instance cursor's location.
     this.evaluate(function (i, l, c) {
         IPython.notebook.get_cell(i).code_mirror.setCursor(l, c);
     }, {i: index, l: line_index, c: char_index});
 };
 
 casper.focus_notebook = function() {
     // Focus the notebook div.
     this.evaluate(function (){
         $('#notebook').focus();
     }, {});
 };
 
 casper.trigger_keydown = function() {
     // Emulate a keydown in the notebook.
     for (var i = 0; i < arguments.length; i++) {
         this.evaluate(function (k) {
             var element = $(document);
             var event = IPython.keyboard.shortcut_to_event(k, 'keydown');
             element.trigger(event);
         }, {k: arguments[i]});    
     }
 };
 
 casper.get_keyboard_mode = function() {
     // Get the mode of the keyboard manager.
     return this.evaluate(function() {
         return IPython.keyboard_manager.mode;
     }, {});
 };
 
 casper.get_notebook_mode = function() {
     // Get the mode of the notebook.
     return this.evaluate(function() {
         return IPython.notebook.mode;
     }, {});
 };
 
 casper.get_cell = function(index) {
     // Get a single cell.
     //
     // Note: Handles to DOM elements stored in the cell will be useless once in
     //       CasperJS context.
     return this.evaluate(function(i) {
         var cell = IPython.notebook.get_cell(i);
         if (cell) {
             return cell;
         }
         return null;
     }, {i : index});
 };
 
 casper.is_cell_editor_focused = function(index) {
     // Make sure a cell's editor is the only editor focused on the page.
     return this.evaluate(function(i) {
         var focused_textarea = $('#notebook .CodeMirror-focused textarea');
         if (focused_textarea.length > 1) { throw 'More than one Code Mirror editor is focused at once!'; }
         if (i === null) {
             return focused_textarea.length === 0;
         } else {
             var cell = IPython.notebook.get_cell(i);
             if (cell) {
                 return cell.code_mirror.getInputField() == focused_textarea[0];
             }    
         }
         return false;
     }, {i : index});
 };
 
 casper.is_only_cell_selected = function(index) {
     // Check if a cell is the only cell selected.
     // Pass null as the index to check if no cells are selected.
     return this.is_only_cell_on(index, 'selected', 'unselected');
 };
 
 casper.is_only_cell_edit = function(index) {
     // Check if a cell is the only cell in edit mode.
     // Pass null as the index to check if all of the cells are in command mode.
     var cells_length = this.get_cells_length();
     for (var j = 0; j < cells_length; j++) {
         if (j === index) {
             if (!this.cell_mode_is(j, 'edit')) {
                 return false;
             }
         } else {
             if (this.cell_mode_is(j, 'edit')) {
                 return false;
             }
         }
     }
     return true;
 };
 
 casper.is_only_cell_on = function(i, on_class, off_class) {
     // Check if a cell is the only cell with the `on_class` DOM class applied to it.
     // All of the other cells are checked for the `off_class` DOM class.
     // Pass null as the index to check if all of the cells have the `off_class`.
     var cells_length = this.get_cells_length();
     for (var j = 0; j < cells_length; j++) {
         if (j === i) {
             if (this.cell_has_class(j, off_class) || !this.cell_has_class(j, on_class)) {
                 return false;
             }
         } else {
             if (!this.cell_has_class(j, off_class) || this.cell_has_class(j, on_class)) {
                 return false;
             }
         }
     }
     return true;
 };
 
 casper.cells_modes = function(){
     return this.evaluate(function(){
         return IPython.notebook.get_cells().map(function(x,c){return x.mode})
     }, {});
 };
 
 casper.cell_mode_is = function(index, mode) {
     // Check if a cell is in a specific mode
     return this.evaluate(function(i, m) {
         var cell = IPython.notebook.get_cell(i);
         if (cell) {
             return cell.mode === m;
         }
         return false;
     }, {i : index, m: mode});
 };
 
 
 casper.cell_has_class = function(index, classes) {
     // Check if a cell has a class.
     return this.evaluate(function(i, c) {
         var cell = IPython.notebook.get_cell(i);
         if (cell) {
             return cell.element.hasClass(c);
         }
         return false;
     }, {i : index, c: classes});
 };
 
 casper.is_cell_rendered = function (index) {
     return this.evaluate(function(i) {
         return !!IPython.notebook.get_cell(i).rendered;
     }, {i:index});
 };
 
 casper.assert_colors_equal = function (hex_color, local_color, msg) {
     // Tests to see if two colors are equal.
     //
     // Parameters
     // hex_color: string
     //      Hexadecimal color code, with or without preceeding hash character.
     // local_color: string
     //      Local color representation.  Can either be hexadecimal (default for 
     //      phantom) or rgb (default for slimer).
 
     // Remove parentheses, hashes, semi-colons, and space characters.
     hex_color = hex_color.replace(/[\(\); #]/, '');
     local_color = local_color.replace(/[\(\); #]/, '');
 
     // If the local color is rgb, clean it up and replace 
     if (local_color.substr(0,3).toLowerCase() == 'rgb') {
         var components = local_color.substr(3).split(',');
         local_color = '';
         for (var i = 0; i < components.length; i++) {
             var part = parseInt(components[i]).toString(16);
             while (part.length < 2) part = '0' + part;
             local_color += part;
         }
     }
     
     this.test.assertEquals(hex_color.toUpperCase(), local_color.toUpperCase(), msg);
 };
 
 casper.notebook_test = function(test) {
     // Wrap a notebook test to reduce boilerplate.
     this.open_new_notebook();
 
     // Echo whether or not we are running this test using SlimerJS
     if (this.evaluate(function(){
         return typeof InstallTrigger !== 'undefined';   // Firefox 1.0+
     })) { 
         console.log('This test is running in SlimerJS.'); 
         this.slimerjs = true;
     }
     
     // Make sure to remove the onbeforeunload callback.  This callback is 
     // responsible for the "Are you sure you want to quit?" type messages.
     // PhantomJS ignores these prompts, SlimerJS does not which causes hangs.
     this.then(function(){
         this.evaluate(function(){
             window.onbeforeunload = function(){};
         });
     });
 
     this.then(test);
     
     // Kill the kernel and delete the notebook.
     this.shutdown_current_kernel();
     // This is still broken but shouldn't be a problem for now.
     // this.delete_current_notebook();
     
     // This is required to clean up the page we just finished with. If we don't call this
     // casperjs will leak file descriptors of all the open WebSockets in that page. We
     // have to set this.page=null so that next time casper.start runs, it will create a
     // new page from scratch.
     this.then(function () {
         this.page.close();
         this.page = null;
     });
     
     // Run the browser automation.
     this.run(function() {
         this.test.done();
     });
 };
 
 casper.wait_for_dashboard = function () {
     // Wait for the dashboard list to load.
     casper.waitForSelector('.list_item');
 };
 
 casper.open_dashboard = function () {
     // Start casper by opening the dashboard page.
     var baseUrl = this.get_notebook_server();
     this.start(baseUrl);
     this.waitFor(this.page_loaded);
     this.wait_for_dashboard();
 };
 
 casper.dashboard_test = function (test) {
     // Open the dashboard page and run a test.
     this.open_dashboard();
     this.then(test);
 
     this.then(function () {
         this.page.close();
         this.page = null;
     });
     
     // Run the browser automation.
     this.run(function() {
         this.test.done();
     });
 };
 
 // note that this will only work for UNIQUE events -- if you want to
 // listen for the same event twice, this will not work!
 casper.event_test = function (name, events, action, timeout) {
 
     // set up handlers to listen for each of the events
     this.thenEvaluate(function (events) {
         var make_handler = function (event) {
             return function () {
                 IPython._events_triggered.push(event);
                 IPython.notebook.events.off(event, null, IPython._event_handlers[event]);
                 delete IPython._event_handlers[event];
             };
         };
         IPython._event_handlers = {};
         IPython._events_triggered = [];
         for (var i=0; i < events.length; i++) {
             IPython._event_handlers[events[i]] = make_handler(events[i]);
             IPython.notebook.events.on(events[i], IPython._event_handlers[events[i]]);
         }
     }, [events]);
 
     // execute the requested action
     this.then(action);
 
     // wait for all the events to be triggered
     this.waitFor(function () {
         return this.evaluate(function (events) {
             return IPython._events_triggered.length >= events.length;
         }, [events]);
     }, undefined, undefined, timeout);
 
     // test that the events were triggered in the proper order
     this.then(function () {
         var triggered = this.evaluate(function () {
             return IPython._events_triggered;
         });
         var handlers = this.evaluate(function () {
             return Object.keys(IPython._event_handlers);
         });
         this.test.assertEquals(triggered.length, events.length, name + ': ' + events.length + ' events were triggered');
         this.test.assertEquals(handlers.length, 0, name + ': all handlers triggered');
         for (var i=0; i < events.length; i++) {
             this.test.assertEquals(triggered[i], events[i], name + ': ' + events[i] + ' was triggered');
         }
     });
 
     // turn off any remaining event listeners
     this.thenEvaluate(function () {
         for (var event in IPython._event_handlers) {
             IPython.notebook.events.off(event, null, IPython._event_handlers[event]);
             delete IPython._event_handlers[event];
         }
     });
 };
 
 casper.options.waitTimeout=10000;
 casper.on('waitFor.timeout', function onWaitForTimeout(timeout) {
     this.echo("Timeout for " + casper.get_notebook_server());
     this.echo("Is the notebook server running?");
 });
 
 casper.print_log = function () {
     // Pass `console.log` calls from page JS to casper.
     this.on('remote.message', function(msg) {
         this.echo('Remote message caught: ' + msg);
     });
 };
 
 casper.on("page.error", function onError(msg, trace) {
     // show errors in the browser
     this.echo("Page Error");
     this.echo("  Message:   " + msg.split('\n').join('\n             '));
     this.echo("  Call stack:");
     var local_path = this.get_notebook_server();
     for (var i = 0; i < trace.length; i++) {
         var frame = trace[i];
         var file = frame.file;
         // shorten common phantomjs evaluate url
         // this will have a different value on slimerjs
         if (file === "phantomjs://webpage.evaluate()") {
             file = "evaluate";
         }
         // remove the version tag from the path
         file = file.replace(/(\?v=[0-9abcdef]+)/, '');
         // remove the local address from the beginning of the path
         if (file.indexOf(local_path) === 0) {
             file = file.substr(local_path.length);
         }
         var frame_text = (frame.function.length > 0) ? " in " + frame.function : "";
         this.echo("    line " + frame.line + " of " + file + frame_text);
     }
 });
 
 
 casper.capture_log = function () {
     // show captured errors
     var captured_log = [];
     var seen_errors = 0;
     this.on('remote.message', function(msg) {
         captured_log.push(msg);
     });
 
     var that = this;
     this.test.on("test.done", function (result) {
         // test.done runs per-file,
         // but suiteResults is per-suite (directory)
         var current_errors;
         if (this.suiteResults) {
             // casper 1.1 has suiteResults
             current_errors = this.suiteResults.countErrors() + this.suiteResults.countFailed();
         } else {
             // casper 1.0 has testResults instead
             current_errors = this.testResults.failed;
         }
 
         if (current_errors > seen_errors && captured_log.length > 0) {
             casper.echo("\nCaptured console.log:");
             for (var i = 0; i < captured_log.length; i++) {
                 var output = String(captured_log[i]).split('\n');
                 for (var j = 0; j < output.length; j++) {
                     casper.echo("    " + output[j]);
                 }
             }
         }
 
         seen_errors = current_errors;
         captured_log = [];
     });
 };
 
 casper.interact = function() {
     // Start an interactive Javascript console.
     var system = require('system');
     system.stdout.writeLine('JS interactive console.');
     system.stdout.writeLine('Type `exit` to quit.');
 
     function read_line() {
         system.stdout.writeLine('JS: ');
         var line = system.stdin.readLine();
         return line;
     }
 
     var input = read_line();
     while (input.trim() != 'exit') {
         var output = this.evaluate(function(code) {
             return String(eval(code));
         }, {code: input});
         system.stdout.writeLine('\nOut: ' + output);
         input = read_line();
     }
 };
 
 casper.capture_log();

IPython/html/tests/widgets/widget.js

@@ -1,191 +1,309 b''
 var xor = function (a, b) {return !a ^ !b;}; 
 var isArray = function (a) {
     try {
         return Object.toString.call(a) === "[object Array]" || Object.toString.call(a) === "[object RuntimeArray]";
     } catch (e) {
         return Array.isArray(a);
     }
 };
 var recursive_compare = function(a, b) {
     // Recursively compare two objects.
     var same = true;
     same = same && !xor(a instanceof Object || typeof a == 'object', b instanceof Object || typeof b == 'object');
     same = same && !xor(isArray(a), isArray(b));
 
     if (same) {
         if (a instanceof Object) {
             var key;
             for (key in a) {
                 if (a.hasOwnProperty(key) && !recursive_compare(a[key], b[key])) {
                     same = false;
                     break;
                 }
             }
             for (key in b) {
                 if (b.hasOwnProperty(key) && !recursive_compare(a[key], b[key])) {
                     same = false;
                     break;
                 }
             }
         } else {
             return a === b;
         }    
     }
     
     return same;
 };
 
 // Test the widget framework.
 casper.notebook_test(function () {
     var index;
 
     index = this.append_cell(
-        'from IPython.html import widgets\n' + 
-        'from IPython.display import display, clear_output\n' +
-        'print("Success")');
+        ['from IPython.html import widgets',
+         'from IPython.display import display, clear_output',
+         'print("Success")'].join('\n'));
     this.execute_cell_then(index);
 
     this.then(function () {
-
-        // Functions that can be used to test the packing and unpacking APIs
-        var that = this;
-        var test_pack = function (input) {
-            var output = that.evaluate(function(input) {
-                var model = new IPython.WidgetModel(IPython.notebook.kernel.widget_manager, undefined);
-                var results = model._pack_models(input);
-                return results;
-            }, {input: input});
-            that.test.assert(recursive_compare(input, output), 
-                JSON.stringify(input) + ' passed through Model._pack_model unchanged');
-        };
-        var test_unpack = function (input) {
-            that.thenEvaluate(function(input) {
-                window.results = undefined;
-                var model = new IPython.WidgetModel(IPython.notebook.kernel.widget_manager, undefined);
-                model._unpack_models(input).then(function(results) { 
-                    window.results = results; 
-                });    
-            }, {input: input});
-            
-            that.waitFor(function check() {
-                return that.evaluate(function() { 
-                    return window.results; 
-                }); 
-            });
-            
-            that.then(function() {
-                var results = that.evaluate(function() { 
-                    return window.results; 
-                });
-                that.test.assert(recursive_compare(input, results), 
-                    JSON.stringify(input) + ' passed through Model._unpack_model unchanged');
-            });
-        };
-        var test_packing = function(input) {
-            test_pack(input);
-            test_unpack(input);
-        };
-        
-        test_packing({0: 'hi', 1: 'bye'});
-        test_packing(['hi', 'bye']);
-        test_packing(['hi', 5]);
-        test_packing(['hi', '5']);
-        test_packing([1.0, 0]);
-        test_packing([1.0, false]);
-        test_packing([1, false]);
-        test_packing([1, false, {a: 'hi'}]);
-        test_packing([1, false, ['hi']]);
-        test_packing([String('hi'), Date("Thu Nov 13 2014 13:46:21 GMT-0500")])
-
         // Test multi-set, single touch code.  First create a custom widget.
         this.thenEvaluate(function() {
             var MultiSetView = IPython.DOMWidgetView.extend({
                 render: function(){
                     this.model.set('a', 1);
                     this.model.set('b', 2);
                     this.model.set('c', 3);
                     this.touch();
                 },
             });
             IPython.WidgetManager.register_widget_view('MultiSetView', MultiSetView);
         }, {});
     });
 
     // Try creating the multiset widget, verify that sets the values correctly.
     var multiset = {};
-    multiset.index = this.append_cell(
-        'from IPython.utils.traitlets import Unicode, CInt\n' +
-        'class MultiSetWidget(widgets.Widget):\n' +
-        '    _view_name = Unicode("MultiSetView", sync=True)\n' +
-        '    a = CInt(0, sync=True)\n' +
-        '    b = CInt(0, sync=True)\n' +
-        '    c = CInt(0, sync=True)\n' +
-        '    d = CInt(-1, sync=True)\n' + // See if it sends a full state.
-        '    def set_state(self, sync_data):\n' +
-        '        widgets.Widget.set_state(self, sync_data)\n'+
-        '        self.d = len(sync_data)\n' +
-        'multiset = MultiSetWidget()\n' +
-        'display(multiset)\n' +
-        'print(multiset.model_id)');
+    multiset.index = this.append_cell([
+        'from IPython.utils.traitlets import Unicode, CInt',
+        'class MultiSetWidget(widgets.Widget):',
+        '    _view_name = Unicode("MultiSetView", sync=True)',
+        '    a = CInt(0, sync=True)',
+        '    b = CInt(0, sync=True)',
+        '    c = CInt(0, sync=True)',
+        '    d = CInt(-1, sync=True)', // See if it sends a full state.
+        '    def set_state(self, sync_data):',
+        '        widgets.Widget.set_state(self, sync_data)',
+        '        self.d = len(sync_data)',
+        'multiset = MultiSetWidget()',
+        'display(multiset)',
+        'print(multiset.model_id)'].join('\n'));
     this.execute_cell_then(multiset.index, function(index) {
         multiset.model_id = this.get_output_cell(index).text.trim();
     });
 
     this.wait_for_widget(multiset);
 
     index = this.append_cell(
         'print("%d%d%d" % (multiset.a, multiset.b, multiset.c))');
     this.execute_cell_then(index, function(index) {
         this.test.assertEquals(this.get_output_cell(index).text.trim(), '123',
             'Multiple model.set calls and one view.touch update state in back-end.');
     });
 
     index = this.append_cell(
         'print("%d" % (multiset.d))');
     this.execute_cell_then(index, function(index) {
         this.test.assertEquals(this.get_output_cell(index).text.trim(), '3',
             'Multiple model.set calls sent a partial state.');
     });
 
     var textbox = {};
-    throttle_index = this.append_cell(
-        'import time\n' +
-        'textbox = widgets.Text()\n' +
-        'display(textbox)\n' +
-        'textbox._dom_classes = ["my-throttle-textbox"]\n' +
-        'def handle_change(name, old, new):\n' +
-        '    display(len(new))\n' +
-        '    time.sleep(0.5)\n' +
-        'textbox.on_trait_change(handle_change, "value")\n' +
-        'print(textbox.model_id)');
+    throttle_index = this.append_cell([
+        'import time',
+        'textbox = widgets.Text()',
+        'display(textbox)',
+        'textbox._dom_classes = ["my-throttle-textbox"]',
+        'def handle_change(name, old, new):',
+        '    display(len(new))',
+        '    time.sleep(0.5)',
+        'textbox.on_trait_change(handle_change, "value")',
+        'print(textbox.model_id)'].join('\n'));
     this.execute_cell_then(throttle_index, function(index){
         textbox.model_id = this.get_output_cell(index).text.trim();
 
         this.test.assert(this.cell_element_exists(index, 
             '.widget-area .widget-subarea'),
             'Widget subarea exists.');
 
         this.test.assert(this.cell_element_exists(index, 
             '.my-throttle-textbox'), 'Textbox exists.');
 
         // Send 20 characters
-        this.sendKeys('.my-throttle-textbox input', '....................');
+        this.sendKeys('.my-throttle-textbox input', '12345678901234567890');
     });
 
     this.wait_for_widget(textbox);
 
     this.then(function () { 
         var outputs = this.evaluate(function(i) {
             return IPython.notebook.get_cell(i).output_area.outputs;
         }, {i : throttle_index});
 
         // Only 4 outputs should have printed, but because of timing, sometimes
         // 5 outputs will print.  All we need to do is verify num outputs <= 5
         // because that is much less than 20.
         this.test.assert(outputs.length <= 5, 'Messages throttled.');
 
         // We also need to verify that the last state sent was correct.
         var last_state = outputs[outputs.length-1].data['text/plain'];
         this.test.assertEquals(last_state, "20", "Last state sent when throttling.");
     });
+
+
+    this.thenEvaluate(function() {
+        define('TestWidget', ['widgets/js/widget', 'base/js/utils', 'underscore'], function(widget, utils, _) {
+            var floatArray = {
+                deserialize: function (value, model) {
+                    if (value===null) {return null;}
+                    // DataView -> float64 typed array
+                    return new Float64Array(value.buffer);
+                },
+                // serialization automatically handled since the 
+                // attribute is an ArrayBuffer view
+            };
+            
+            var floatList = {
+                deserialize: function (value, model) {
+                    // list of floats -> list of strings
+                    return value.map(function(x) {return x.toString()});
+                },
+                serialize: function(value, model) {
+                    // list of strings -> list of floats
+                    return value.map(function(x) {return parseFloat(x);})
+                }
+            };
+
+            var TestWidgetModel = widget.WidgetModel.extend({}, {
+                serializers: _.extend({
+                    array_list: floatList,
+                    array_binary: floatArray
+                }, widget.WidgetModel.serializers)
+            });
+            
+            var TestWidgetView = widget.DOMWidgetView.extend({
+                render: function () {
+                    this.listenTo(this.model, 'msg:custom', this.handle_msg);
+                },
+                handle_msg: function(content, buffers) {
+                    this.msg = [content, buffers];
+                }
+            });
+
+            return {TestWidgetModel: TestWidgetModel, TestWidgetView: TestWidgetView};
+        });
+    });
+
+    var testwidget = {};
+    this.append_cell_execute_then([
+        'from IPython.html import widgets',
+        'from IPython.utils.traitlets import Unicode, Instance, List',
+        'from IPython.display import display',
+        'from array import array',
+        'def _array_to_memoryview(x):',
+        '    if x is None: return None',
+        '    try:',
+        '        y = memoryview(x)',
+        '    except TypeError:',
+        '        # in python 2, arrays do not support the new buffer protocol',
+        '        y = memoryview(buffer(x))',
+        '    return y',
+        'def _memoryview_to_array(x):',
+        '    if x is None: return None',
+        '    return array("d", x.tobytes())',
+        'arrays_binary = {',
+        '    "from_json": _memoryview_to_array,',
+        '    "to_json": _array_to_memoryview',
+        '}',
+        '',
+        'def _array_to_list(x):',
+        '    return list(x)',
+        'def _list_to_array(x):',
+        '    return array("d",x)',
+        'arrays_list = {',
+        '    "from_json": _list_to_array,',
+        '    "to_json": _array_to_list',
+        '}',
+        '',
+        'class TestWidget(widgets.DOMWidget):',
+        '    _model_module = Unicode("TestWidget", sync=True)',
+        '    _model_name = Unicode("TestWidgetModel", sync=True)',
+        '    _view_module = Unicode("TestWidget", sync=True)',
+        '    _view_name = Unicode("TestWidgetView", sync=True)',
+        '    array_binary = Instance(array, allow_none=True, sync=True, **arrays_binary)',
+        '    array_list = Instance(array, args=("d", [3.0]), allow_none=False, sync=True, **arrays_list)',
+        '    msg = {}',
+        '    def __init__(self, **kwargs):',
+        '        super(widgets.DOMWidget, self).__init__(**kwargs)',
+        '        self.on_msg(self._msg)',
+        '    def _msg(self, _, content, buffers):',
+        '        self.msg = [content, buffers]',
+        'x=TestWidget()',
+        'display(x)',
+        'print(x.model_id)'].join('\n'), function(index){
+            testwidget.index = index;
+            testwidget.model_id = this.get_output_cell(index).text.trim();
+        });
+    this.wait_for_widget(testwidget);
+
+
+    this.append_cell_execute_then('x.array_list = array("d", [1.5, 2.0, 3.1])');
+    this.wait_for_widget(testwidget);
+    this.then(function() {
+        var result = this.evaluate(function(index) {
+            var v = IPython.notebook.get_cell(index).widget_views[0];
+            var result = v.model.get('array_list');
+            var z = result.slice();
+            z[0]+="1234";
+            z[1]+="5678";
+            v.model.set('array_list', z);
+            v.touch();
+            return result;
+        }, testwidget.index);
+        this.test.assertEquals(result, ["1.5", "2", "3.1"], "JSON custom serializer kernel -> js");
+    });
+    
+    this.assert_output_equals('print(x.array_list.tolist() == [1.51234, 25678.0, 3.1])',
+                              'True', 'JSON custom serializer js -> kernel');
+
+    if (this.slimerjs) {
+        this.append_cell_execute_then("x.array_binary=array('d', [1.5,2.5,5])", function() {
+            this.evaluate(function(index) {
+                var v = IPython.notebook.get_cell(index).widget_views[0];
+                var z = v.model.get('array_binary');
+                z[0]*=3;
+                z[1]*=3;
+                z[2]*=3;
+                // we set to null so that we recognize the change
+                // when we set data back to z
+                v.model.set('array_binary', null);
+                v.model.set('array_binary', z);
+                v.touch();
+            }, textwidget.index);
+        });
+        this.wait_for_widget(testwidget);
+        this.assert_output_equals('x.array_binary.tolist() == [4.5, 7.5, 15.0]',
+                                  'True\n', 'Binary custom serializer js -> kernel')
+
+        this.append_cell_execute_then('x.send("some content", [memoryview(b"binarycontent"), memoryview("morecontent")])');
+        this.wait_for_widget(testwidget);
+
+        this.then(function() {
+            var result = this.evaluate(function(index) {
+                var v = IPython.notebook.get_cell(index).widget_views[0];
+                var d = new TextDecoder('utf-8');
+                return {text: v.msg[0], 
+                        binary0: d.decode(v.msg[1][0]),
+                        binary1: d.decode(v.msg[1][1])};
+            }, testwidget.index);
+            this.test.assertEquals(result, {text: 'some content', 
+                                       binary0: 'binarycontent', 
+                                       binary1: 'morecontent'}, 
+                              "Binary widget messages kernel -> js");
+        });
+
+        this.then(function() {
+            this.evaluate(function(index) {
+                var v = IPython.notebook.get_cell(index).widget_views[0];
+                v.send('content back', [new Uint8Array([1,2,3,4]), new Float64Array([2.1828, 3.14159])])
+            }, testwidget.index);
+        });
+        this.wait_for_widget(testwidget);
+        this.assert_output_equals([
+            'all([x.msg[0] == "content back",',
+            '     x.msg[1][0].tolist() == [1,2,3,4],',
+            '     array("d", x.msg[1][1].tobytes()).tolist() == [2.1828, 3.14159]])'].join('\n'),
+                                  'True', 'Binary buffers message js -> kernel');
+    } else {
+        console.log("skipping binary websocket tests on phantomjs");
+    }
+
 });

IPython/html/widgets/widget.py

@@ -1,497 +1,497 b''
 """Base Widget class.  Allows user to create widgets in the back-end that render
 in the IPython notebook front-end.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from contextlib import contextmanager
 import collections
 
 from IPython.core.getipython import get_ipython
 from IPython.kernel.comm import Comm
 from IPython.config import LoggingConfigurable
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import Unicode, Dict, Instance, Bool, List, \
     CaselessStrEnum, Tuple, CUnicode, Int, Set
 from IPython.utils.py3compat import string_types
 from .trait_types import Color
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 class CallbackDispatcher(LoggingConfigurable):
     """A structure for registering and running callbacks"""
     callbacks = List()
     
     def __call__(self, *args, **kwargs):
         """Call all of the registered callbacks."""
         value = None
         for callback in self.callbacks:
             try:
                 local_value = callback(*args, **kwargs)
             except Exception as e:
                 ip = get_ipython()
                 if ip is None:
                     self.log.warn("Exception in callback %s: %s", callback, e, exc_info=True)
                 else:
                     ip.showtraceback()
             else:
                 value = local_value if local_value is not None else value
         return value
 
     def register_callback(self, callback, remove=False):
         """(Un)Register a callback
 
         Parameters
         ----------
         callback: method handle
             Method to be registered or unregistered.
         remove=False: bool
             Whether to unregister the callback."""
         
         # (Un)Register the callback.
         if remove and callback in self.callbacks:
             self.callbacks.remove(callback)
         elif not remove and callback not in self.callbacks:
             self.callbacks.append(callback)
 
 def _show_traceback(method):
     """decorator for showing tracebacks in IPython"""
     def m(self, *args, **kwargs):
         try:
             return(method(self, *args, **kwargs))
         except Exception as e:
             ip = get_ipython()
             if ip is None:
                 self.log.warn("Exception in widget method %s: %s", method, e, exc_info=True)
             else:
                 ip.showtraceback()
     return m
 
 
 def register(key=None):
     """Returns a decorator registering a widget class in the widget registry. 
     If no key is provided, the class name is used as a key. A key is
     provided for each core IPython widget so that the frontend can use
     this key regardless of the language of the kernel"""
     def wrap(widget):
         l = key if key is not None else widget.__module__ + widget.__name__
         Widget.widget_types[l] = widget
         return widget
     return wrap
 
 
 class Widget(LoggingConfigurable):
     #-------------------------------------------------------------------------
     # Class attributes
     #-------------------------------------------------------------------------
     _widget_construction_callback = None
     widgets = {}
     widget_types = {}
 
     @staticmethod
     def on_widget_constructed(callback):
         """Registers a callback to be called when a widget is constructed.
 
         The callback must have the following signature:
         callback(widget)"""
         Widget._widget_construction_callback = callback
 
     @staticmethod
     def _call_widget_constructed(widget):
         """Static method, called when a widget is constructed."""
         if Widget._widget_construction_callback is not None and callable(Widget._widget_construction_callback):
             Widget._widget_construction_callback(widget)
 
     @staticmethod
     def handle_comm_opened(comm, msg):
         """Static method, called when a widget is constructed."""
         widget_class = import_item(msg['content']['data']['widget_class'])
         widget = widget_class(comm=comm)
 
 
     #-------------------------------------------------------------------------
     # Traits
     #-------------------------------------------------------------------------
     _model_module = Unicode(None, allow_none=True, help="""A requirejs module name
         in which to find _model_name. If empty, look in the global registry.""")
     _model_name = Unicode('WidgetModel', help="""Name of the backbone model 
         registered in the front-end to create and sync this widget with.""")
     _view_module = Unicode(help="""A requirejs module in which to find _view_name.
         If empty, look in the global registry.""", sync=True)
     _view_name = Unicode(None, allow_none=True, help="""Default view registered in the front-end
         to use to represent the widget.""", sync=True)
     comm = Instance('IPython.kernel.comm.Comm', allow_none=True)
     
     msg_throttle = Int(3, sync=True, help="""Maximum number of msgs the 
         front-end can send before receiving an idle msg from the back-end.""")
     
     version = Int(0, sync=True, help="""Widget's version""")
     keys = List()
     def _keys_default(self):
         return [name for name in self.traits(sync=True)]
     
     _property_lock = Tuple((None, None))
     _send_state_lock = Int(0)
     _states_to_send = Set()
     _display_callbacks = Instance(CallbackDispatcher, ())
     _msg_callbacks = Instance(CallbackDispatcher, ())
     
     #-------------------------------------------------------------------------
     # (Con/de)structor
     #-------------------------------------------------------------------------
     def __init__(self, **kwargs):
         """Public constructor"""
         self._model_id = kwargs.pop('model_id', None)
         super(Widget, self).__init__(**kwargs)
 
         Widget._call_widget_constructed(self)
         self.open()
 
     def __del__(self):
         """Object disposal"""
         self.close()
 
     #-------------------------------------------------------------------------
     # Properties
     #-------------------------------------------------------------------------
 
     def open(self):
         """Open a comm to the frontend if one isn't already open."""
         if self.comm is None:
             args = dict(target_name='ipython.widget',
                         data={'model_name': self._model_name,
                               'model_module': self._model_module})
             if self._model_id is not None:
                 args['comm_id'] = self._model_id
             self.comm = Comm(**args)
 
     def _comm_changed(self, name, new):
         """Called when the comm is changed."""
         if new is None:
             return
         self._model_id = self.model_id
         
         self.comm.on_msg(self._handle_msg)
         Widget.widgets[self.model_id] = self
         
         # first update
         self.send_state()
 
     @property
     def model_id(self):
         """Gets the model id of this widget.
 
         If a Comm doesn't exist yet, a Comm will be created automagically."""
         return self.comm.comm_id
 
     #-------------------------------------------------------------------------
     # Methods
     #-------------------------------------------------------------------------
 
     def close(self):
         """Close method.
 
         Closes the underlying comm.
         When the comm is closed, all of the widget views are automatically
         removed from the front-end."""
         if self.comm is not None:
             Widget.widgets.pop(self.model_id, None)
             self.comm.close()
             self.comm = None
     
     def send_state(self, key=None):
         """Sends the widget state, or a piece of it, to the front-end.
 
         Parameters
         ----------
         key : unicode, or iterable (optional)
             A single property's name or iterable of property names to sync with the front-end.
         """
-        self._send({
-            "method" : "update",
-            "state"  : self.get_state(key=key)
-        })
+        state, buffer_keys, buffers = self.get_state(key=key)
+        msg = {"method": "update", "state": state}
+        if buffer_keys:
+            msg['buffers'] = buffer_keys
+        self._send(msg, buffers=buffers)
 
     def get_state(self, key=None):
         """Gets the widget state, or a piece of it.
 
         Parameters
         ----------
         key : unicode or iterable (optional)
             A single property's name or iterable of property names to get.
+
+        Returns
+        -------
+        state : dict of states
+        buffer_keys : list of strings
+            the values that are stored in buffers
+        buffers : list of binary memoryviews
+            values to transmit in binary
+        metadata : dict
+            metadata for each field: {key: metadata}
         """
         if key is None:
             keys = self.keys
         elif isinstance(key, string_types):
             keys = [key]
         elif isinstance(key, collections.Iterable):
             keys = key
         else:
             raise ValueError("key must be a string, an iterable of keys, or None")
         state = {}
+        buffers = []
+        buffer_keys = []
         for k in keys:
             f = self.trait_metadata(k, 'to_json', self._trait_to_json)
             value = getattr(self, k)
-            state[k] = f(value)
-        return state
+            serialized = f(value)
+            if isinstance(serialized, memoryview):
+                buffers.append(serialized)
+                buffer_keys.append(k)
+            else:
+                state[k] = serialized
+        return state, buffer_keys, buffers
 
     def set_state(self, sync_data):
         """Called when a state is received from the front-end."""
         for name in self.keys:
             if name in sync_data:
                 json_value = sync_data[name]
                 from_json = self.trait_metadata(name, 'from_json', self._trait_from_json)
                 with self._lock_property(name, json_value):
                     setattr(self, name, from_json(json_value))
     
-    def send(self, content):
+    def send(self, content, buffers=None):
         """Sends a custom msg to the widget model in the front-end.
 
         Parameters
         ----------
         content : dict
             Content of the message to send.
+        buffers : list of binary buffers
+            Binary buffers to send with message
         """
-        self._send({"method": "custom", "content": content})
+        self._send({"method": "custom", "content": content}, buffers=buffers)
 
     def on_msg(self, callback, remove=False):
         """(Un)Register a custom msg receive callback.
 
         Parameters
         ----------
         callback: callable
-            callback will be passed two arguments when a message arrives::
+            callback will be passed three arguments when a message arrives::
             
-                callback(widget, content)
+                callback(widget, content, buffers)
             
         remove: bool
             True if the callback should be unregistered."""
         self._msg_callbacks.register_callback(callback, remove=remove)
 
     def on_displayed(self, callback, remove=False):
         """(Un)Register a widget displayed callback.
 
         Parameters
         ----------
         callback: method handler
             Must have a signature of::
             
                 callback(widget, **kwargs)
             
             kwargs from display are passed through without modification.
         remove: bool
             True if the callback should be unregistered."""
         self._display_callbacks.register_callback(callback, remove=remove)
 
     def add_trait(self, traitname, trait):
         """Dynamically add a trait attribute to the Widget."""
         super(Widget, self).add_trait(traitname, trait)
         if trait.get_metadata('sync'):
              self.keys.append(traitname)
              self.send_state(traitname)
 
     #-------------------------------------------------------------------------
     # Support methods
     #-------------------------------------------------------------------------
     @contextmanager
     def _lock_property(self, key, value):
         """Lock a property-value pair.
 
         The value should be the JSON state of the property.
 
         NOTE: This, in addition to the single lock for all state changes, is 
         flawed.  In the future we may want to look into buffering state changes 
         back to the front-end."""
         self._property_lock = (key, value)
         try:
             yield
         finally:
             self._property_lock = (None, None)
 
     @contextmanager
     def hold_sync(self):
         """Hold syncing any state until the context manager is released"""
         # We increment a value so that this can be nested.  Syncing will happen when
         # all levels have been released.
         self._send_state_lock += 1
         try:
             yield
         finally:
             self._send_state_lock -=1
             if self._send_state_lock == 0:
                 self.send_state(self._states_to_send)
                 self._states_to_send.clear()
 
     def _should_send_property(self, key, value):
         """Check the property lock (property_lock)"""
         to_json = self.trait_metadata(key, 'to_json', self._trait_to_json)
         if (key == self._property_lock[0]
             and to_json(value) == self._property_lock[1]):
             return False
         elif self._send_state_lock > 0:
             self._states_to_send.add(key)
             return False
         else:
             return True
     
     # Event handlers
     @_show_traceback
     def _handle_msg(self, msg):
         """Called when a msg is received from the front-end"""
         data = msg['content']['data']
         method = data['method']
 
         # Handle backbone sync methods CREATE, PATCH, and UPDATE all in one.
         if method == 'backbone':
             if 'sync_data' in data:
+                # get binary buffers too
                 sync_data = data['sync_data']
+                for i,k in enumerate(data.get('buffer_keys', [])):
+                    sync_data[k] = msg['buffers'][i]
                 self.set_state(sync_data) # handles all methods
 
         # Handle a state request.
         elif method == 'request_state':
             self.send_state()
 
         # Handle a custom msg from the front-end.
         elif method == 'custom':
             if 'content' in data:
-                self._handle_custom_msg(data['content'])
+                self._handle_custom_msg(data['content'], msg['buffers'])
 
         # Catch remainder.
         else:
             self.log.error('Unknown front-end to back-end widget msg with method "%s"' % method)
 
-    def _handle_custom_msg(self, content):
+    def _handle_custom_msg(self, content, buffers):
         """Called when a custom msg is received."""
-        self._msg_callbacks(self, content)
+        self._msg_callbacks(self, content, buffers)
 
     def _notify_trait(self, name, old_value, new_value):
         """Called when a property has been changed."""
         # Trigger default traitlet callback machinery.  This allows any user
         # registered validation to be processed prior to allowing the widget
         # machinery to handle the state.
         LoggingConfigurable._notify_trait(self, name, old_value, new_value)
 
         # Send the state after the user registered callbacks for trait changes
         # have all fired (allows for user to validate values).
         if self.comm is not None and name in self.keys:
             # Make sure this isn't information that the front-end just sent us.
             if self._should_send_property(name, new_value):
                 # Send new state to front-end
                 self.send_state(key=name)
 
     def _handle_displayed(self, **kwargs):
         """Called when a view has been displayed for this widget instance"""
         self._display_callbacks(self, **kwargs)
 
     def _trait_to_json(self, x):
-        """Convert a trait value to json
-
-        Traverse lists/tuples and dicts and serialize their values as well.
-        Replace any widgets with their model_id
-        """
-        if isinstance(x, dict):
-            return {k: self._trait_to_json(v) for k, v in x.items()}
-        elif isinstance(x, (list, tuple)):
-            return [self._trait_to_json(v) for v in x]
-        elif isinstance(x, Widget):
-            return "IPY_MODEL_" + x.model_id
-        else:
-            return x # Value must be JSON-able
+        """Convert a trait value to json."""
+        return x
 
     def _trait_from_json(self, x):
-        """Convert json values to objects
-
-        Replace any strings representing valid model id values to Widget references.
-        """
-        if isinstance(x, dict):
-            return {k: self._trait_from_json(v) for k, v in x.items()}
-        elif isinstance(x, (list, tuple)):
-            return [self._trait_from_json(v) for v in x]
-        elif isinstance(x, string_types) and x.startswith('IPY_MODEL_') and x[10:] in Widget.widgets:
-            # we want to support having child widgets at any level in a hierarchy
-            # trusting that a widget UUID will not appear out in the wild
-            return Widget.widgets[x[10:]]
-        else:
-            return x
+        """Convert json values to objects."""
+        return x
 
     def _ipython_display_(self, **kwargs):
         """Called when `IPython.display.display` is called on the widget."""
         # Show view.
         if self._view_name is not None:
             self._send({"method": "display"})
             self._handle_displayed(**kwargs)
 
-    def _send(self, msg):
+    def _send(self, msg, buffers=None):
         """Sends a message to the model in the front-end."""
-        self.comm.send(msg)
+        self.comm.send(data=msg, buffers=buffers)
 
 
 class DOMWidget(Widget):
     visible = Bool(True, allow_none=True, help="Whether the widget is visible.  False collapses the empty space, while None preserves the empty space.", sync=True)
     _css = Tuple(sync=True, help="CSS property list: (selector, key, value)")
     _dom_classes = Tuple(sync=True, help="DOM classes applied to widget.$el.")
     
     width = CUnicode(sync=True)
     height = CUnicode(sync=True)
     # A default padding of 2.5 px makes the widgets look nice when displayed inline.
     padding = CUnicode(sync=True)
     margin = CUnicode(sync=True)
 
     color = Color(None, allow_none=True, sync=True)
     background_color = Color(None, allow_none=True, sync=True)
     border_color = Color(None, allow_none=True, sync=True)
 
     border_width = CUnicode(sync=True)
     border_radius = CUnicode(sync=True)
     border_style = CaselessStrEnum(values=[ # http://www.w3schools.com/cssref/pr_border-style.asp
         'none', 
         'hidden', 
         'dotted', 
         'dashed', 
         'solid', 
         'double', 
         'groove', 
         'ridge', 
         'inset', 
         'outset', 
         'initial', 
         'inherit', ''],
         default_value='', sync=True)
 
     font_style = CaselessStrEnum(values=[ # http://www.w3schools.com/cssref/pr_font_font-style.asp
         'normal', 
         'italic', 
         'oblique', 
         'initial', 
         'inherit', ''], 
         default_value='', sync=True)
     font_weight = CaselessStrEnum(values=[ # http://www.w3schools.com/cssref/pr_font_weight.asp
         'normal', 
         'bold', 
         'bolder', 
         'lighter',
         'initial', 
         'inherit', ''] + list(map(str, range(100,1000,100))),
         default_value='', sync=True)
     font_size = CUnicode(sync=True)
     font_family = Unicode(sync=True)
 
     def __init__(self, *pargs, **kwargs):
         super(DOMWidget, self).__init__(*pargs, **kwargs)
 
         def _validate_border(name, old, new):
             if new is not None and new != '':
                 if name != 'border_width' and not self.border_width:
                     self.border_width = 1
                 if name != 'border_style' and self.border_style == '':
                     self.border_style = 'solid'
         self.on_trait_change(_validate_border, ['border_width', 'border_style', 'border_color'])

IPython/html/widgets/widget_box.py

@@ -1,80 +1,107 b''
 """Box class.  
 
 Represents a container that can be used to group other widgets.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from .widget import DOMWidget, register
+from .widget import DOMWidget, Widget, register
 from IPython.utils.traitlets import Unicode, Tuple, TraitError, Int, CaselessStrEnum
 from IPython.utils.warn import DeprecatedClass
 
+def _widget_to_json(x):
+    if isinstance(x, dict):
+        return {k: _widget_to_json(v) for k, v in x.items()}
+    elif isinstance(x, (list, tuple)):
+        return [_widget_to_json(v) for v in x]
+    elif isinstance(x, Widget):
+        return "IPY_MODEL_" + x.model_id
+    else:
+        return x
+
+def _json_to_widget(x):
+    if isinstance(x, dict):
+        return {k: _json_to_widget(v) for k, v in x.items()}
+    elif isinstance(x, (list, tuple)):
+        return [_json_to_widget(v) for v in x]
+    elif isinstance(x, string_types) and x.startswith('IPY_MODEL_') and x[10:] in Widget.widgets:
+        return Widget.widgets[x[10:]]
+    else:
+        return x
+
+widget_serialization = {
+    'from_json': _json_to_widget,
+    'to_json': _widget_to_json
+}
+
+
 @register('IPython.Box')
 class Box(DOMWidget):
     """Displays multiple widgets in a group."""
+    _model_name = Unicode('BoxModel', sync=True)
     _view_name = Unicode('BoxView', sync=True)
 
     # Child widgets in the container.
     # Using a tuple here to force reassignment to update the list.
     # When a proper notifying-list trait exists, that is what should be used here.
-    children = Tuple(sync=True)
+    children = Tuple(sync=True, **widget_serialization)
     
     _overflow_values = ['visible', 'hidden', 'scroll', 'auto', 'initial', 'inherit', '']
     overflow_x = CaselessStrEnum(
         values=_overflow_values, 
         default_value='', sync=True, help="""Specifies what
         happens to content that is too large for the rendered region.""")
     overflow_y = CaselessStrEnum(
         values=_overflow_values, 
         default_value='', sync=True, help="""Specifies what
         happens to content that is too large for the rendered region.""")
 
     box_style = CaselessStrEnum(
         values=['success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the box.""")
 
     def __init__(self, children = (), **kwargs):
         kwargs['children'] = children
         super(Box, self).__init__(**kwargs)
         self.on_displayed(Box._fire_children_displayed)
 
     def _fire_children_displayed(self):
         for child in self.children:
             child._handle_displayed()
 
 
 @register('IPython.FlexBox')
 class FlexBox(Box):
     """Displays multiple widgets using the flexible box model."""
     _view_name = Unicode('FlexBoxView', sync=True)
     orientation = CaselessStrEnum(values=['vertical', 'horizontal'], default_value='vertical', sync=True)
     flex = Int(0, sync=True, help="""Specify the flexible-ness of the model.""")
     def _flex_changed(self, name, old, new):
         new = min(max(0, new), 2)
         if self.flex != new:
             self.flex = new
 
     _locations = ['start', 'center', 'end', 'baseline', 'stretch']
     pack = CaselessStrEnum(
         values=_locations, 
         default_value='start', sync=True)
     align = CaselessStrEnum(
         values=_locations, 
         default_value='start', sync=True)
 
 
 def VBox(*pargs, **kwargs):
     """Displays multiple widgets vertically using the flexible box model."""
     kwargs['orientation'] = 'vertical'
     return FlexBox(*pargs, **kwargs)
 
 def HBox(*pargs, **kwargs):
     """Displays multiple widgets horizontally using the flexible box model."""
     kwargs['orientation'] = 'horizontal'
     return FlexBox(*pargs, **kwargs)
 
 
 # Remove in IPython 4.0
 ContainerWidget = DeprecatedClass(Box, 'ContainerWidget')

IPython/html/widgets/widget_button.py

@@ -1,82 +1,82 b''
 """Button class.  
 
 Represents a button in the frontend using a widget.  Allows user to listen for
 click events on the button and trigger backend code when the clicks are fired.
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from .widget import DOMWidget, CallbackDispatcher, register
 from IPython.utils.traitlets import Unicode, Bool, CaselessStrEnum
 from IPython.utils.warn import DeprecatedClass
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 @register('IPython.Button')
 class Button(DOMWidget):
     """Button widget.
        This widget has an `on_click` method that allows you to listen for the 
        user clicking on the button.  The click event itself is stateless.
 
        Parameters
        ----------
        description : str
            description displayed next to the button
        tooltip: str
            tooltip caption of the toggle button
        icon: str
            font-awesome icon name
     """
     _view_name = Unicode('ButtonView', sync=True)
 
     # Keys
     description = Unicode('', help="Button label.", sync=True)
     tooltip = Unicode(help="Tooltip caption of the button.", sync=True)
     disabled = Bool(False, help="Enable or disable user changes.", sync=True)
     icon = Unicode('', help= "Font-awesome icon.", sync=True)
 
     button_style = CaselessStrEnum(
         values=['primary', 'success', 'info', 'warning', 'danger', ''], 
         default_value='', allow_none=True, sync=True, help="""Use a
         predefined styling for the button.""")
     
     def __init__(self, **kwargs):
         """Constructor"""
         super(Button, self).__init__(**kwargs)
         self._click_handlers = CallbackDispatcher()
         self.on_msg(self._handle_button_msg)
 
     def on_click(self, callback, remove=False):
         """Register a callback to execute when the button is clicked.
 
         The callback will be called with one argument,
         the clicked button widget instance.
 
         Parameters
         ----------
         remove : bool (optional)
             Set to true to remove the callback from the list of callbacks."""
         self._click_handlers.register_callback(callback, remove=remove)
 
-    def _handle_button_msg(self, _, content):
+    def _handle_button_msg(self, _, content, buffers):
         """Handle a msg from the front-end.
 
         Parameters
         ----------
         content: dict
             Content of the msg."""
         if content.get('event', '') == 'click':
             self._click_handlers(self)
 
 
 # Remove in IPython 4.0
 ButtonWidget = DeprecatedClass(Button, 'ButtonWidget')