s/target/target_name

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

@@ -1,173 +1,173 b''
 //----------------------------------------------------------------------------
 //  Copyright (C) 2013  The IPython Development Team
 //
 //  Distributed under the terms of the BSD License.  The full license is in
 //  the file COPYING, distributed as part of this software.
 //----------------------------------------------------------------------------
 
 //============================================================================
 // Comm and CommManager bases
 //============================================================================
 /**
  * Base Comm classes
  * @module IPython
  * @namespace IPython
  * @submodule comm
  */
 
 var IPython = (function (IPython) {
     "use strict";
 
     //-----------------------------------------------------------------------
     // CommManager class
     //-----------------------------------------------------------------------
     
     var CommManager = function (kernel) {
         this.comms = {};
-        this.targets = {comm : Comm};
+        this.targets = {};
         if (kernel !== undefined) {
             this.init_kernel(kernel);
         }
     };
     
     CommManager.prototype.init_kernel = function (kernel) {
         // connect the kernel, and register message handlers
         this.kernel = kernel;
         var msg_types = ['comm_open', 'comm_msg', 'comm_close'];
         for (var i = 0; i < msg_types.length; i++) {
             var msg_type = msg_types[i];
             kernel.register_iopub_handler(msg_type, $.proxy(this[msg_type], this));
         }
     };
     
-    CommManager.prototype.register_target = function (target, constructor) {
-        // Register a constructor for a given target key
-        this.targets[target] = constructor;
+    CommManager.prototype.register_target = function (target_name, f) {
+        // Register a target function for a given target name
+        this.targets[target_name] = f;
     };
     
     CommManager.prototype.register_comm = function (comm) {
         // Register a comm in the mapping
         this.comms[comm.comm_id] = comm;
         comm.kernel = this.kernel;
         return comm.comm_id;
     };
     
     CommManager.prototype.unregister_comm = function (comm_id) {
         // Remove a comm from the mapping
         delete this.comms[comm_id];
     };
     
     // comm message handlers
     
     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;
         }
         var comm = new Comm(content.comm_id);
         this.register_comm(comm);
         callback(comm);
         comm.handle_open(msg);
     };
     
     CommManager.prototype.comm_close = function (msg) {
         var content = msg.content;
         var comm = this.comms[content.comm_id];
         if (comm === undefined) {
             return;
         }
         delete this.comms[content.comm_id];
         comm.handle_close(msg);
     };
     
     CommManager.prototype.comm_msg = function (msg) {
         var content = msg.content;
         var comm = this.comms[content.comm_id];
         if (comm === undefined) {
             return;
         }
         comm.handle_msg(msg);
     };
     
     //-----------------------------------------------------------------------
     // 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;
     };
     
     // methods for sending messages
     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);
     };
     
     Comm.prototype.send = function (data, callbacks) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_msg", content, callbacks);
     };
     
     Comm.prototype.close = function (data, callbacks) {
         var content = {
             comm_id : this.comm_id,
             data : data || {},
         };
         return this.kernel.send_shell_message("comm_close", content, callbacks);
     };
     
     // methods for registering callbacks for incoming messages
     Comm.prototype._register_callback = function (key, callback) {
         this['_' + key + '_callback'] = callback;
     };
     
     Comm.prototype.on_open = function (callback) {
         this._register_callback('open', callback);
     };
     
     Comm.prototype.on_msg = function (callback) {
         this._register_callback('msg', callback);
     };
     
     Comm.prototype.on_close = function (callback) {
         this._register_callback('close', callback);
     };
     
     // methods for handling incoming messages
     
     Comm.prototype._maybe_callback = function (key, msg) {
         var callback = this['_' + key + '_callback'];
         if (callback) callback(msg);
     };
     
     Comm.prototype.handle_open = function (msg) {
         this._maybe_callback('open', msg);
     };
     
     Comm.prototype.handle_msg = function (msg) {
         this._maybe_callback('msg', msg);
     };
     
     Comm.prototype.handle_close = function (msg) {
         this._maybe_callback('close', msg);
     };
     
     IPython.CommManager = CommManager;
     IPython.Comm = Comm;
     
     return IPython;
 
 }(IPython));
 

IPython/kernel/comm/comm.py

