upstream/ipython Commit - r13204:f6f777f9

s/target/target_name

MinRK -

r13204:f6f777f9

parent child

IPython/html/static/notebook/js/comm.js

0 +9 -9

                 var CommManager = function (kernel) {
                     this.comms = {};
-                    this.targets = {comm : Comm};
+                    this.targets = {};
                     if (kernel !== undefined) {
                         this.init_kernel(kernel);
                     }
                     }
                 };
-                CommManager.prototype.register_target = function (target, constructor) {
+                CommManager.prototype.register_target = function (target_name, f) {
-                    // Register a constructor for a given target key
+                    // Register a target function for a given target name
-                    this.targets[target] = constructor;
+                    this.targets[target_name] = f;
                 };
                 CommManager.prototype.register_comm = function (comm) {
                 CommManager.prototype.comm_open = function (msg) {
                     var content = msg.content;
-                    var callback = this.targets[content.target];
+                    var callback = this.targets[content.target_name];
                     if (callback === undefined) {
-                        console.log("No such target registered: ", content.target);
+                        console.log("No such target registered: ", content.target_name);
                         console.log("Available targets are: ", this.targets);
                         return;
                     }
                 // Comm base class
                 //-----------------------------------------------------------------------
-                var Comm = function (comm_id, target) {
+                var Comm = function (comm_id, target_name) {
                     this.comm_id = comm_id || new IPython.utils.uuid();
-                    this.target = target || 'comm';
+                    this.target_name = target_name;
                     this._msg_callback = this._open_callback = this._close_callback = null;
                 };
                 Comm.prototype.open = function (data, callbacks) {
                     var content = {
                         comm_id : this.comm_id,
-                        target : this.target,
+                        target_name : this.target_name,
                         data : data || {},
                     };
                     return this.kernel.send_shell_message("comm_open", content, callbacks);

IPython/kernel/comm/comm.py

0 +2 -2

                         return
                     return self.shell.kernel.session
-                target = Unicode('comm')
+                target_name = Unicode('comm')
                 topic = Bytes()
                 def _topic_default(self):
                     """Open the frontend-side version of this comm"""
                     if data is None:
                         data = self._open_data
-                    self._publish_msg('comm_open', data, target=self.target)
+                    self._publish_msg('comm_open', data, target_name=self.target_name)
                 def close(self, data=None):
                     """Close the frontend-side version of this comm"""

IPython/kernel/comm/manager.py

0 +8 -8

                 # Public APIs
-                def register_target(self, target, f):
+                def register_target(self, target_name, f):
-                    """Register a callable f for a given target
+                    """Register a callable f for a given target name
                     f will be called with a Comm object as its only argument
                     when a comm_open message is received with `target`.
                     if isinstance(f, basestring):
                         f = import_item(f)
-                    self.targets[target] = f
+                    self.targets[target_name] = f
                 def register_comm(self, comm):
                     """Register a new comm"""
                     """Handler for comm_open messages"""
                     content = msg['content']
                     comm_id = content['comm_id']
-                    target = content['target']
+                    target_name = content['target_name']
-                    callback = self.targets.get(target, None)
+                    f = self.targets.get(target_name, None)
                     comm = Comm(comm_id=comm_id,
                                 shell=self.shell,
                                 iopub_socket=self.iopub_socket,
                                 primary=False,
                     )
-                    if callback is None:
+                    if f is None:
-                        self.log.error("No such comm target registered: %s", target)
+                        self.log.error("No such comm target registered: %s", target_name)
                         comm.close()
                         return
-                    callback(comm)
+                    f(comm)
                     comm.handle_open(msg)
                     self.register_comm(comm)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages