move zmq.KernelManagers into IPython.kernel

IPython/frontend/consoleapp.py

@@ -1,362 +1,362 b''
 """ A minimal application base mixin for all ZMQ based IPython frontends.
 
 This is not a complete console app, as subprocess will not be able to receive
 input, there is no real readline support, among other limitations. This is a
 refactoring of what used to be the IPython/frontend/qt/console/qtconsoleapp.py
 
 Authors:
 
 * Evan Patterson
 * Min RK
 * Erik Tollerud
 * Fernando Perez
 * Bussonnier Matthias
 * Thomas Kluyver
 * Paul Ivanov
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # stdlib imports
 import atexit
 import json
 import os
 import shutil
 import signal
 import sys
 import uuid
 
 
 # Local imports
 from IPython.config.application import boolean_flag
 from IPython.config.configurable import Configurable
 from IPython.core.profiledir import ProfileDir
-from IPython.zmq.blockingkernelmanager import BlockingKernelManager
-from IPython.zmq.kernelmanager import KernelManager
+from IPython.kernel.blockingkernelmanager import BlockingKernelManager
+from IPython.kernel.kernelmanager import KernelManager
 from IPython.kernel import tunnel_to_kernel, find_connection_file, swallow_argv
 from IPython.utils.path import filefind
 from IPython.utils.py3compat import str_to_bytes
 from IPython.utils.traitlets import (
     Dict, List, Unicode, CUnicode, Int, CBool, Any, CaselessStrEnum
 )
 from IPython.zmq.kernelapp import (
     kernel_flags,
     kernel_aliases,
     IPKernelApp
 )
 from IPython.zmq.session import Session, default_secure
 from IPython.zmq.zmqshell import ZMQInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Network Constants
 #-----------------------------------------------------------------------------
 
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags
 #-----------------------------------------------------------------------------
 
 flags = dict(kernel_flags)
 
 # the flags that are specific to the frontend
 # these must be scrubbed before being passed to the kernel,
 # or it will raise an error on unrecognized flags
 app_flags = {
     'existing' : ({'IPythonConsoleApp' : {'existing' : 'kernel*.json'}},
             "Connect to an existing kernel. If no argument specified, guess most recent"),
 }
 app_flags.update(boolean_flag(
     'confirm-exit', 'IPythonConsoleApp.confirm_exit',
     """Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
        to force a direct exit without any confirmation.
     """,
     """Don't prompt the user when exiting. This will terminate the kernel
        if it is owned by the frontend, and leave it alive if it is external.
     """
 ))
 flags.update(app_flags)
 
 aliases = dict(kernel_aliases)
 
 # also scrub aliases from the frontend
 app_aliases = dict(
     ip = 'KernelManager.ip',
     transport = 'KernelManager.transport',
     hb = 'IPythonConsoleApp.hb_port',
     shell = 'IPythonConsoleApp.shell_port',
     iopub = 'IPythonConsoleApp.iopub_port',
     stdin = 'IPythonConsoleApp.stdin_port',
     existing = 'IPythonConsoleApp.existing',
     f = 'IPythonConsoleApp.connection_file',
 
 
     ssh = 'IPythonConsoleApp.sshserver',
 )
 aliases.update(app_aliases)
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # IPythonConsole
 #-----------------------------------------------------------------------------
 
 classes = [IPKernelApp, ZMQInteractiveShell, KernelManager, ProfileDir, Session]
 
 try:
     from IPython.zmq.pylab.backend_inline import InlineBackend
 except ImportError:
     pass
 else:
     classes.append(InlineBackend)
 
 class IPythonConsoleApp(Configurable):
     name = 'ipython-console-mixin'
     default_config_file_name='ipython_config.py'
 
     description = """
         The IPython Mixin Console.
         
         This class contains the common portions of console client (QtConsole,
         ZMQ-based terminal console, etc).  It is not a full console, in that
         launched terminal subprocesses will not be able to accept input.
         
         The Console using this mixing supports various extra features beyond
         the single-process Terminal IPython shell, such as connecting to
         existing kernel, via:
         
             ipython <appname> --existing
         
         as well as tunnel via SSH
         
     """
 
     classes = classes
     flags = Dict(flags)
     aliases = Dict(aliases)
     kernel_manager_class = BlockingKernelManager
 
     kernel_argv = List(Unicode)
     # frontend flags&aliases to be stripped when building kernel_argv
     frontend_flags = Any(app_flags)
     frontend_aliases = Any(app_aliases)
 
     # create requested profiles by default, if they don't exist:
     auto_create = CBool(True)
     # connection info:
     
     sshserver = Unicode('', config=True,
         help="""The SSH server to use to connect to the kernel.""")
     sshkey = Unicode('', config=True,
         help="""Path to the ssh key to use for logging in to the ssh server.""")
     
     hb_port = Int(0, config=True,
         help="set the heartbeat port [default: random]")
     shell_port = Int(0, config=True,
         help="set the shell (ROUTER) port [default: random]")
     iopub_port = Int(0, config=True,
         help="set the iopub (PUB) port [default: random]")
     stdin_port = Int(0, config=True,
         help="set the stdin (DEALER) port [default: random]")
     connection_file = Unicode('', config=True,
         help="""JSON file in which to store connection info [default: kernel-<pid>.json]
 
         This file will contain the IP, ports, and authentication key needed to connect
         clients to this kernel. By default, this file will be created in the security-dir
         of the current profile, but can be specified by absolute path.
         """)
     def _connection_file_default(self):
         return 'kernel-%i.json' % os.getpid()
 
     existing = CUnicode('', config=True,
         help="""Connect to an already running kernel""")
 
     confirm_exit = CBool(True, config=True,
         help="""
         Set to display confirmation dialog on exit. You can always use 'exit' or 'quit',
         to force a direct exit without any confirmation.""",
     )
 
 
     def build_kernel_argv(self, argv=None):
         """build argv to be passed to kernel subprocess"""
         if argv is None:
             argv = sys.argv[1:]
         self.kernel_argv = swallow_argv(argv, self.frontend_aliases, self.frontend_flags)
         # kernel should inherit default config file from frontend
         self.kernel_argv.append("--KernelApp.parent_appname='%s'"%self.name)
     
     def init_connection_file(self):
         """find the connection file, and load the info if found.
         
         The current working directory and the current profile's security
         directory will be searched for the file if it is not given by
         absolute path.
         
         When attempting to connect to an existing kernel and the `--existing`
         argument does not match an existing file, it will be interpreted as a
         fileglob, and the matching file in the current profile's security dir
         with the latest access time will be used.
         
         After this method is called, self.connection_file contains the *full path*
         to the connection file, never just its name.
         """
         if self.existing:
             try:
                 cf = find_connection_file(self.existing)
             except Exception:
                 self.log.critical("Could not find existing kernel connection file %s", self.existing)
                 self.exit(1)
             self.log.info("Connecting to existing kernel: %s" % cf)
             self.connection_file = cf
         else:
             # not existing, check if we are going to write the file
             # and ensure that self.connection_file is a full path, not just the shortname
             try:
                 cf = find_connection_file(self.connection_file)
             except Exception:
                 # file might not exist
                 if self.connection_file == os.path.basename(self.connection_file):
                     # just shortname, put it in security dir
                     cf = os.path.join(self.profile_dir.security_dir, self.connection_file)
                 else:
                     cf = self.connection_file
                 self.connection_file = cf
         
         # should load_connection_file only be used for existing?
         # as it is now, this allows reusing ports if an existing
         # file is requested
         try:
             self.load_connection_file()
         except Exception:
             self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
             self.exit(1)
     
     def load_connection_file(self):
         """load ip/port/hmac config from JSON connection file"""
         # this is identical to KernelApp.load_connection_file
         # perhaps it can be centralized somewhere?
         try:
             fname = filefind(self.connection_file, ['.', self.profile_dir.security_dir])
         except IOError:
             self.log.debug("Connection File not found: %s", self.connection_file)
             return
         self.log.debug(u"Loading connection file %s", fname)
         with open(fname) as f:
             cfg = json.load(f)
         
         self.config.KernelManager.transport = cfg.get('transport', 'tcp')
         self.config.KernelManager.ip = cfg.get('ip', LOCALHOST)
         
         for channel in ('hb', 'shell', 'iopub', 'stdin'):
             name = channel + '_port'
             if getattr(self, name) == 0 and name in cfg:
                 # not overridden by config or cl_args
                 setattr(self, name, cfg[name])
         if 'key' in cfg:
             self.config.Session.key = str_to_bytes(cfg['key'])
     
     def init_ssh(self):
         """set up ssh tunnels, if needed."""
         if not self.existing or (not self.sshserver and not self.sshkey):
             return
         
         self.load_connection_file()
         
         transport = self.config.KernelManager.transport
         ip = self.config.KernelManager.ip
         
         if transport != 'tcp':
             self.log.error("Can only use ssh tunnels with TCP sockets, not %s", transport)
             sys.exit(-1)
         
         if self.sshkey and not self.sshserver:
             # specifying just the key implies that we are connecting directly
             self.sshserver = ip
             ip = LOCALHOST
         
         # build connection dict for tunnels:
         info = dict(ip=ip,
                     shell_port=self.shell_port,
                     iopub_port=self.iopub_port,
                     stdin_port=self.stdin_port,
                     hb_port=self.hb_port
         )
         
         self.log.info("Forwarding connections to %s via %s"%(ip, self.sshserver))
         
         # tunnels return a new set of ports, which will be on localhost:
         self.config.KernelManager.ip = LOCALHOST
         try:
             newports = tunnel_to_kernel(info, self.sshserver, self.sshkey)
         except:
             # even catch KeyboardInterrupt
             self.log.error("Could not setup tunnels", exc_info=True)
             self.exit(1)
         
         self.shell_port, self.iopub_port, self.stdin_port, self.hb_port = newports
         
         cf = self.connection_file
         base,ext = os.path.splitext(cf)
         base = os.path.basename(base)
         self.connection_file = os.path.basename(base)+'-ssh'+ext
         self.log.critical("To connect another client via this tunnel, use:")
         self.log.critical("--existing %s" % self.connection_file)
     
     def _new_connection_file(self):
         cf = ''
         while not cf:
             # we don't need a 128b id to distinguish kernels, use more readable
             # 48b node segment (12 hex chars).  Users running more than 32k simultaneous
             # kernels can subclass.
             ident = str(uuid.uuid4()).split('-')[-1]
             cf = os.path.join(self.profile_dir.security_dir, 'kernel-%s.json' % ident)
             # only keep if it's actually new.  Protect against unlikely collision
             # in 48b random search space
             cf = cf if not os.path.exists(cf) else ''
         return cf
 
     def init_kernel_manager(self):
         # Don't let Qt or ZMQ swallow KeyboardInterupts.
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
         # Create a KernelManager and start a kernel.
         self.kernel_manager = self.kernel_manager_class(
                                 shell_port=self.shell_port,
                                 iopub_port=self.iopub_port,
                                 stdin_port=self.stdin_port,
                                 hb_port=self.hb_port,
                                 connection_file=self.connection_file,
                                 config=self.config,
         )
         # start the kernel
         if not self.existing:
             self.kernel_manager.start_kernel(extra_arguments=self.kernel_argv)
             atexit.register(self.kernel_manager.cleanup_ipc_files)
         elif self.sshserver:
             # ssh, write new connection file
             self.kernel_manager.write_connection_file()
         atexit.register(self.kernel_manager.cleanup_connection_file)
         self.kernel_manager.start_channels()
 
 
     def initialize(self, argv=None):
         """
         Classes which mix this class in should call:
                IPythonConsoleApp.initialize(self,argv)
         """
         self.init_connection_file()
         default_secure(self.config)
         self.init_ssh()
         self.init_kernel_manager()
 

IPython/frontend/html/notebook/kernelmanager.py

@@ -1,364 +1,364 b''
 """A kernel manager for multiple kernels.
 
 Authors:
 
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import uuid
 
 import zmq
 from zmq.eventloop.zmqstream import ZMQStream
 
 from tornado import web
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import (
     Instance, Dict, List, Unicode, Float, Integer, Any, DottedObjectName,
 )
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class DuplicateKernelError(Exception):
     pass
 
 
 class MultiKernelManager(LoggingConfigurable):
     """A class for managing multiple kernels."""
     
     kernel_manager_class = DottedObjectName(
-        "IPython.zmq.blockingkernelmanager.BlockingKernelManager", config=True,
+        "IPython.kernel.blockingkernelmanager.BlockingKernelManager", config=True,
         help="""The kernel manager class.  This is configurable to allow
         subclassing of the KernelManager for customized behavior.
         """
     )
     def _kernel_manager_class_changed(self, name, old, new):
         self.kernel_manager_factory = import_item(new)
     
     kernel_manager_factory = Any(help="this is kernel_manager_class after import")
     def _kernel_manager_factory_default(self):
         return import_item(self.kernel_manager_class)
     
     context = Instance('zmq.Context')
     def _context_default(self):
         return zmq.Context.instance()
     
     connection_dir = Unicode('')
 
     _kernels = Dict()
 
     def list_kernel_ids(self):
         """Return a list of the kernel ids of the active kernels."""
         # Create a copy so we can iterate over kernels in operations
         # that delete keys.
         return list(self._kernels.keys())
 
     def __len__(self):
         """Return the number of running kernels."""
         return len(self.list_kernel_ids())
 
     def __contains__(self, kernel_id):
         return kernel_id in self._kernels
 
     def start_kernel(self, **kwargs):
         """Start a new kernel.
 
         The caller can pick a kernel_id by passing one in as a keyword arg,
         otherwise one will be picked using a uuid.
 
         To silence the kernel's stdout/stderr, call this using::
 
             km.start_kernel(stdout=PIPE, stderr=PIPE)
 
         """
         kernel_id = kwargs.pop('kernel_id', unicode(uuid.uuid4()))
         if kernel_id in self:
             raise DuplicateKernelError('Kernel already exists: %s' % kernel_id)
         # kernel_manager_factory is the constructor for the KernelManager
         # subclass we are using. It can be configured as any Configurable,
         # including things like its transport and ip.
         km = self.kernel_manager_factory(connection_file=os.path.join(
                     self.connection_dir, "kernel-%s.json" % kernel_id),
                     config=self.config,
         )
         km.start_kernel(**kwargs)
         # start just the shell channel, needed for graceful restart
         km.start_channels(shell=True, iopub=False, stdin=False, hb=False)
         self._kernels[kernel_id] = km
         return kernel_id
 
     def shutdown_kernel(self, kernel_id, now=False):
         """Shutdown a kernel by its kernel uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to shutdown.
         now : bool
             Should the kernel be shutdown forcibly using a signal.
         """
         k = self.get_kernel(kernel_id)
         k.shutdown_kernel(now=now)
         k.shell_channel.stop()
         del self._kernels[kernel_id]
 
     def shutdown_all(self, now=False):
         """Shutdown all kernels."""
         for kid in self.list_kernel_ids():
             self.shutdown_kernel(kid, now=now)
 
     def interrupt_kernel(self, kernel_id):
         """Interrupt (SIGINT) the kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         return self.get_kernel(kernel_id).interrupt_kernel()
 
     def signal_kernel(self, kernel_id, signum):
         """Sends a signal to the kernel by its uuid.
 
         Note that since only SIGTERM is supported on Windows, this function
         is only useful on Unix systems.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to signal.
         """
         return self.get_kernel(kernel_id).signal_kernel(signum)
 
     def restart_kernel(self, kernel_id):
         """Restart a kernel by its uuid, keeping the same ports.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         return self.get_kernel(kernel_id).restart_kernel()
 
     def get_kernel(self, kernel_id):
         """Get the single KernelManager object for a kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
         """
         km = self._kernels.get(kernel_id)
         if km is not None:
             return km
         else:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     def get_connection_info(self, kernel_id):
         """Return a dictionary of connection data for a kernel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         connection_dict : dict
             A dict of the information needed to connect to a kernel.
             This includes the ip address and the integer port
             numbers of the different channels (stdin_port, iopub_port,
             shell_port, hb_port).
         """
         km = self.get_kernel(kernel_id)
         return dict(transport=km.transport,
                     ip=km.ip,
                     shell_port=km.shell_port,
                     iopub_port=km.iopub_port,
                     stdin_port=km.stdin_port,
                     hb_port=km.hb_port,
         )  
 
     def _make_url(self, transport, ip, port):
         """Make a ZeroMQ URL for a given transport, ip and port."""
         if transport == 'tcp':
             return "tcp://%s:%i" % (ip, port)
         else:
             return "%s://%s-%s" % (transport, ip, port)
 
     def _create_connected_stream(self, kernel_id, socket_type, channel):
         """Create a connected ZMQStream for a kernel."""
         cinfo = self.get_connection_info(kernel_id)
         url = self._make_url(cinfo['transport'], cinfo['ip'],
                 cinfo['%s_port' % channel]
         )
         sock = self.context.socket(socket_type)
         self.log.info("Connecting to: %s" % url)
         sock.connect(url)
         return ZMQStream(sock)
 
     def create_iopub_stream(self, kernel_id):
         """Return a ZMQStream object connected to the iopub channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         stream : ZMQStream
         """
         iopub_stream = self._create_connected_stream(kernel_id, zmq.SUB, 'iopub')
         iopub_stream.socket.setsockopt(zmq.SUBSCRIBE, b'')
         return iopub_stream
 
     def create_shell_stream(self, kernel_id):
         """Return a ZMQStream object connected to the shell channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         stream : ZMQStream
         """
         shell_stream = self._create_connected_stream(kernel_id, zmq.DEALER, 'shell')
         return shell_stream
 
     def create_hb_stream(self, kernel_id):
         """Return a ZMQStream object connected to the hb channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
 
         Returns
         =======
         stream : ZMQStream
         """
         hb_stream = self._create_connected_stream(kernel_id, zmq.REQ, 'hb')
         return hb_stream
 
 
 class MappingKernelManager(MultiKernelManager):
     """A KernelManager that handles notebok mapping and HTTP error handling"""
 
     kernel_argv = List(Unicode)
     
     time_to_dead = Float(3.0, config=True, help="""Kernel heartbeat interval in seconds.""")
     first_beat = Float(5.0, config=True, help="Delay (in seconds) before sending first heartbeat.")
     
     max_msg_size = Integer(65536, config=True, help="""
         The max raw message size accepted from the browser
         over a WebSocket connection.
     """)
 
     _notebook_mapping = Dict()
 
     #-------------------------------------------------------------------------
     # Methods for managing kernels and sessions
     #-------------------------------------------------------------------------
 
     def kernel_for_notebook(self, notebook_id):
         """Return the kernel_id for a notebook_id or None."""
         return self._notebook_mapping.get(notebook_id)
 
     def set_kernel_for_notebook(self, notebook_id, kernel_id):
         """Associate a notebook with a kernel."""
         if notebook_id is not None:
             self._notebook_mapping[notebook_id] = kernel_id
 
     def notebook_for_kernel(self, kernel_id):
         """Return the notebook_id for a kernel_id or None."""
         notebook_ids = [k for k, v in self._notebook_mapping.iteritems() if v == kernel_id]
         if len(notebook_ids) == 1:
             return notebook_ids[0]
         else:
             return None
 
     def delete_mapping_for_kernel(self, kernel_id):
         """Remove the kernel/notebook mapping for kernel_id."""
         notebook_id = self.notebook_for_kernel(kernel_id)
         if notebook_id is not None:
             del self._notebook_mapping[notebook_id]
 
     def start_kernel(self, notebook_id=None, **kwargs):
         """Start a kernel for a notebok an return its kernel_id.
 
         Parameters
         ----------
         notebook_id : uuid
             The uuid of the notebook to associate the new kernel with. If this
             is not None, this kernel will be persistent whenever the notebook
             requests a kernel.
         """
         kernel_id = self.kernel_for_notebook(notebook_id)
         if kernel_id is None:
             kwargs['extra_arguments'] = self.kernel_argv
             kernel_id = super(MappingKernelManager, self).start_kernel(**kwargs)
             self.set_kernel_for_notebook(notebook_id, kernel_id)
             self.log.info("Kernel started: %s" % kernel_id)
             self.log.debug("Kernel args: %r" % kwargs)
         else:
             self.log.info("Using existing kernel: %s" % kernel_id)
         return kernel_id
 
     def shutdown_kernel(self, kernel_id, now=False):
         """Shutdown a kernel and remove its notebook association."""
         self._check_kernel_id(kernel_id)
         super(MappingKernelManager, self).shutdown_kernel(
             kernel_id, now=now
         )
         self.delete_mapping_for_kernel(kernel_id)
         self.log.info("Kernel shutdown: %s" % kernel_id)
 
     def interrupt_kernel(self, kernel_id):
         """Interrupt a kernel."""
         self._check_kernel_id(kernel_id)
         super(MappingKernelManager, self).interrupt_kernel(kernel_id)
         self.log.info("Kernel interrupted: %s" % kernel_id)
 
     def restart_kernel(self, kernel_id):
         """Restart a kernel while keeping clients connected."""
         self._check_kernel_id(kernel_id)
         super(MappingKernelManager, self).restart_kernel(kernel_id)
         self.log.info("Kernel restarted: %s" % kernel_id)
 
     def create_iopub_stream(self, kernel_id):
         """Create a new iopub stream."""
         self._check_kernel_id(kernel_id)
         return super(MappingKernelManager, self).create_iopub_stream(kernel_id)
 
     def create_shell_stream(self, kernel_id):
         """Create a new shell stream."""
         self._check_kernel_id(kernel_id)
         return super(MappingKernelManager, self).create_shell_stream(kernel_id)
 
     def create_hb_stream(self, kernel_id):
         """Create a new hb stream."""
         self._check_kernel_id(kernel_id)
         return super(MappingKernelManager, self).create_hb_stream(kernel_id)
 
     def _check_kernel_id(self, kernel_id):
         """Check a that a kernel_id exists and raise 404 if not."""
         if kernel_id not in self:
             raise web.HTTPError(404, u'Kernel does not exist: %s' % kernel_id)
 

IPython/frontend/html/notebook/tests/test_kernelmanager.py

@@ -1,80 +1,80 b''
 """Tests for the notebook kernel and session manager."""
 
 from subprocess import PIPE
 import time
 from unittest import TestCase
 
 from IPython.testing import decorators as dec
 
 from IPython.config.loader import Config
 from IPython.frontend.html.notebook.kernelmanager import MultiKernelManager
 from IPython.utils.localinterfaces import LOCALHOST
-from IPython.zmq.kernelmanager import KernelManager
+from IPython.kernel.kernelmanager import KernelManager
 
 class TestKernelManager(TestCase):
 
     def _get_tcp_km(self):
         return MultiKernelManager()
 
     def _get_ipc_km(self):
         c = Config()
         c.KernelManager.transport = 'ipc'
         c.KernelManager.ip = 'test'
         km = MultiKernelManager(config=c)
         return km
 
     def _run_lifecycle(self, km):
         kid = km.start_kernel(stdout=PIPE, stderr=PIPE)
         self.assertTrue(kid in km)
         self.assertTrue(kid in km.list_kernel_ids())
         self.assertEqual(len(km),1)
         km.restart_kernel(kid)
         self.assertTrue(kid in km.list_kernel_ids())
         # We need a delay here to give the restarting kernel a chance to
         # restart. Otherwise, the interrupt will kill it, causing the test
         # suite to hang. The reason it *hangs* is that the shutdown
         # message for the restart sometimes hasn't been sent to the kernel.
         # Because linger is oo on the shell channel, the context can't
         # close until the message is sent to the kernel, which is not dead.
         time.sleep(1.0)
         km.interrupt_kernel(kid)
         k = km.get_kernel(kid)
         self.assertTrue(isinstance(k, KernelManager))
         km.shutdown_kernel(kid)
         self.assertTrue(not kid in km)
 
     def _run_cinfo(self, km, transport, ip):
         kid = km.start_kernel(stdout=PIPE, stderr=PIPE)
         k = km.get_kernel(kid)
         cinfo = km.get_connection_info(kid)
         self.assertEqual(transport, cinfo['transport'])
         self.assertEqual(ip, cinfo['ip'])
         self.assertTrue('stdin_port' in cinfo)
         self.assertTrue('iopub_port' in cinfo)
         stream = km.create_iopub_stream(kid)
         stream.close()
         self.assertTrue('shell_port' in cinfo)
         stream = km.create_shell_stream(kid)
         stream.close()
         self.assertTrue('hb_port' in cinfo)
         stream = km.create_hb_stream(kid)
         stream.close()
         km.shutdown_kernel(kid)
 
     def test_tcp_lifecycle(self):
         km = self._get_tcp_km()
         self._run_lifecycle(km)
     
     @dec.skip_win32
     def test_tcp_cinfo(self):
         km = self._get_tcp_km()
         self._run_cinfo(km, 'tcp', LOCALHOST)
 
     def test_ipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)
     
     def test_ipc_cinfo(self):
         km = self._get_ipc_km()
         self._run_cinfo(km, 'ipc', 'test')
 

IPython/frontend/qt/kernelmanager.py

@@ -1,32 +1,32 b''
 """ Defines a KernelManager that provides signals and slots.
 """
 
 # Local imports.
 from IPython.utils.traitlets import Type
-from IPython.zmq.kernelmanager import ShellChannel, IOPubChannel, \
+from IPython.kernel.kernelmanager import ShellChannel, IOPubChannel, \
     StdInChannel, HBChannel, KernelManager
 from base_kernelmanager import QtShellChannelMixin, QtIOPubChannelMixin, \
     QtStdInChannelMixin, QtHBChannelMixin, QtKernelManagerMixin
 
 
 class QtShellChannel(QtShellChannelMixin, ShellChannel):
     pass
 
 class QtIOPubChannel(QtIOPubChannelMixin, IOPubChannel):
     pass
 
 class QtStdInChannel(QtStdInChannelMixin, StdInChannel):
     pass
 
 class QtHBChannel(QtHBChannelMixin, HBChannel):
     pass
 
 
 class QtKernelManager(QtKernelManagerMixin, KernelManager):
     """ A KernelManager that provides signals and slots.
     """
 
     iopub_channel_class = Type(QtIOPubChannel)
     shell_channel_class = Type(QtShellChannel)
     stdin_channel_class = Type(QtStdInChannel)
     hb_channel_class = Type(QtHBChannel)

IPython/frontend/terminal/console/tests/test_image_handler.py

@@ -1,95 +1,95 b''
 #-----------------------------------------------------------------------------
 # Copyright (C) 2012 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.
 #-----------------------------------------------------------------------------
 
 import os
 import sys
 import unittest
 import base64
 
-from IPython.zmq.kernelmanager import KernelManager
+from IPython.kernel.kernelmanager import KernelManager
 from IPython.frontend.terminal.console.interactiveshell \
     import ZMQTerminalInteractiveShell
 from IPython.utils.tempdir import TemporaryDirectory
 from IPython.testing.tools import monkeypatch
 from IPython.testing.decorators import skip_without
 from IPython.utils.ipstruct import Struct
 
 
 SCRIPT_PATH = os.path.join(
     os.path.abspath(os.path.dirname(__file__)), 'writetofile.py')
 
 
 class ZMQTerminalInteractiveShellTestCase(unittest.TestCase):
 
     def setUp(self):
         km = KernelManager()
         self.shell = ZMQTerminalInteractiveShell(kernel_manager=km)
         self.raw = b'dummy data'
         self.mime = 'image/png'
         self.data = {self.mime: base64.encodestring(self.raw).decode('ascii')}
 
     def test_no_call_by_default(self):
         def raise_if_called(*args, **kwds):
             assert False
 
         shell = self.shell
         shell.handle_image_PIL = raise_if_called
         shell.handle_image_stream = raise_if_called
         shell.handle_image_tempfile = raise_if_called
         shell.handle_image_callable = raise_if_called
 
         shell.handle_image(None, None)  # arguments are dummy
 
     @skip_without('PIL')
     def test_handle_image_PIL(self):
         import PIL.Image
 
         open_called_with = []
         show_called_with = []
 
         def fake_open(arg):
             open_called_with.append(arg)
             return Struct(show=lambda: show_called_with.append(None))
 
         with monkeypatch(PIL.Image, 'open', fake_open):
             self.shell.handle_image_PIL(self.data, self.mime)
 
         self.assertEqual(len(open_called_with), 1)
         self.assertEqual(len(show_called_with), 1)
         self.assertEqual(open_called_with[0].getvalue(), self.raw)
 
     def check_handler_with_file(self, inpath, handler):
         shell = self.shell
         configname = '{0}_image_handler'.format(handler)
         funcname = 'handle_image_{0}'.format(handler)
 
         assert hasattr(shell, configname)
         assert hasattr(shell, funcname)
 
         with TemporaryDirectory() as tmpdir:
             outpath = os.path.join(tmpdir, 'data')
             cmd = [sys.executable, SCRIPT_PATH, inpath, outpath]
             setattr(shell, configname, cmd)
             getattr(shell, funcname)(self.data, self.mime)
             # cmd is called and file is closed.  So it's safe to open now.
             with open(outpath, 'rb') as file:
                 transferred = file.read()
 
         self.assertEqual(transferred, self.raw)
 
     def test_handle_image_stream(self):
         self.check_handler_with_file('-', 'stream')
 
     def test_handle_image_tempfile(self):
         self.check_handler_with_file('{file}', 'tempfile')
 
     def test_handle_image_callable(self):
         called_with = []
         self.shell.callable_image_handler = called_with.append
         self.shell.handle_image_callable(self.data, self.mime)
         self.assertEqual(len(called_with), 1)
         assert called_with[0] is self.data

IPython/inprocess/blockingkernelmanager.py

@@ -1,54 +1,54 b''
 """ Implements a fully blocking kernel manager.
 
 Useful for test suites and blocking terminal interfaces.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2012  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Local imports.
 from IPython.utils.io import raw_print
 from IPython.utils.traitlets import Type
 from kernelmanager import InProcessKernelManager, InProcessShellChannel, \
     InProcessIOPubChannel, InProcessStdInChannel
-from IPython.zmq.blockingkernelmanager import BlockingChannelMixin
+from IPython.kernel.blockingkernelmanager import BlockingChannelMixin
 
 
 #-----------------------------------------------------------------------------
 # Blocking kernel manager
 #-----------------------------------------------------------------------------
 
 class BlockingInProcessShellChannel(BlockingChannelMixin, InProcessShellChannel):
     pass
 
 class BlockingInProcessIOPubChannel(BlockingChannelMixin, InProcessIOPubChannel):
     pass
 
 class BlockingInProcessStdInChannel(BlockingChannelMixin, InProcessStdInChannel):
     
     def call_handlers(self, msg):
         """ Overridden for the in-process channel.
 
         This methods simply calls raw_input directly.
         """
         msg_type = msg['header']['msg_type']
         if msg_type == 'input_request':
             _raw_input = self.manager.kernel._sys_raw_input
             prompt = msg['content']['prompt']
             raw_print(prompt, end='')
             self.input(_raw_input())
 
 class BlockingInProcessKernelManager(InProcessKernelManager):
 
     # The classes to use for the various channels.
     shell_channel_class = Type(BlockingInProcessShellChannel)
     iopub_channel_class = Type(BlockingInProcessIOPubChannel)
     stdin_channel_class = Type(BlockingInProcessStdInChannel)

IPython/inprocess/kernelmanager.py

@@ -1,313 +1,313 b''
 """ A kernel manager for in-process kernels. """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2012  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
 #-----------------------------------------------------------------------------
 
 # Local imports.
 from IPython.config.configurable import Configurable
 from IPython.inprocess.socket import DummySocket
 from IPython.utils.traitlets import Any, Instance, Type
 from IPython.kernel import (
     ShellChannelABC, IOPubChannelABC,
     HBChannelABC, StdInChannelABC,
     KernelManagerABC
 )
 
 #-----------------------------------------------------------------------------
 # Channel classes
 #-----------------------------------------------------------------------------
 
 class InProcessChannel(object):
     """Base class for in-process channels."""
 
     def __init__(self, manager):
         super(InProcessChannel, self).__init__()
         self.manager = manager
         self._is_alive = False
 
     #--------------------------------------------------------------------------
     # Channel interface
     #--------------------------------------------------------------------------
 
     def is_alive(self):
         return self._is_alive
 
     def start(self):
         self._is_alive = True
 
     def stop(self):
         self._is_alive = False
 
     def call_handlers(self, msg):
         """ This method is called in the main thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     #--------------------------------------------------------------------------
     # InProcessChannel interface
     #--------------------------------------------------------------------------
 
     def call_handlers_later(self, *args, **kwds):
         """ Call the message handlers later.
 
         The default implementation just calls the handlers immediately, but this
         method exists so that GUI toolkits can defer calling the handlers until
         after the event loop has run, as expected by GUI frontends.
         """
         self.call_handlers(*args, **kwds)
 
     def process_events(self):
         """ Process any pending GUI events.
 
         This method will be never be called from a frontend without an event
         loop (e.g., a terminal frontend).
         """
         raise NotImplementedError
 
 
 class InProcessShellChannel(InProcessChannel):
-    """See `IPython.zmq.kernelmanager.ShellChannel` for docstrings."""
+    """See `IPython.kernel.kernelmanager.ShellChannel` for docstrings."""
 
     # flag for whether execute requests should be allowed to call raw_input
     allow_stdin = True
 
     #--------------------------------------------------------------------------
     # ShellChannel interface
     #--------------------------------------------------------------------------
 
     def execute(self, code, silent=False, store_history=True,
                 user_variables=[], user_expressions={}, allow_stdin=None):
         if allow_stdin is None:
             allow_stdin = self.allow_stdin
         content = dict(code=code, silent=silent, store_history=store_history,
                        user_variables=user_variables,
                        user_expressions=user_expressions,
                        allow_stdin=allow_stdin)
         msg = self.manager.session.msg('execute_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def complete(self, text, line, cursor_pos, block=None):
         content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)
         msg = self.manager.session.msg('complete_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def object_info(self, oname, detail_level=0):
         content = dict(oname=oname, detail_level=detail_level)
         msg = self.manager.session.msg('object_info_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def history(self, raw=True, output=False, hist_access_type='range', **kwds):
         content = dict(raw=raw, output=output,
                        hist_access_type=hist_access_type, **kwds)
         msg = self.manager.session.msg('history_request', content)
         self._dispatch_to_kernel(msg)
         return msg['header']['msg_id']
 
     def shutdown(self, restart=False):
         # FIXME: What to do here?
         raise NotImplementedError('Cannot shutdown in-process kernel')
 
     #--------------------------------------------------------------------------
     # Protected interface
     #--------------------------------------------------------------------------
 
     def _dispatch_to_kernel(self, msg):
         """ Send a message to the kernel and handle a reply.
         """
         kernel = self.manager.kernel
         if kernel is None:
             raise RuntimeError('Cannot send request. No kernel exists.')
 
         stream = DummySocket()
         self.manager.session.send(stream, msg)
         msg_parts = stream.recv_multipart()
         kernel.dispatch_shell(stream, msg_parts)
 
         idents, reply_msg = self.manager.session.recv(stream, copy=False)
         self.call_handlers_later(reply_msg)
 
 
 class InProcessIOPubChannel(InProcessChannel):
-    """See `IPython.zmq.kernelmanager.IOPubChannel` for docstrings."""
+    """See `IPython.kernel.kernelmanager.IOPubChannel` for docstrings."""
 
     def flush(self, timeout=1.0):
         pass
 
 
 class InProcessStdInChannel(InProcessChannel):
-    """See `IPython.zmq.kernelmanager.StdInChannel` for docstrings."""
+    """See `IPython.kernel.kernelmanager.StdInChannel` for docstrings."""
 
     def input(self, string):
         kernel = self.manager.kernel
         if kernel is None:
             raise RuntimeError('Cannot send input reply. No kernel exists.')
         kernel.raw_input_str = string
 
 
 class InProcessHBChannel(InProcessChannel):
-    """See `IPython.zmq.kernelmanager.HBChannel` for docstrings."""
+    """See `IPython.kernel.kernelmanager.HBChannel` for docstrings."""
 
     time_to_dead = 3.0
 
     def __init__(self, *args, **kwds):
         super(InProcessHBChannel, self).__init__(*args, **kwds)
         self._pause = True
 
     def pause(self):
         self._pause = True
 
     def unpause(self):
         self._pause = False
 
     def is_beating(self):
         return not self._pause
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 class InProcessKernelManager(Configurable):
     """A manager for an in-process kernel.
 
     This class implements the interface of
     `IPython.kernel.kernelmanagerabc.KernelManagerABC` and allows
     (asynchronous) frontends to be used seamlessly with an in-process kernel.
     
-    See `IPython.zmq.kernelmanager.KernelManager` for docstrings.
+    See `IPython.kernel.kernelmanager.KernelManager` for docstrings.
     """
 
     # The Session to use for building messages.
     session = Instance('IPython.zmq.session.Session')
     def _session_default(self):
         from IPython.zmq.session import Session
         return Session(config=self.config)
 
     # The kernel process with which the KernelManager is communicating.
     kernel = Instance('IPython.inprocess.ipkernel.InProcessKernel')
 
     # The classes to use for the various channels.
     shell_channel_class = Type(InProcessShellChannel)
     iopub_channel_class = Type(InProcessIOPubChannel)
     stdin_channel_class = Type(InProcessStdInChannel)
     hb_channel_class = Type(InProcessHBChannel)
 
     # Protected traits.
     _shell_channel = Any
     _iopub_channel = Any
     _stdin_channel = Any
     _hb_channel = Any
 
     #--------------------------------------------------------------------------
     # Channel management methods.
     #--------------------------------------------------------------------------
 
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         if shell:
             self.shell_channel.start()
         if iopub:
             self.iopub_channel.start()
         if stdin:
             self.stdin_channel.start()
             self.shell_channel.allow_stdin = True
         else:
             self.shell_channel.allow_stdin = False
         if hb:
             self.hb_channel.start()
 
     def stop_channels(self):
         if self.shell_channel.is_alive():
             self.shell_channel.stop()
         if self.iopub_channel.is_alive():
             self.iopub_channel.stop()
         if self.stdin_channel.is_alive():
             self.stdin_channel.stop()
         if self.hb_channel.is_alive():
             self.hb_channel.stop()
 
     @property
     def channels_running(self):
         return (self.shell_channel.is_alive() or self.iopub_channel.is_alive() or
                 self.stdin_channel.is_alive() or self.hb_channel.is_alive())
 
     @property
     def shell_channel(self):
         if self._shell_channel is None:
             self._shell_channel = self.shell_channel_class(self)
         return self._shell_channel
 
     @property
     def iopub_channel(self):
         if self._iopub_channel is None:
             self._iopub_channel = self.iopub_channel_class(self)
         return self._iopub_channel
 
     @property
     def stdin_channel(self):
         if self._stdin_channel is None:
             self._stdin_channel = self.stdin_channel_class(self)
         return self._stdin_channel
 
     @property
     def hb_channel(self):
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(self)
         return self._hb_channel
 
     #--------------------------------------------------------------------------
     # Kernel management methods:
     #--------------------------------------------------------------------------
     
     def start_kernel(self, **kwds):
         from IPython.inprocess.ipkernel import InProcessKernel
         self.kernel = InProcessKernel()
         self.kernel.frontends.append(self)
 
     def shutdown_kernel(self):
         self._kill_kernel()
 
     def restart_kernel(self, now=False, **kwds):
         self.shutdown_kernel()
         self.start_kernel(**kwds)
 
     @property
     def has_kernel(self):
         return self.kernel is not None
 
     def _kill_kernel(self):
         self.kernel.frontends.remove(self)
         self.kernel = None
 
     def interrupt_kernel(self):
         raise NotImplementedError("Cannot interrupt in-process kernel.")
 
     def signal_kernel(self, signum):
         raise NotImplementedError("Cannot signal in-process kernel.")
 
     @property
     def is_alive(self):
         return True
 
 
 #-----------------------------------------------------------------------------
 # ABC Registration
 #-----------------------------------------------------------------------------
 
 ShellChannelABC.register(InProcessShellChannel)
 IOPubChannelABC.register(InProcessIOPubChannel)
 HBChannelABC.register(InProcessHBChannel)
 StdInChannelABC.register(InProcessStdInChannel)
 KernelManagerABC.register(InProcessKernelManager)

IPython/kernel/kernelmanager.py

@@ -1,1129 +1,1129 b''
 """Base classes to manage the interaction with a running kernel.
 
 TODO
 * Create logger to handle debugging and console messages.
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2011  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
-# Standard library imports.
+# Standard library imports
 import atexit
 import errno
 import json
 from subprocess import Popen
 import os
 import signal
 import sys
 from threading import Thread
 import time
 
-# System library imports.
+# System library imports
 import zmq
 # import ZMQError in top-level namespace, to avoid ugly attribute-error messages
 # during garbage collection of threads at exit:
 from zmq import ZMQError
 from zmq.eventloop import ioloop, zmqstream
 
-# Local imports.
+# Local imports
 from IPython.config.configurable import Configurable
 from IPython.utils.localinterfaces import LOCALHOST, LOCAL_IPS
 from IPython.utils.traitlets import (
     Any, Instance, Type, Unicode, List, Integer, Bool, CaselessStrEnum
 )
 from IPython.utils.py3compat import str_to_bytes
 from IPython.kernel import (
     write_connection_file,
     make_ipkernel_cmd,
     launch_kernel,
 )
-from session import Session
+from IPython.zmq.session import Session
 from IPython.kernel import (
     ShellChannelABC, IOPubChannelABC,
     HBChannelABC, StdInChannelABC,
     KernelManagerABC
 )
 
 
 #-----------------------------------------------------------------------------
 # Constants and exceptions
 #-----------------------------------------------------------------------------
 
 class InvalidPortNumber(Exception):
     pass
 
 #-----------------------------------------------------------------------------
 # Utility functions
 #-----------------------------------------------------------------------------
 
 # some utilities to validate message structure, these might get moved elsewhere
 # if they prove to have more generic utility
 
 def validate_string_list(lst):
     """Validate that the input is a list of strings.
 
     Raises ValueError if not."""
     if not isinstance(lst, list):
         raise ValueError('input %r must be a list' % lst)
     for x in lst:
         if not isinstance(x, basestring):
             raise ValueError('element %r in list must be a string' % x)
 
 
 def validate_string_dict(dct):
     """Validate that the input is a dict with string keys and values.
 
     Raises ValueError if not."""
     for k,v in dct.iteritems():
         if not isinstance(k, basestring):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, basestring):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 #-----------------------------------------------------------------------------
 # ZMQ Socket Channel classes
 #-----------------------------------------------------------------------------
 
 class ZMQSocketChannel(Thread):
     """The base class for the channels that use ZMQ sockets."""
     context = None
     session = None
     socket = None
     ioloop = None
     stream = None
     _address = None
     _exiting = False
 
     def __init__(self, context, session, address):
         """Create a channel.
 
         Parameters
         ----------
         context : :class:`zmq.Context`
             The ZMQ context to use.
         session : :class:`session.Session`
             The session to use.
         address : zmq url
             Standard (ip, port) tuple that the kernel is listening on.
         """
         super(ZMQSocketChannel, self).__init__()
         self.daemon = True
 
         self.context = context
         self.session = session
         if isinstance(address, tuple):
             if address[1] == 0:
                 message = 'The port number for a channel cannot be 0.'
                 raise InvalidPortNumber(message)
             address = "tcp://%s:%i" % address
         self._address = address
         atexit.register(self._notice_exit)
     
     def _notice_exit(self):
         self._exiting = True
 
     def _run_loop(self):
         """Run my loop, ignoring EINTR events in the poller"""
         while True:
             try:
                 self.ioloop.start()
             except ZMQError as e:
                 if e.errno == errno.EINTR:
                     continue
                 else:
                     raise
             except Exception:
                 if self._exiting:
                     break
                 else:
                     raise
             else:
                 break
 
     def stop(self):
         """Stop the channel's event loop and join its thread.
 
         This calls :method:`Thread.join` and returns when the thread
         terminates. :class:`RuntimeError` will be raised if
         :method:`self.start` is called again.
         """
         self.join()
 
     @property
     def address(self):
         """Get the channel's address as a zmq url string.
 
         These URLS have the form: 'tcp://127.0.0.1:5555'.
         """
         return self._address
 
     def _queue_send(self, msg):
         """Queue a message to be sent from the IOLoop's thread.
         
         Parameters
         ----------
         msg : message to send
         
         This is threadsafe, as it uses IOLoop.add_callback to give the loop's
         thread control of the action.
         """
         def thread_send():
             self.session.send(self.stream, msg)
         self.ioloop.add_callback(thread_send)
 
     def _handle_recv(self, msg):
         """Callback for stream.on_recv.
 
         Unpacks message, and calls handlers with it.
         """
         ident,smsg = self.session.feed_identities(msg)
         self.call_handlers(self.session.unserialize(smsg))
     
 
 
 class ShellChannel(ZMQSocketChannel):
     """The shell channel for issuing request/replies to the kernel."""
 
     command_queue = None
     # flag for whether execute requests should be allowed to call raw_input:
     allow_stdin = True
 
     def __init__(self, context, session, address):
         super(ShellChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.DEALER)
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
         self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
         try:
             self.socket.close()
         except:
             pass
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self.ioloop.stop()
         super(ShellChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def execute(self, code, silent=False, store_history=True,
                 user_variables=None, user_expressions=None, allow_stdin=None):
         """Execute code in the kernel.
 
         Parameters
         ----------
         code : str
             A string of Python code.
 
         silent : bool, optional (default False)
             If set, the kernel will execute the code as quietly possible, and
             will force store_history to be False.
 
         store_history : bool, optional (default True)
             If set, the kernel will store command history.  This is forced
             to be False if silent is True.
 
         user_variables : list, optional
             A list of variable names to pull from the user's namespace.  They
             will come back as a dict with these names as keys and their
             :func:`repr` as values.
 
         user_expressions : dict, optional
             A dict mapping names to expressions to be evaluated in the user's
             dict. The expression values are returned as strings formatted using
             :func:`repr`.
 
         allow_stdin : bool, optional (default self.allow_stdin)
             Flag for whether the kernel can send stdin requests to frontends.
 
             Some frontends (e.g. the Notebook) do not support stdin requests. 
             If raw_input is called from code executed from such a frontend, a
             StdinNotImplementedError will be raised.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         if user_variables is None:
             user_variables = []
         if user_expressions is None:
             user_expressions = {}
         if allow_stdin is None:
             allow_stdin = self.allow_stdin
         
         
         # Don't waste network traffic if inputs are invalid
         if not isinstance(code, basestring):
             raise ValueError('code %r must be a string' % code)
         validate_string_list(user_variables)
         validate_string_dict(user_expressions)
 
         # Create class for content/msg creation. Related to, but possibly
         # not in Session.
         content = dict(code=code, silent=silent, store_history=store_history,
                        user_variables=user_variables,
                        user_expressions=user_expressions,
                        allow_stdin=allow_stdin,
                        )
         msg = self.session.msg('execute_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def complete(self, text, line, cursor_pos, block=None):
         """Tab complete text in the kernel's namespace.
 
         Parameters
         ----------
         text : str
             The text to complete.
         line : str
             The full line of text that is the surrounding context for the
             text to complete.
         cursor_pos : int
             The position of the cursor in the line where the completion was
             requested.
         block : str, optional
             The full block of code in which the completion is being requested.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(text=text, line=line, block=block, cursor_pos=cursor_pos)
         msg = self.session.msg('complete_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def object_info(self, oname, detail_level=0):
         """Get metadata information about an object in the kernel's namespace.
 
         Parameters
         ----------
         oname : str
             A string specifying the object name.
         detail_level : int, optional
             The level of detail for the introspection (0-2)
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(oname=oname, detail_level=detail_level)
         msg = self.session.msg('object_info_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def history(self, raw=True, output=False, hist_access_type='range', **kwargs):
         """Get entries from the kernel's history list.
 
         Parameters
         ----------
         raw : bool
             If True, return the raw input.
         output : bool
             If True, then return the output as well.
         hist_access_type : str
             'range' (fill in session, start and stop params), 'tail' (fill in n)
              or 'search' (fill in pattern param).
 
         session : int
             For a range request, the session from which to get lines. Session
             numbers are positive integers; negative ones count back from the
             current session.
         start : int
             The first line number of a history range.
         stop : int
             The final (excluded) line number of a history range.
 
         n : int
             The number of lines of history to get for a tail request.
 
         pattern : str
             The glob-syntax pattern for a search request.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         content = dict(raw=raw, output=output, hist_access_type=hist_access_type,
                                                                     **kwargs)
         msg = self.session.msg('history_request', content)
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def kernel_info(self):
         """Request kernel info."""
         msg = self.session.msg('kernel_info_request')
         self._queue_send(msg)
         return msg['header']['msg_id']
 
     def shutdown(self, restart=False):
         """Request an immediate kernel shutdown.
 
         Upon receipt of the (empty) reply, client code can safely assume that
         the kernel has shut down and it's safe to forcefully terminate it if
         it's still alive.
 
         The kernel will send the reply via a function registered with Python's
         atexit module, ensuring it's truly done as the kernel is done with all
         normal operation.
         """
         # Send quit message to kernel. Once we implement kernel-side setattr,
         # this should probably be done that way, but for now this will do.
         msg = self.session.msg('shutdown_request', {'restart':restart})
         self._queue_send(msg)
         return msg['header']['msg_id']
 
 
 
 class IOPubChannel(ZMQSocketChannel):
     """The iopub channel which listens for messages that the kernel publishes.
 
     This channel is where all output is published to frontends.
     """
 
     def __init__(self, context, session, address):
         super(IOPubChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.SUB)
         self.socket.setsockopt(zmq.SUBSCRIBE,b'')
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
         self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
         try:
             self.socket.close()
         except:
             pass
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self.ioloop.stop()
         super(IOPubChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def flush(self, timeout=1.0):
         """Immediately processes all pending messages on the iopub channel.
 
         Callers should use this method to ensure that :method:`call_handlers`
         has been called for all messages that have been received on the
         0MQ SUB socket of this channel.
 
         This method is thread safe.
 
         Parameters
         ----------
         timeout : float, optional
             The maximum amount of time to spend flushing, in seconds. The
             default is one second.
         """
         # We do the IOLoop callback process twice to ensure that the IOLoop
         # gets to perform at least one full poll.
         stop_time = time.time() + timeout
         for i in xrange(2):
             self._flushed = False
             self.ioloop.add_callback(self._flush)
             while not self._flushed and time.time() < stop_time:
                 time.sleep(0.01)
 
     def _flush(self):
         """Callback for :method:`self.flush`."""
         self.stream.flush()
         self._flushed = True
 
 
 class StdInChannel(ZMQSocketChannel):
     """The stdin channel to handle raw_input requests that the kernel makes."""
 
     msg_queue = None
 
     def __init__(self, context, session, address):
         super(StdInChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self.socket = self.context.socket(zmq.DEALER)
         self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
         self.socket.connect(self.address)
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
         self._run_loop()
         try:
             self.socket.close()
         except:
             pass
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self.ioloop.stop()
         super(StdInChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application leve
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def input(self, string):
         """Send a string of raw input to the kernel."""
         content = dict(value=string)
         msg = self.session.msg('input_reply', content)
         self._queue_send(msg)
 
 
 class HBChannel(ZMQSocketChannel):
     """The heartbeat channel which monitors the kernel heartbeat.
 
     Note that the heartbeat channel is paused by default. As long as you start
     this channel, the kernel manager will ensure that it is paused and un-paused
     as appropriate.
     """
 
     time_to_dead = 3.0
     socket = None
     poller = None
     _running = None
     _pause = None
     _beating = None
 
     def __init__(self, context, session, address):
         super(HBChannel, self).__init__(context, session, address)
         self._running = False
         self._pause =True
         self.poller = zmq.Poller()
 
     def _create_socket(self):
         if self.socket is not None:
             # close previous socket, before opening a new one
             self.poller.unregister(self.socket)
             self.socket.close()
         self.socket = self.context.socket(zmq.REQ)
         self.socket.setsockopt(zmq.LINGER, 0)
         self.socket.connect(self.address)
         
         self.poller.register(self.socket, zmq.POLLIN)
     
     def _poll(self, start_time):
         """poll for heartbeat replies until we reach self.time_to_dead.
         
         Ignores interrupts, and returns the result of poll(), which
         will be an empty list if no messages arrived before the timeout,
         or the event tuple if there is a message to receive.
         """
         
         until_dead = self.time_to_dead - (time.time() - start_time)
         # ensure poll at least once
         until_dead = max(until_dead, 1e-3)
         events = []
         while True:
             try:
                 events = self.poller.poll(1000 * until_dead)
             except ZMQError as e:
                 if e.errno == errno.EINTR:
                     # ignore interrupts during heartbeat
                     # this may never actually happen
                     until_dead = self.time_to_dead - (time.time() - start_time)
                     until_dead = max(until_dead, 1e-3)
                     pass
                 else:
                     raise
             except Exception:
                 if self._exiting:
                     break
                 else:
                     raise
             else:
                 break
         return events
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self._create_socket()
         self._running = True
         self._beating = True
         
         while self._running:
             if self._pause:
                 # just sleep, and skip the rest of the loop
                 time.sleep(self.time_to_dead)
                 continue
             
             since_last_heartbeat = 0.0
             # io.rprint('Ping from HB channel') # dbg
             # no need to catch EFSM here, because the previous event was
             # either a recv or connect, which cannot be followed by EFSM
             self.socket.send(b'ping')
             request_time = time.time()
             ready = self._poll(request_time)
             if ready:
                 self._beating = True
                 # the poll above guarantees we have something to recv
                 self.socket.recv()
                 # sleep the remainder of the cycle
                 remainder = self.time_to_dead - (time.time() - request_time)
                 if remainder > 0:
                     time.sleep(remainder)
                 continue
             else:
                 # nothing was received within the time limit, signal heart failure
                 self._beating = False
                 since_last_heartbeat = time.time() - request_time
                 self.call_handlers(since_last_heartbeat)
                 # and close/reopen the socket, because the REQ/REP cycle has been broken
                 self._create_socket()
                 continue
         try:
             self.socket.close()
         except:
             pass
 
     def pause(self):
         """Pause the heartbeat."""
         self._pause = True
 
     def unpause(self):
         """Unpause the heartbeat."""
         self._pause = False
 
     def is_beating(self):
         """Is the heartbeat running and responsive (and not paused)."""
         if self.is_alive() and not self._pause and self._beating:
             return True
         else:
             return False
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self._running = False
         super(HBChannel, self).stop()
 
     def call_handlers(self, since_last_heartbeat):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application level
         handlers are called in the application thread.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 class KernelManager(Configurable):
     """Manages a single kernel on this host along with its channels.
 
     There are four channels associated with each kernel:
 
     * shell: for request/reply calls to the kernel.
     * iopub: for the kernel to publish results to frontends.
     * hb: for monitoring the kernel's heartbeat.
     * stdin: for frontends to reply to raw_input calls in the kernel.
 
     The usage of the channels that this class manages is optional. It is
     entirely possible to connect to the kernels directly using ZeroMQ
     sockets. These channels are useful primarily for talking to a kernel
     whose :class:`KernelManager` is in the same process.
 
     This version manages kernels started using Popen.
     """
     # The PyZMQ Context to use for communication with the kernel.
     context = Instance(zmq.Context)
     def _context_default(self):
         return zmq.Context.instance()
 
     # The Session to use for communication with the kernel.
     session = Instance(Session)
     def _session_default(self):
         return Session(config=self.config)
 
     # The kernel process with which the KernelManager is communicating.
     # generally a Popen instance
     kernel = Any() 
     
     kernel_cmd = List(Unicode, config=True,
         help="""The Popen Command to launch the kernel.
         Override this if you have a custom 
         """
     )
     def _kernel_cmd_changed(self, name, old, new):
         print 'kernel cmd changed', new
         self.ipython_kernel = False
 
     ipython_kernel = Bool(True)
     
 
     # The addresses for the communication channels.
     connection_file = Unicode('')
     
     transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
 
     ip = Unicode(LOCALHOST, config=True,
         help="""Set the kernel\'s IP address [default localhost].
         If the IP address is something other than localhost, then
         Consoles on other machines will be able to connect
         to the Kernel, so be careful!"""
     )
     def _ip_default(self):
         if self.transport == 'ipc':
             if self.connection_file:
                 return os.path.splitext(self.connection_file)[0] + '-ipc'
             else:
                 return 'kernel-ipc'
         else:
             return LOCALHOST
     def _ip_changed(self, name, old, new):
         if new == '*':
             self.ip = '0.0.0.0'
     shell_port = Integer(0)
     iopub_port = Integer(0)
     stdin_port = Integer(0)
     hb_port = Integer(0)
 
     # The classes to use for the various channels.
     shell_channel_class = Type(ShellChannel)
     iopub_channel_class = Type(IOPubChannel)
     stdin_channel_class = Type(StdInChannel)
     hb_channel_class = Type(HBChannel)
 
     # Protected traits.
     _launch_args = Any
     _shell_channel = Any
     _iopub_channel = Any
     _stdin_channel = Any
     _hb_channel = Any
     _connection_file_written=Bool(False)
 
     def __del__(self):
         self.cleanup_connection_file()
 
     #--------------------------------------------------------------------------
     # Channel management methods:
     #--------------------------------------------------------------------------
 
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         """Starts the channels for this kernel.
 
         This will create the channels if they do not exist and then start
         them (their activity runs in a thread). If port numbers of 0 are
         being used (random ports) then you must first call 
         :method:`start_kernel`. If the channels have been stopped and you
         call this, :class:`RuntimeError` will be raised.
         """
         if shell:
             self.shell_channel.start()
         if iopub:
             self.iopub_channel.start()
         if stdin:
             self.stdin_channel.start()
             self.shell_channel.allow_stdin = True
         else:
             self.shell_channel.allow_stdin = False
         if hb:
             self.hb_channel.start()
 
     def stop_channels(self):
         """Stops all the running channels for this kernel.
 
         This stops their event loops and joins their threads.
         """
         if self.shell_channel.is_alive():
             self.shell_channel.stop()
         if self.iopub_channel.is_alive():
             self.iopub_channel.stop()
         if self.stdin_channel.is_alive():
             self.stdin_channel.stop()
         if self.hb_channel.is_alive():
             self.hb_channel.stop()
 
     @property
     def channels_running(self):
         """Are any of the channels created and running?"""
         return (self.shell_channel.is_alive() or self.iopub_channel.is_alive() or
                 self.stdin_channel.is_alive() or self.hb_channel.is_alive())
 
     def _make_url(self, port):
         """Make a zmq url with a port.
 
         There are two cases that this handles:
 
         * tcp: tcp://ip:port
         * ipc: ipc://ip-port
         """
         if self.transport == 'tcp':
             return "tcp://%s:%i" % (self.ip, port)
         else:
             return "%s://%s-%s" % (self.transport, self.ip, port)
 
     @property
     def shell_channel(self):
         """Get the shell channel object for this kernel."""
         if self._shell_channel is None:
             self._shell_channel = self.shell_channel_class(
                 self.context, self.session, self._make_url(self.shell_port)
             )
         return self._shell_channel
 
     @property
     def iopub_channel(self):
         """Get the iopub channel object for this kernel."""
         if self._iopub_channel is None:
             self._iopub_channel = self.iopub_channel_class(
                 self.context, self.session, self._make_url(self.iopub_port)
             )
         return self._iopub_channel
 
     @property
     def stdin_channel(self):
         """Get the stdin channel object for this kernel."""
         if self._stdin_channel is None:
             self._stdin_channel = self.stdin_channel_class(
                 self.context, self.session, self._make_url(self.stdin_port)
             )
         return self._stdin_channel
 
     @property
     def hb_channel(self):
         """Get the hb channel object for this kernel."""
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(
                 self.context, self.session, self._make_url(self.hb_port)
             )
         return self._hb_channel
 
     #--------------------------------------------------------------------------
     # Connection and ipc file management
     #--------------------------------------------------------------------------
     
     def cleanup_connection_file(self):
         """Cleanup connection file *if we wrote it*
         
         Will not raise if the connection file was already removed somehow.
         """
         if self._connection_file_written:
             # cleanup connection files on full shutdown of kernel we started
             self._connection_file_written = False
             try:
                 os.remove(self.connection_file)
             except (IOError, OSError):
                 pass
     
     def cleanup_ipc_files(self):
         """Cleanup ipc files if we wrote them."""
         if self.transport != 'ipc':
             return
         for port in (self.shell_port, self.iopub_port, self.stdin_port, self.hb_port):
             ipcfile = "%s-%i" % (self.ip, port)
             try:
                 os.remove(ipcfile)
             except (IOError, OSError):
                 pass
 
     def load_connection_file(self):
         """Load connection info from JSON dict in self.connection_file."""
         with open(self.connection_file) as f:
             cfg = json.loads(f.read())
 
         from pprint import pprint
         pprint(cfg)
         self.transport = cfg.get('transport', 'tcp')
         self.ip = cfg['ip']
         self.shell_port = cfg['shell_port']
         self.stdin_port = cfg['stdin_port']
         self.iopub_port = cfg['iopub_port']
         self.hb_port = cfg['hb_port']
         self.session.key = str_to_bytes(cfg['key'])
     
     def write_connection_file(self):
         """Write connection info to JSON dict in self.connection_file."""
         if self._connection_file_written:
             return
         self.connection_file,cfg = write_connection_file(self.connection_file,
             transport=self.transport, ip=self.ip, key=self.session.key,
             stdin_port=self.stdin_port, iopub_port=self.iopub_port,
             shell_port=self.shell_port, hb_port=self.hb_port)
         # write_connection_file also sets default ports:
         self.shell_port = cfg['shell_port']
         self.stdin_port = cfg['stdin_port']
         self.iopub_port = cfg['iopub_port']
         self.hb_port = cfg['hb_port']
         
         self._connection_file_written = True
 
     #--------------------------------------------------------------------------
     # Kernel management
     #--------------------------------------------------------------------------
     
     def format_kernel_cmd(self, **kw):
         """format templated args (e.g. {connection_file})"""
         if self.kernel_cmd:
             cmd = self.kernel_cmd
         else:
             cmd = make_ipkernel_cmd(
                 'from IPython.zmq.kernelapp import main; main()',
                 **kw
             )
         ns = dict(connection_file=self.connection_file)
         ns.update(self._launch_args)
         return [ c.format(**ns) for c in cmd ]
     
     def _launch_kernel(self, kernel_cmd, **kw):
         """actually launch the kernel
         
         override in a subclass to launch kernel subprocesses differently
         """
         return launch_kernel(kernel_cmd, **kw)
     
     def start_kernel(self, **kw):
         """Starts a kernel on this host in a separate process.
 
         If random ports (port=0) are being used, this method must be called
         before the channels are created.
 
         Parameters:
         -----------
         **kw : optional
              keyword arguments that are passed down to build the kernel_cmd
              and launching the kernel (e.g. Popen kwargs).
         """
         if self.transport == 'tcp' and self.ip not in LOCAL_IPS:
             raise RuntimeError("Can only launch a kernel on a local interface. "
                                "Make sure that the '*_address' attributes are "
                                "configured properly. "
                                "Currently valid addresses are: %s"%LOCAL_IPS
                                )
         
         # write connection file / get default ports
         self.write_connection_file()
 
         # save kwargs for use in restart
         self._launch_args = kw.copy()
         # build the Popen cmd
         kernel_cmd = self.format_kernel_cmd(**kw)
         # launch the kernel subprocess
         self.kernel = self._launch_kernel(kernel_cmd,
                                     ipython_kernel=self.ipython_kernel,
                                     **kw)
 
     def shutdown_kernel(self, now=False, restart=False):
         """Attempts to the stop the kernel process cleanly. 
 
         This attempts to shutdown the kernels cleanly by:
 
         1. Sending it a shutdown message over the shell channel.
         2. If that fails, the kernel is shutdown forcibly by sending it
            a signal.
 
         Parameters:
         -----------
         now : bool
             Should the kernel be forcible killed *now*. This skips the
             first, nice shutdown attempt.
         restart: bool
             Will this kernel be restarted after it is shutdown. When this
             is True, connection files will not be cleaned up.
         """
         # FIXME: Shutdown does not work on Windows due to ZMQ errors!
         if sys.platform == 'win32':
             self._kill_kernel()
             return
 
         # Pause the heart beat channel if it exists.
         if self._hb_channel is not None:
             self._hb_channel.pause()
 
         if now:
             if self.has_kernel:
                 self._kill_kernel()
         else:
             # Don't send any additional kernel kill messages immediately, to give
             # the kernel a chance to properly execute shutdown actions. Wait for at
             # most 1s, checking every 0.1s.
             self.shell_channel.shutdown(restart=restart)
             for i in range(10):
                 if self.is_alive:
                     time.sleep(0.1)
                 else:
                     break
             else:
                 # OK, we've waited long enough.
                 if self.has_kernel:
                     self._kill_kernel()
 
         if not restart:
             self.cleanup_connection_file()
             self.cleanup_ipc_files()
         else:
             self.cleanup_ipc_files()
 
     def restart_kernel(self, now=False, **kw):
         """Restarts a kernel with the arguments that were used to launch it.
 
         If the old kernel was launched with random ports, the same ports will be
         used for the new kernel. The same connection file is used again.
 
         Parameters
         ----------
         now : bool, optional
             If True, the kernel is forcefully restarted *immediately*, without
             having a chance to do any cleanup action.  Otherwise the kernel is
             given 1s to clean up before a forceful restart is issued.
 
             In all cases the kernel is restarted, the only difference is whether
             it is given a chance to perform a clean shutdown or not.
 
         **kw : optional
             Any options specified here will overwrite those used to launch the
             kernel.
         """
         if self._launch_args is None:
             raise RuntimeError("Cannot restart the kernel. "
                                "No previous call to 'start_kernel'.")
         else:
             # Stop currently running kernel.
             self.shutdown_kernel(now=now, restart=True)
 
             # Start new kernel.
             self._launch_args.update(kw)
             self.start_kernel(**self._launch_args)
 
             # FIXME: Messages get dropped in Windows due to probable ZMQ bug
             # unless there is some delay here.
             if sys.platform == 'win32':
                 time.sleep(0.2)
 
     @property
     def has_kernel(self):
         """Has a kernel been started that we are managing."""
         return self.kernel is not None
 
     def _kill_kernel(self):
         """Kill the running kernel.
 
         This is a private method, callers should use shutdown_kernel(now=True).
         """
         if self.has_kernel:
             # Pause the heart beat channel if it exists.
             if self._hb_channel is not None:
                 self._hb_channel.pause()
 
             # Signal the kernel to terminate (sends SIGKILL on Unix and calls
             # TerminateProcess() on Win32).
             try:
                 self.kernel.kill()
             except OSError as e:
                 # In Windows, we will get an Access Denied error if the process
                 # has already terminated. Ignore it.
                 if sys.platform == 'win32':
                     if e.winerror != 5:
                         raise
                 # On Unix, we may get an ESRCH error if the process has already
                 # terminated. Ignore it.
                 else:
                     from errno import ESRCH
                     if e.errno != ESRCH:
                         raise
 
             # Block until the kernel terminates.
             self.kernel.wait()
             self.kernel = None
         else:
             raise RuntimeError("Cannot kill kernel. No kernel is running!")
 
     def interrupt_kernel(self):
         """Interrupts the kernel by sending it a signal.
 
         Unlike ``signal_kernel``, this operation is well supported on all
         platforms.
         """
         if self.has_kernel:
             if sys.platform == 'win32':
                 from parentpoller import ParentPollerWindows as Poller
                 Poller.send_interrupt(self.kernel.win32_interrupt_event)
             else:
                 self.kernel.send_signal(signal.SIGINT)
         else:
             raise RuntimeError("Cannot interrupt kernel. No kernel is running!")
 
     def signal_kernel(self, signum):
         """Sends a signal to the kernel.
 
         Note that since only SIGTERM is supported on Windows, this function is
         only useful on Unix systems.
         """
         if self.has_kernel:
             self.kernel.send_signal(signum)
         else:
             raise RuntimeError("Cannot signal kernel. No kernel is running!")
 
     @property
     def is_alive(self):
         """Is the kernel process still running?"""
         if self.has_kernel:
             if self.kernel.poll() is None:
                 return True
             else:
                 return False
         elif self._hb_channel is not None:
             # We didn't start the kernel with this KernelManager so we
             # use the heartbeat.
             return self._hb_channel.is_beating()
         else:
             # no heartbeat and not local, we can't tell if it's running,
             # so naively return True
             return True
 
 
 #-----------------------------------------------------------------------------
 # ABC Registration
 #-----------------------------------------------------------------------------
 
 ShellChannelABC.register(ShellChannel)
 IOPubChannelABC.register(IOPubChannel)
 HBChannelABC.register(HBChannel)
 StdInChannelABC.register(StdInChannel)
 KernelManagerABC.register(KernelManager)
 

IPython/kernel/kernelmanagerabc.py

@@ -1,226 +1,226 b''
 """Abstract base classes for kernel manager and channels."""
 
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 import abc
 
 #-----------------------------------------------------------------------------
 # Channels
 #-----------------------------------------------------------------------------
 
 
 class ChannelABC(object):
     """A base class for all channel ABCs."""
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractmethod
     def start(self):
         pass
 
     @abc.abstractmethod
     def stop(self):
         pass
 
     @abc.abstractmethod
     def is_alive(self):
         pass
 
 
 class ShellChannelABC(ChannelABC):
     """ShellChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.zmq.kernelmanager.ShellChannel`
+    `IPython.kernel.kernelmanager.ShellChannel`
     """
 
     @abc.abstractproperty
     def allow_stdin(self):
         pass
 
     @abc.abstractmethod
     def execute(self, code, silent=False, store_history=True,
                 user_variables=None, user_expressions=None, allow_stdin=None):
         pass
 
     @abc.abstractmethod
     def complete(self, text, line, cursor_pos, block=None):
         pass
 
     @abc.abstractmethod
     def object_info(self, oname, detail_level=0):
         pass
 
     @abc.abstractmethod
     def history(self, raw=True, output=False, hist_access_type='range', **kwargs):
         pass
 
     @abc.abstractmethod
     def kernel_info(self):
         pass
 
     @abc.abstractmethod
     def shutdown(self, restart=False):
         pass
 
 
 class IOPubChannelABC(ChannelABC):
     """IOPubChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.zmq.kernelmanager.IOPubChannel`
+    `IPython.kernel.kernelmanager.IOPubChannel`
     """
 
     @abc.abstractmethod
     def flush(self, timeout=1.0):
         pass
 
 
 class StdInChannelABC(ChannelABC):
     """StdInChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.zmq.kernelmanager.StdInChannel`
+    `IPython.kernel.kernelmanager.StdInChannel`
     """
 
     @abc.abstractmethod
     def input(self, string):
         pass
 
 
 class HBChannelABC(ChannelABC):
     """HBChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.zmq.kernelmanager.HBChannel`
+    `IPython.kernel.kernelmanager.HBChannel`
     """
 
     @abc.abstractproperty
     def time_to_dead(self):
         pass
 
     @abc.abstractmethod
     def pause(self):
         pass
 
     @abc.abstractmethod
     def unpause(self):
         pass
 
     @abc.abstractmethod
     def is_beating(self):
         pass
 
 
 #-----------------------------------------------------------------------------
 # Main kernel manager class
 #-----------------------------------------------------------------------------
 
 class KernelManagerABC(object):
     """KernelManager ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.zmq.kernelmanager.KernelManager`
+    `IPython.kernel.kernelmanager.KernelManager`
     """
 
     __metaclass__ = abc.ABCMeta
 
     @abc.abstractproperty
     def kernel(self):
         pass
 
     @abc.abstractproperty
     def shell_channel_class(self):
         pass
 
     @abc.abstractproperty
     def iopub_channel_class(self):
         pass
 
     @abc.abstractproperty
     def hb_channel_class(self):
         pass
 
     @abc.abstractproperty
     def stdin_channel_class(self):
         pass
 
     #--------------------------------------------------------------------------
     # Channel management methods
     #--------------------------------------------------------------------------
 
     @abc.abstractmethod
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         pass
 
     @abc.abstractmethod
     def stop_channels(self):
         pass
 
     @abc.abstractproperty
     def channels_running(self):
         pass
 
     @abc.abstractproperty
     def shell_channel(self):
         pass
 
     @abc.abstractproperty
     def iopub_channel(self):
         pass
 
     @abc.abstractproperty
     def stdin_channel(self):
         pass
 
     @abc.abstractproperty
     def hb_channel(self):
         pass
 
     #--------------------------------------------------------------------------
     # Kernel management
     #--------------------------------------------------------------------------
 
     @abc.abstractmethod
     def start_kernel(self, **kw):
         pass
 
     @abc.abstractmethod
     def shutdown_kernel(self, now=False, restart=False):
         pass
 
     @abc.abstractmethod
     def restart_kernel(self, now=False, **kw):
         pass
 
     @abc.abstractproperty
     def has_kernel(self):
         pass
 
     @abc.abstractmethod
     def interrupt_kernel(self):
         pass
 
     @abc.abstractmethod
     def signal_kernel(self, signum):
         pass
 
     @abc.abstractproperty
     def is_alive(self):
         pass
 

IPython/zmq/__init__.py

@@ -1,51 +1,51 b''
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2010  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING.txt, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Verify zmq version dependency >= 2.1.11
 #-----------------------------------------------------------------------------
 
 import warnings
 from IPython.utils.version import check_version
 
 
 def patch_pyzmq():
     """backport a few patches from newer pyzmq
     
     These can be removed as we bump our minimum pyzmq version
     """
     
     import zmq
     
     # fallback on stdlib json if jsonlib is selected, because jsonlib breaks things.
     # jsonlib support is removed from pyzmq >= 2.2.0
 
     from zmq.utils import jsonapi
     if jsonapi.jsonmod.__name__ == 'jsonlib':
         import json
         jsonapi.jsonmod = json
 
 
 def check_for_zmq(minimum_version, module='IPython.zmq'):
     try:
         import zmq
     except ImportError:
         raise ImportError("%s requires pyzmq >= %s"%(module, minimum_version))
 
     pyzmq_version = zmq.__version__
     
     if not check_version(pyzmq_version, minimum_version):
         raise ImportError("%s requires pyzmq >= %s, but you have %s"%(
                         module, minimum_version, pyzmq_version))
 
 check_for_zmq('2.1.11')
 patch_pyzmq()
 
-from .blockingkernelmanager import BlockingKernelManager
-from .kernelmanager import *
+from IPython.kernel.blockingkernelmanager import BlockingKernelManager
+from IPython.kernel.kernelmanager import *
 from .session import Session
 

IPython/zmq/tests/test_embed_kernel.py

@@ -1,193 +1,193 b''
 """test IPython.embed_kernel()"""
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2012  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 os
 import shutil
 import sys
 import tempfile
 import time
 
 from contextlib import contextmanager
 from subprocess import Popen, PIPE
 
 import nose.tools as nt
 
-from IPython.zmq.blockingkernelmanager import BlockingKernelManager
+from IPython.kernel.blockingkernelmanager import BlockingKernelManager
 from IPython.utils import path, py3compat
 
 #-------------------------------------------------------------------------------
 # Tests
 #-------------------------------------------------------------------------------
 
 def setup():
     """setup temporary IPYTHONDIR for tests"""
     global IPYTHONDIR
     global env
     global save_get_ipython_dir
     
     IPYTHONDIR = tempfile.mkdtemp()
 
     env = os.environ.copy()
     env["IPYTHONDIR"] = IPYTHONDIR
 
     save_get_ipython_dir = path.get_ipython_dir
     path.get_ipython_dir = lambda : IPYTHONDIR
 
 
 def teardown():
     path.get_ipython_dir = save_get_ipython_dir
     
     try:
         shutil.rmtree(IPYTHONDIR)
     except (OSError, IOError):
         # no such file
         pass
 
 
 @contextmanager
 def setup_kernel(cmd):
     """start an embedded kernel in a subprocess, and wait for it to be ready
     
     Returns
     -------
     kernel_manager: connected KernelManager instance
     """
     kernel = Popen([sys.executable, '-c', cmd], stdout=PIPE, stderr=PIPE, env=env)
     connection_file = os.path.join(IPYTHONDIR,
                                     'profile_default',
                                     'security',
                                     'kernel-%i.json' % kernel.pid
     )
     # wait for connection file to exist, timeout after 5s
     tic = time.time()
     while not os.path.exists(connection_file) and kernel.poll() is None and time.time() < tic + 10:
         time.sleep(0.1)
     
     if kernel.poll() is not None:
         o,e = kernel.communicate()
         e = py3compat.cast_unicode(e)
         raise IOError("Kernel failed to start:\n%s" % e)
     
     if not os.path.exists(connection_file):
         if kernel.poll() is None:
             kernel.terminate()
         raise IOError("Connection file %r never arrived" % connection_file)
     
     km = BlockingKernelManager(connection_file=connection_file)
     km.load_connection_file()
     km.start_channels()
     
     try:
         yield km
     finally:
         km.stop_channels()
         kernel.terminate()
 
 def test_embed_kernel_basic():
     """IPython.embed_kernel() is basically functional"""
     cmd = '\n'.join([
         'from IPython import embed_kernel',
         'def go():',
         '    a=5',
         '    b="hi there"',
         '    embed_kernel()',
         'go()',
         '',
     ])
     
     with setup_kernel(cmd) as km:
         shell = km.shell_channel
     
         # oinfo a (int)
         msg_id = shell.object_info('a')
         msg = shell.get_msg(block=True, timeout=2)
         content = msg['content']
         nt.assert_true(content['found'])
     
         msg_id = shell.execute("c=a*2")
         msg = shell.get_msg(block=True, timeout=2)
         content = msg['content']
         nt.assert_equal(content['status'], u'ok')
 
         # oinfo c (should be 10)
         msg_id = shell.object_info('c')
         msg = shell.get_msg(block=True, timeout=2)
         content = msg['content']
         nt.assert_true(content['found'])
         nt.assert_equal(content['string_form'], u'10')
 
 def test_embed_kernel_namespace():
     """IPython.embed_kernel() inherits calling namespace"""
     cmd = '\n'.join([
         'from IPython import embed_kernel',
         'def go():',
         '    a=5',
         '    b="hi there"',
         '    embed_kernel()',
         'go()',
         '',
     ])
     
     with setup_kernel(cmd) as km:
         shell = km.shell_channel
     
         # oinfo a (int)
         msg_id = shell.object_info('a')
         msg = shell.get_msg(block=True, timeout=2)
         content = msg['content']
         nt.assert_true(content['found'])
         nt.assert_equal(content['string_form'], u'5')
 
         # oinfo b (str)
         msg_id = shell.object_info('b')
         msg = shell.get_msg(block=True, timeout=2)
         content = msg['content']
         nt.assert_true(content['found'])
         nt.assert_equal(content['string_form'], u'hi there')
 
         # oinfo c (undefined)
         msg_id = shell.object_info('c')
         msg = shell.get_msg(block=True, timeout=2)
         content = msg['content']
         nt.assert_false(content['found'])
 
 def test_embed_kernel_reentrant():
     """IPython.embed_kernel() can be called multiple times"""
     cmd = '\n'.join([
         'from IPython import embed_kernel',
         'count = 0',
         'def go():',
         '    global count',
         '    embed_kernel()',
         '    count = count + 1',
         '',
         'while True:'
         '    go()',
         '',
     ])
     
     with setup_kernel(cmd) as km:
         shell = km.shell_channel
         for i in range(5):
             msg_id = shell.object_info('count')
             msg = shell.get_msg(block=True, timeout=2)
             content = msg['content']
             nt.assert_true(content['found'])
             nt.assert_equal(content['string_form'], unicode(i))
             
             # exit from embed_kernel
             shell.execute("get_ipython().exit_now = True")
             msg = shell.get_msg(block=True, timeout=2)
             time.sleep(0.2)
 
 

IPython/zmq/tests/test_kernelmanager.py

@@ -1,48 +1,48 b''
 """Tests for the notebook kernel and session manager"""
 
 from subprocess import PIPE
 import time
 from unittest import TestCase
 
 from IPython.testing import decorators as dec
 
 from IPython.config.loader import Config
-from IPython.zmq.kernelmanager import KernelManager
+from IPython.kernel.kernelmanager import KernelManager
 
 class TestKernelManager(TestCase):
 
     def _get_tcp_km(self):
         return KernelManager()
 
     def _get_ipc_km(self):
         c = Config()
         c.KernelManager.transport = 'ipc'
         c.KernelManager.ip = 'test'
         km = KernelManager(config=c)
         return km
 
     def _run_lifecycle(self, km):
         km.start_kernel(stdout=PIPE, stderr=PIPE)
         km.start_channels(shell=True, iopub=False, stdin=False, hb=False)
         km.restart_kernel()
         # We need a delay here to give the restarting kernel a chance to
         # restart. Otherwise, the interrupt will kill it, causing the test
         # suite to hang. The reason it *hangs* is that the shutdown
         # message for the restart sometimes hasn't been sent to the kernel.
         # Because linger is oo on the shell channel, the context can't
         # close until the message is sent to the kernel, which is not dead.
         time.sleep(1.0)
         km.interrupt_kernel()
         self.assertTrue(isinstance(km, KernelManager))
         km.shutdown_kernel()
         km.shell_channel.stop()
 
     def test_tcp_lifecycle(self):
         km = self._get_tcp_km()
         self._run_lifecycle(km)
 
     @dec.skip_win32
     def testipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)