@@ -1,150 +1,150 b''
 """Base class for a Comm"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import uuid
 
 from IPython.config import LoggingConfigurable
 from IPython.core.getipython import get_ipython
 
 from IPython.utils.traitlets import Instance, Unicode, Bytes, Bool, Dict, Any
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 class Comm(LoggingConfigurable):
     
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     def _shell_default(self):
         return get_ipython()
     
     iopub_socket = Any()
     def _iopub_socket_default(self):
         return self.shell.kernel.iopub_socket
     session = Instance('IPython.kernel.zmq.session.Session')
     def _session_default(self):
         if self.shell is None:
             return
         return self.shell.kernel.session
     
-    target = Unicode('comm')
+    target_name = Unicode('comm')
     
     topic = Bytes()
     def _topic_default(self):
         return ('comm-%s' % self.comm_id).encode('ascii')
     
     _open_data = Dict(help="data dict, if any, to be included in comm_close")
     _close_data = Dict(help="data dict, if any, to be included in comm_close")
     
     _open_callback = Any()
     _msg_callback = Any()
     _close_callback = Any()
     
     _closed = Bool(False)
     comm_id = Unicode()
     def _comm_id_default(self):
         return uuid.uuid4().hex
     
     primary = Bool(True, help="Am I the primary or secondary Comm?")
     
     def __init__(self, data=None, **kwargs):
         super(Comm, self).__init__(**kwargs)
         get_ipython().comm_manager.register_comm(self)
         if self.primary:
             # I am primary, open my peer
             self.open(data)
     
     def _publish_msg(self, msg_type, data=None, **keys):
         """Helper for sending a comm message on IOPub"""
         data = {} if data is None else data
         self.session.send(self.iopub_socket, msg_type,
             dict(data=data, comm_id=self.comm_id, **keys),
             ident=self.topic,
         )
     
     def __del__(self):
         """trigger close on gc"""
         self.close()
     
     # publishing messages
     
     def open(self, data=None):
         """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"""
         if self._closed:
             # only close once
             return
         if data is None:
             data = self._close_data
         self._publish_msg('comm_close', data)
         self._closed = True
     
     def send(self, data=None):
         """Send a message to the frontend-side version of this comm"""
         self._publish_msg('comm_msg', data)
     
     # registering callbacks
     def on_open(self, callback):
         """Register a callback for comm_open
         
         Will be called with the `data` of the open message.
         
         Call `on_open(None)` to disable an existing callback.
         """
         self._open_callback = callback
     
     def on_close(self, callback):
         """Register a callback for comm_close
         
         Will be called with the `data` of the close message.
         
         Call `on_close(None)` to disable an existing callback.
         """
         self._close_callback = callback
     
     def on_msg(self, callback):
         """Register a callback for comm_msg
         
         Will be called with the `data` of any comm_msg messages.
         
         Call `on_msg(None)` to disable an existing callback.
         """
         self._msg_callback = callback
     
     # handling of incoming messages
     
     def handle_open(self, msg):
         """Handle a comm_open message"""
         self.log.debug("handle_open[%s](%s)", self.comm_id, msg)
         if self._open_callback:
             self._open_callback(msg)
     
     def handle_close(self, msg):
         """Handle a comm_close message"""
         self.log.debug("handle_close[%s](%s)", self.comm_id, msg)
         if self._close_callback:
             self._close_callback(msg)
     
     def handle_msg(self, msg):
         """Handle a comm_msg message"""
         self.log.debug("handle_msg[%s](%s)", self.comm_id, msg)
         if self._msg_callback:
             self._msg_callback(msg)
 
 
 __all__ = ['Comm']

IPython/kernel/comm/manager.py

@@ -1,167 +1,167 b''
 """Base class to manage comms"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import sys
 
 from IPython.config import LoggingConfigurable
 from IPython.core.prompts import LazyEvaluate
 from IPython.core.getipython import get_ipython
 
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import Instance, Unicode, Dict, Any
 
 from .comm import Comm
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 def lazy_keys(dikt):
     """Return lazy-evaluated string representation of a dictionary's keys
     
     Key list is only constructed if it will actually be used.
     Used for debug-logging.
     """
     return LazyEvaluate(lambda d: list(d.keys()))
 
 
 def with_output(method):
     """method decorator for ensuring output is handled properly in a message handler
     
     - sets parent header before entering the method
     - publishes busy/idle
     - flushes stdout/stderr after
     """
     def method_with_output(self, stream, ident, msg):
         parent = msg['header']
         self.shell.set_parent(parent)
         self.shell.kernel._publish_status('busy')
         try:
             return method(self, stream, ident, msg)
         finally:
             sys.stdout.flush()
             sys.stderr.flush()
             self.shell.kernel._publish_status('idle')
     
     return method_with_output
 
 
 class CommManager(LoggingConfigurable):
     """Manager for Comms in the Kernel"""
     
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     def _shell_default(self):
         return get_ipython()
     iopub_socket = Any()
     def _iopub_socket_default(self):
         return self.shell.kernel.iopub_socket
     session = Instance('IPython.kernel.zmq.session.Session')
     def _session_default(self):
         if self.shell is None:
             return
         return self.shell.kernel.session
     
     comms = Dict()
     targets = Dict()
     
     # Public APIs
     
-    def register_target(self, target, f):
-        """Register a callable f for a given target
+    def register_target(self, target_name, f):
+        """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`.
         
         f can be a Python callable or an import string for one.
         """
         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"""
         comm_id = comm.comm_id
         comm.shell = self.shell
         comm.iopub_socket = self.iopub_socket
         self.comms[comm_id] = comm
         return comm_id
     
     def unregister_comm(self, comm_id):
         """Unregister a comm, and close its counterpart"""
         # unlike get_comm, this should raise a KeyError
         comm = self.comms.pop(comm_id)
         comm.close()
     
     def get_comm(self, comm_id):
         """Get a comm with a particular id
         
         Returns the comm if found, otherwise None.
         
         This will not raise an error,
         it will log messages if the comm cannot be found.
         """
         if comm_id not in self.comms:
             self.log.error("No such comm: %s", comm_id)
             self.log.debug("Current comms: %s", lazy_keys(self.comms))
             return
         # call, because we store weakrefs
         comm = self.comms[comm_id]
         return comm
     
     # Message handlers
     @with_output
     def comm_open(self, stream, ident, msg):
         """Handler for comm_open messages"""
         content = msg['content']
         comm_id = content['comm_id']
-        target = content['target']
-        callback = self.targets.get(target, None)
+        target_name = content['target_name']
+        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:
-            self.log.error("No such comm target registered: %s", target)
+        if f is None:
+            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)
     
     @with_output
     def comm_msg(self, stream, ident, msg):
         """Handler for comm_msg messages"""
         content = msg['content']
         comm_id = content['comm_id']
         comm = self.get_comm(comm_id)
         if comm is None:
             # no such comm
             return
         comm.handle_msg(msg)
     
     @with_output
     def comm_close(self, stream, ident, msg):
         """Handler for comm_close messages"""
         content = msg['content']
         comm_id = content['comm_id']
         comm = self.get_comm(comm_id)
         if comm is None:
             # no such comm
             return
         del self.comms[comm_id]
         comm.handle_close(msg)
 
 
 __all__ = ['CommManager']