s/IPython.kernel/jupyter_client in jupyter_client

jupyter_client/__init__.py

@@ -1,11 +1,8 b''
 """IPython kernels and associated utilities"""
 
-# just for friendlier zmq version check
-from . import zmq
-
 from .connect import *
 from .launcher import *
 from .client import KernelClient
 from .manager import KernelManager, run_kernel
 from .blocking import BlockingKernelClient
 from .multikernelmanager import MultiKernelManager

jupyter_client/blocking/client.py

@@ -1,38 +1,38 b''
 """Implements a fully blocking kernel client.
 
 Useful for test suites and blocking terminal interfaces.
 """
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 try:
     from queue import Empty  # Python 3
 except ImportError:
     from Queue import Empty  # Python 2
 
 from IPython.utils.traitlets import Type
-from IPython.kernel.channels import HBChannel
-from IPython.kernel.client import KernelClient
+from jupyter_client.channels import HBChannel
+from jupyter_client.client import KernelClient
 from .channels import ZMQSocketChannel
 
 class BlockingKernelClient(KernelClient):
     def wait_for_ready(self):
         # Wait for kernel info reply on shell channel
         while True:
             msg = self.shell_channel.get_msg(block=True)
             if msg['msg_type'] == 'kernel_info_reply':
                 self._handle_kernel_info_reply(msg)
                 break
 
         # Flush IOPub channel
         while True:
             try:
                 msg = self.iopub_channel.get_msg(block=True, timeout=0.2)
             except Empty:
                 break
 
     # The classes to use for the various channels
     shell_channel_class = Type(ZMQSocketChannel)
     iopub_channel_class = Type(ZMQSocketChannel)
     stdin_channel_class = Type(ZMQSocketChannel)
     hb_channel_class = Type(HBChannel)

jupyter_client/channelsabc.py

@@ -1,49 +1,49 b''
 """Abstract base classes for kernel client channels"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import abc
 
 from IPython.utils.py3compat import with_metaclass
 
 
 class ChannelABC(with_metaclass(abc.ABCMeta, object)):
     """A base class for all channel ABCs."""
 
     @abc.abstractmethod
     def start(self):
         pass
 
     @abc.abstractmethod
     def stop(self):
         pass
 
     @abc.abstractmethod
     def is_alive(self):
         pass
 
 
 class HBChannelABC(ChannelABC):
     """HBChannel ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.kernel.channels.HBChannel`
+    `jupyter_client.channels.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

jupyter_client/client.py

@@ -1,390 +1,390 b''
 """Base class to manage the interaction with a running kernel"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import absolute_import
-from IPython.kernel.channels import major_protocol_version
+from jupyter_client.channels import major_protocol_version
 from IPython.utils.py3compat import string_types, iteritems
 
 import zmq
 
 from IPython.utils.traitlets import (
     Any, Instance, Type,
 )
 
 from .channelsabc import (ChannelABC, HBChannelABC)
 from .clientabc import KernelClientABC
 from .connect import ConnectionFileMixin
 
 
 # some utilities to validate message structure, these might get moved elsewhere
 # if they prove to have more generic utility
 
 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 iteritems(dct):
         if not isinstance(k, string_types):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, string_types):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 class KernelClient(ConnectionFileMixin):
     """Communicates with a single kernel on any host via zmq 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 methods of the channels are exposed as methods of the client itself
     (KernelClient.execute, complete, history, etc.).
     See the channels themselves for documentation of these methods.
 
     """
 
     # The PyZMQ Context to use for communication with the kernel.
     context = Instance(zmq.Context)
     def _context_default(self):
         return zmq.Context.instance()
 
     # The classes to use for the various channels
     shell_channel_class = Type(ChannelABC)
     iopub_channel_class = Type(ChannelABC)
     stdin_channel_class = Type(ChannelABC)
     hb_channel_class = Type(HBChannelABC)
 
     # Protected traits
     _shell_channel = Any
     _iopub_channel = Any
     _stdin_channel = Any
     _hb_channel = Any
 
     # flag for whether execute requests should be allowed to call raw_input:
     allow_stdin = True
 
     #--------------------------------------------------------------------------
     # Channel proxy methods
     #--------------------------------------------------------------------------
 
     def _get_msg(channel, *args, **kwargs):
         return channel.get_msg(*args, **kwargs)
 
     def get_shell_msg(self, *args, **kwargs):
         """Get a message from the shell channel"""
         return self.shell_channel.get_msg(*args, **kwargs)
 
     def get_iopub_msg(self, *args, **kwargs):
         """Get a message from the iopub channel"""
         return self.iopub_channel.get_msg(*args, **kwargs)
 
     def get_stdin_msg(self, *args, **kwargs):
         """Get a message from the stdin channel"""
         return self.stdin_channel.get_msg(*args, **kwargs)
 
     #--------------------------------------------------------------------------
     # 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
         :meth:`start_kernel`. If the channels have been stopped and you
         call this, :class:`RuntimeError` will be raised.
         """
         if shell:
             self.shell_channel.start()
             self.kernel_info()
         if iopub:
             self.iopub_channel.start()
         if stdin:
             self.stdin_channel.start()
             self.allow_stdin = True
         else:
             self.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())
 
     ioloop = None  # Overridden in subclasses that use pyzmq event loop
 
     @property
     def shell_channel(self):
         """Get the shell channel object for this kernel."""
         if self._shell_channel is None:
             url = self._make_url('shell')
             self.log.debug("connecting shell channel to %s", url)
             socket = self.connect_shell(identity=self.session.bsession)
             self._shell_channel = self.shell_channel_class(
                 socket, self.session, self.ioloop
             )
         return self._shell_channel
 
     @property
     def iopub_channel(self):
         """Get the iopub channel object for this kernel."""
         if self._iopub_channel is None:
             url = self._make_url('iopub')
             self.log.debug("connecting iopub channel to %s", url)
             socket = self.connect_iopub()
             self._iopub_channel = self.iopub_channel_class(
                 socket, self.session, self.ioloop
             )
         return self._iopub_channel
 
     @property
     def stdin_channel(self):
         """Get the stdin channel object for this kernel."""
         if self._stdin_channel is None:
             url = self._make_url('stdin')
             self.log.debug("connecting stdin channel to %s", url)
             socket = self.connect_stdin(identity=self.session.bsession)
             self._stdin_channel = self.stdin_channel_class(
                 socket, self.session, self.ioloop
             )
         return self._stdin_channel
 
     @property
     def hb_channel(self):
         """Get the hb channel object for this kernel."""
         if self._hb_channel is None:
             url = self._make_url('hb')
             self.log.debug("connecting heartbeat channel to %s", url)
             self._hb_channel = self.hb_channel_class(
                 self.context, self.session, url
             )
         return self._hb_channel
 
     def is_alive(self):
         """Is the kernel process still running?"""
         if 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
 
 
     # Methods to send specific messages on channels
     def execute(self, code, silent=False, store_history=True,
                 user_expressions=None, allow_stdin=None, stop_on_error=True):
         """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_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.
 
         stop_on_error: bool, optional (default True)
             Flag whether to abort the execution queue, if an exception is encountered.
 
         Returns
         -------
         The msg_id of the message sent.
         """
         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, string_types):
             raise ValueError('code %r must be a string' % code)
         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_expressions=user_expressions,
                        allow_stdin=allow_stdin, stop_on_error=stop_on_error
                        )
         msg = self.session.msg('execute_request', content)
         self.shell_channel.send(msg)
         return msg['header']['msg_id']
 
     def complete(self, code, cursor_pos=None):
         """Tab complete text in the kernel's namespace.
 
         Parameters
         ----------
         code : str
             The context in which completion is requested.
             Can be anything between a variable name and an entire cell.
         cursor_pos : int, optional
             The position of the cursor in the block of code where the completion was requested.
             Default: ``len(code)``
 
         Returns
         -------
         The msg_id of the message sent.
         """
         if cursor_pos is None:
             cursor_pos = len(code)
         content = dict(code=code, cursor_pos=cursor_pos)
         msg = self.session.msg('complete_request', content)
         self.shell_channel.send(msg)
         return msg['header']['msg_id']
 
     def inspect(self, code, cursor_pos=None, detail_level=0):
         """Get metadata information about an object in the kernel's namespace.
 
         It is up to the kernel to determine the appropriate object to inspect.
 
         Parameters
         ----------
         code : str
             The context in which info is requested.
             Can be anything between a variable name and an entire cell.
         cursor_pos : int, optional
             The position of the cursor in the block of code where the info was requested.
             Default: ``len(code)``
         detail_level : int, optional
             The level of detail for the introspection (0-2)
 
         Returns
         -------
         The msg_id of the message sent.
         """
         if cursor_pos is None:
             cursor_pos = len(code)
         content = dict(code=code, cursor_pos=cursor_pos,
             detail_level=detail_level,
         )
         msg = self.session.msg('inspect_request', content)
         self.shell_channel.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.shell_channel.send(msg)
         return msg['header']['msg_id']
 
     def kernel_info(self):
         """Request kernel info."""
         msg = self.session.msg('kernel_info_request')
         self.shell_channel.send(msg)
         return msg['header']['msg_id']
 
     def _handle_kernel_info_reply(self, msg):
         """handle kernel info reply
 
         sets protocol adaptation version. This might
         be run from a separate thread.
         """
         adapt_version = int(msg['content']['protocol_version'].split('.')[0])
         if adapt_version != major_protocol_version:
             self.session.adapt_version = adapt_version
 
     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.shell_channel.send(msg)
         return msg['header']['msg_id']
 
     def is_complete(self, code):
         msg = self.session.msg('is_complete_request', {'code': code})
         self.shell_channel.send(msg)
         return msg['header']['msg_id']
 
     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.stdin_channel.send(msg)
 
 
 KernelClientABC.register(KernelClient)

jupyter_client/clientabc.py

@@ -1,80 +1,80 b''
 """Abstract base class for kernel clients"""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2013  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import abc
 
 from IPython.utils.py3compat import with_metaclass
 
 #-----------------------------------------------------------------------------
 # Main kernel client class
 #-----------------------------------------------------------------------------
 
 class KernelClientABC(with_metaclass(abc.ABCMeta, object)):
     """KernelManager ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.kernel.client.KernelClient`
+    `jupyter_client.client.KernelClient`
     """
 
     @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

jupyter_client/connect.py

@@ -1,576 +1,576 b''
 """Utilities for connecting to kernels
 
 The :class:`ConnectionFileMixin` class in this module encapsulates the logic
 related to writing and reading connections files.
 """
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 import glob
 import json
 import os
 import socket
 import sys
 from getpass import getpass
 from subprocess import Popen, PIPE
 import tempfile
 
 import zmq
 
 # IPython imports
 from IPython.config import LoggingConfigurable
 from IPython.core.profiledir import ProfileDir
 from IPython.utils.localinterfaces import localhost
 from IPython.utils.path import filefind, get_ipython_dir
 from IPython.utils.py3compat import (str_to_bytes, bytes_to_str, cast_bytes_py2,
                                      string_types)
 from IPython.utils.traitlets import (
     Bool, Integer, Unicode, CaselessStrEnum, Instance,
 )
 
 
 #-----------------------------------------------------------------------------
 # Working with Connection Files
 #-----------------------------------------------------------------------------
 
 def write_connection_file(fname=None, shell_port=0, iopub_port=0, stdin_port=0, hb_port=0,
                          control_port=0, ip='', key=b'', transport='tcp',
                          signature_scheme='hmac-sha256',
                          ):
     """Generates a JSON config file, including the selection of random ports.
 
     Parameters
     ----------
 
     fname : unicode
         The path to the file to write
 
     shell_port : int, optional
         The port to use for ROUTER (shell) channel.
 
     iopub_port : int, optional
         The port to use for the SUB channel.
 
     stdin_port : int, optional
         The port to use for the ROUTER (raw input) channel.
 
     control_port : int, optional
         The port to use for the ROUTER (control) channel.
 
     hb_port : int, optional
         The port to use for the heartbeat REP channel.
 
     ip  : str, optional
         The ip address the kernel will bind to.
 
     key : str, optional
         The Session key used for message authentication.
 
     signature_scheme : str, optional
         The scheme used for message authentication.
         This has the form 'digest-hash', where 'digest'
         is the scheme used for digests, and 'hash' is the name of the hash function
         used by the digest scheme.
         Currently, 'hmac' is the only supported digest scheme,
         and 'sha256' is the default hash function.
 
     """
     if not ip:
         ip = localhost()
     # default to temporary connector file
     if not fname:
         fd, fname = tempfile.mkstemp('.json')
         os.close(fd)
 
     # Find open ports as necessary.
 
     ports = []
     ports_needed = int(shell_port <= 0) + \
                    int(iopub_port <= 0) + \
                    int(stdin_port <= 0) + \
                    int(control_port <= 0) + \
                    int(hb_port <= 0)
     if transport == 'tcp':
         for i in range(ports_needed):
             sock = socket.socket()
             # struct.pack('ii', (0,0)) is 8 null bytes
             sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, b'\0' * 8)
             sock.bind(('', 0))
             ports.append(sock)
         for i, sock in enumerate(ports):
             port = sock.getsockname()[1]
             sock.close()
             ports[i] = port
     else:
         N = 1
         for i in range(ports_needed):
             while os.path.exists("%s-%s" % (ip, str(N))):
                 N += 1
             ports.append(N)
             N += 1
     if shell_port <= 0:
         shell_port = ports.pop(0)
     if iopub_port <= 0:
         iopub_port = ports.pop(0)
     if stdin_port <= 0:
         stdin_port = ports.pop(0)
     if control_port <= 0:
         control_port = ports.pop(0)
     if hb_port <= 0:
         hb_port = ports.pop(0)
 
     cfg = dict( shell_port=shell_port,
                 iopub_port=iopub_port,
                 stdin_port=stdin_port,
                 control_port=control_port,
                 hb_port=hb_port,
               )
     cfg['ip'] = ip
     cfg['key'] = bytes_to_str(key)
     cfg['transport'] = transport
     cfg['signature_scheme'] = signature_scheme
 
     with open(fname, 'w') as f:
         f.write(json.dumps(cfg, indent=2))
 
     return fname, cfg
 
 
 def get_connection_file(app=None):
     """Return the path to the connection file of an app
 
     Parameters
     ----------
     app : IPKernelApp instance [optional]
         If unspecified, the currently running app will be used
     """
     if app is None:
-        from IPython.kernel.zmq.kernelapp import IPKernelApp
+        from jupyter_client.kernelapp import IPKernelApp
         if not IPKernelApp.initialized():
             raise RuntimeError("app not specified, and not in a running Kernel")
 
         app = IPKernelApp.instance()
     return filefind(app.connection_file, ['.', app.profile_dir.security_dir])
 
 
 def find_connection_file(filename='kernel-*.json', profile=None):
     """find a connection file, and return its absolute path.
 
     The current working directory and the profile's security
     directory will be searched for the file if it is not given by
     absolute path.
 
     If profile is unspecified, then the current running application's
     profile will be used, or 'default', if not run from IPython.
 
     If the argument does not match an existing file, it will be interpreted as a
     fileglob, and the matching file in the profile's security dir with
     the latest access time will be used.
 
     Parameters
     ----------
     filename : str
         The connection file or fileglob to search for.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
 
     Returns
     -------
     str : The absolute path of the connection file.
     """
     from IPython.core.application import BaseIPythonApplication as IPApp
     try:
         # quick check for absolute path, before going through logic
         return filefind(filename)
     except IOError:
         pass
 
     if profile is None:
         # profile unspecified, check if running from an IPython app
         if IPApp.initialized():
             app = IPApp.instance()
             profile_dir = app.profile_dir
         else:
             # not running in IPython, use default profile
             profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default')
     else:
         # find profiledir by profile name:
         profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
     security_dir = profile_dir.security_dir
 
     try:
         # first, try explicit name
         return filefind(filename, ['.', security_dir])
     except IOError:
         pass
 
     # not found by full name
 
     if '*' in filename:
         # given as a glob already
         pat = filename
     else:
         # accept any substring match
         pat = '*%s*' % filename
     matches = glob.glob( os.path.join(security_dir, pat) )
     if not matches:
         raise IOError("Could not find %r in %r" % (filename, security_dir))
     elif len(matches) == 1:
         return matches[0]
     else:
         # get most recent match, by access time:
         return sorted(matches, key=lambda f: os.stat(f).st_atime)[-1]
 
 
 def get_connection_info(connection_file=None, unpack=False, profile=None):
     """Return the connection information for the current Kernel.
 
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
         If run from IPython,
 
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     unpack : bool [default: False]
         if True, return the unpacked dict, otherwise just the string contents
         of the file.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
 
 
     Returns
     -------
     The connection dictionary of the current kernel, as string or dict,
     depending on `unpack`.
     """
     if connection_file is None:
         # get connection file from current kernel
         cf = get_connection_file()
     else:
         # connection file specified, allow shortnames:
         cf = find_connection_file(connection_file, profile=profile)
 
     with open(cf) as f:
         info = f.read()
 
     if unpack:
         info = json.loads(info)
         # ensure key is bytes:
         info['key'] = str_to_bytes(info.get('key', ''))
     return info
 
 
 def connect_qtconsole(connection_file=None, argv=None, profile=None):
     """Connect a qtconsole to the current kernel.
 
     This is useful for connecting a second qtconsole to a kernel, or to a
     local notebook.
 
     Parameters
     ----------
     connection_file : str [optional]
         The connection file to be used. Can be given by absolute path, or
         IPython will search in the security directory of a given profile.
         If run from IPython,
 
         If unspecified, the connection file for the currently running
         IPython Kernel will be used, which is only allowed from inside a kernel.
     argv : list [optional]
         Any extra args to be passed to the console.
     profile : str [optional]
         The name of the profile to use when searching for the connection file,
         if different from the current IPython session or 'default'.
 
 
     Returns
     -------
     :class:`subprocess.Popen` instance running the qtconsole frontend
     """
     argv = [] if argv is None else argv
 
     if connection_file is None:
         # get connection file from current kernel
         cf = get_connection_file()
     else:
         cf = find_connection_file(connection_file, profile=profile)
 
     cmd = ';'.join([
         "from IPython.qt.console import qtconsoleapp",
         "qtconsoleapp.main()"
     ])
 
     return Popen([sys.executable, '-c', cmd, '--existing', cf] + argv,
         stdout=PIPE, stderr=PIPE, close_fds=(sys.platform != 'win32'),
     )
 
 
 def tunnel_to_kernel(connection_info, sshserver, sshkey=None):
     """tunnel connections to a kernel via ssh
 
     This will open four SSH tunnels from localhost on this machine to the
     ports associated with the kernel.  They can be either direct
     localhost-localhost tunnels, or if an intermediate server is necessary,
     the kernel must be listening on a public IP.
 
     Parameters
     ----------
     connection_info : dict or str (path)
         Either a connection dict, or the path to a JSON connection file
     sshserver : str
         The ssh sever to use to tunnel to the kernel. Can be a full
         `user@server:port` string. ssh config aliases are respected.
     sshkey : str [optional]
         Path to file containing ssh key to use for authentication.
         Only necessary if your ssh config does not already associate
         a keyfile with the host.
 
     Returns
     -------
 
     (shell, iopub, stdin, hb) : ints
         The four ports on localhost that have been forwarded to the kernel.
     """
     from zmq.ssh import tunnel
     if isinstance(connection_info, string_types):
         # it's a path, unpack it
         with open(connection_info) as f:
             connection_info = json.loads(f.read())
 
     cf = connection_info
 
     lports = tunnel.select_random_ports(4)
     rports = cf['shell_port'], cf['iopub_port'], cf['stdin_port'], cf['hb_port']
 
     remote_ip = cf['ip']
 
     if tunnel.try_passwordless_ssh(sshserver, sshkey):
         password=False
     else:
         password = getpass("SSH Password for %s: " % cast_bytes_py2(sshserver))
 
     for lp,rp in zip(lports, rports):
         tunnel.ssh_tunnel(lp, rp, sshserver, remote_ip, sshkey, password)
 
     return tuple(lports)
 
 
 #-----------------------------------------------------------------------------
 # Mixin for classes that work with connection files
 #-----------------------------------------------------------------------------
 
 channel_socket_types = {
     'hb' : zmq.REQ,
     'shell' : zmq.DEALER,
     'iopub' : zmq.SUB,
     'stdin' : zmq.DEALER,
     'control': zmq.DEALER,
 }
 
 port_names = [ "%s_port" % channel for channel in ('shell', 'stdin', 'iopub', 'hb', 'control')]
 
 class ConnectionFileMixin(LoggingConfigurable):
     """Mixin for configurable classes that work with connection files"""
 
     # The addresses for the communication channels
     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.
     """)
     _connection_file_written = Bool(False)
 
     transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
 
     ip = Unicode(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'
 
     # protected traits
 
     hb_port = Integer(0, config=True,
             help="set the heartbeat port [default: random]")
     shell_port = Integer(0, config=True,
             help="set the shell (ROUTER) port [default: random]")
     iopub_port = Integer(0, config=True,
             help="set the iopub (PUB) port [default: random]")
     stdin_port = Integer(0, config=True,
             help="set the stdin (ROUTER) port [default: random]")
     control_port = Integer(0, config=True,
             help="set the control (ROUTER) port [default: random]")
 
     @property
     def ports(self):
         return [ getattr(self, name) for name in port_names ]
 
     # The Session to use for communication with the kernel.
-    session = Instance('IPython.kernel.zmq.session.Session')
+    session = Instance('jupyter_client.session.Session')
     def _session_default(self):
-        from IPython.kernel.zmq.session import Session
+        from jupyter_client.session import Session
         return Session(parent=self)
 
     #--------------------------------------------------------------------------
     # Connection and ipc file management
     #--------------------------------------------------------------------------
 
     def get_connection_info(self):
         """return the connection info as a dict"""
         return dict(
             transport=self.transport,
             ip=self.ip,
             shell_port=self.shell_port,
             iopub_port=self.iopub_port,
             stdin_port=self.stdin_port,
             hb_port=self.hb_port,
             control_port=self.control_port,
             signature_scheme=self.session.signature_scheme,
             key=self.session.key,
         )
 
     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, AttributeError):
                 pass
 
     def cleanup_ipc_files(self):
         """Cleanup ipc files if we wrote them."""
         if self.transport != 'ipc':
             return
         for port in self.ports:
             ipcfile = "%s-%i" % (self.ip, port)
             try:
                 os.remove(ipcfile)
             except (IOError, OSError):
                 pass
 
     def write_connection_file(self):
         """Write connection info to JSON dict in self.connection_file."""
         if self._connection_file_written and os.path.exists(self.connection_file):
             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,
             control_port=self.control_port,
             signature_scheme=self.session.signature_scheme,
         )
         # write_connection_file also sets default ports:
         for name in port_names:
             setattr(self, name, cfg[name])
 
         self._connection_file_written = True
 
     def load_connection_file(self):
         """Load connection info from JSON dict in self.connection_file."""
         self.log.debug(u"Loading connection file %s", self.connection_file)
         with open(self.connection_file) as f:
             cfg = json.load(f)
         self.transport = cfg.get('transport', self.transport)
         self.ip = cfg.get('ip', self._ip_default())
 
         for name in port_names:
             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.session.key = str_to_bytes(cfg['key'])
         if 'signature_scheme' in cfg:
             self.session.signature_scheme = cfg['signature_scheme']
 
     #--------------------------------------------------------------------------
     # Creating connected sockets
     #--------------------------------------------------------------------------
 
     def _make_url(self, channel):
         """Make a ZeroMQ URL for a given channel."""
         transport = self.transport
         ip = self.ip
         port = getattr(self, '%s_port' % channel)
 
         if transport == 'tcp':
             return "tcp://%s:%i" % (ip, port)
         else:
             return "%s://%s-%s" % (transport, ip, port)
 
     def _create_connected_socket(self, channel, identity=None):
         """Create a zmq Socket and connect it to the kernel."""
         url = self._make_url(channel)
         socket_type = channel_socket_types[channel]
         self.log.debug("Connecting to: %s" % url)
         sock = self.context.socket(socket_type)
         # set linger to 1s to prevent hangs at exit
         sock.linger = 1000
         if identity:
             sock.identity = identity
         sock.connect(url)
         return sock
 
     def connect_iopub(self, identity=None):
         """return zmq Socket connected to the IOPub channel"""
         sock = self._create_connected_socket('iopub', identity=identity)
         sock.setsockopt(zmq.SUBSCRIBE, b'')
         return sock
 
     def connect_shell(self, identity=None):
         """return zmq Socket connected to the Shell channel"""
         return self._create_connected_socket('shell', identity=identity)
 
     def connect_stdin(self, identity=None):
         """return zmq Socket connected to the StdIn channel"""
         return self._create_connected_socket('stdin', identity=identity)
 
     def connect_hb(self, identity=None):
         """return zmq Socket connected to the Heartbeat channel"""
         return self._create_connected_socket('hb', identity=identity)
 
     def connect_control(self, identity=None):
         """return zmq Socket connected to the Control channel"""
         return self._create_connected_socket('control', identity=identity)
 
 
 __all__ = [
     'write_connection_file',
     'get_connection_file',
     'find_connection_file',
     'get_connection_info',
     'connect_qtconsole',
     'tunnel_to_kernel',
 ]

jupyter_client/ioloop/manager.py

@@ -1,62 +1,62 b''
 """A kernel manager with a tornado IOLoop"""
 
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 from zmq.eventloop import ioloop
 from zmq.eventloop.zmqstream import ZMQStream
 
 from IPython.utils.traitlets import (
     Instance
 )
 
-from IPython.kernel.manager import KernelManager
+from jupyter_client.manager import KernelManager
 from .restarter import IOLoopKernelRestarter
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 
 def as_zmqstream(f):
     def wrapped(self, *args, **kwargs):
         socket = f(self, *args, **kwargs)
         return ZMQStream(socket, self.loop)
     return wrapped
 
 class IOLoopKernelManager(KernelManager):
 
     loop = Instance('zmq.eventloop.ioloop.IOLoop')
     def _loop_default(self):
         return ioloop.IOLoop.instance()
 
-    _restarter = Instance('IPython.kernel.ioloop.IOLoopKernelRestarter', allow_none=True)
+    _restarter = Instance('jupyter_client.ioloop.IOLoopKernelRestarter', allow_none=True)
 
     def start_restarter(self):
         if self.autorestart and self.has_kernel:
             if self._restarter is None:
                 self._restarter = IOLoopKernelRestarter(
                     kernel_manager=self, loop=self.loop,
                     parent=self, log=self.log
                 )
             self._restarter.start()
 
     def stop_restarter(self):
         if self.autorestart:
             if self._restarter is not None:
                 self._restarter.stop()
 
     connect_shell = as_zmqstream(KernelManager.connect_shell)
     connect_iopub = as_zmqstream(KernelManager.connect_iopub)
     connect_stdin = as_zmqstream(KernelManager.connect_stdin)
     connect_hb = as_zmqstream(KernelManager.connect_hb)

jupyter_client/ioloop/restarter.py

@@ -1,53 +1,53 b''
 """A basic in process kernel monitor with autorestarting.
 
 This watches a kernel's state using KernelManager.is_alive and auto
 restarts the kernel if it dies.
 """
 
 #-----------------------------------------------------------------------------
 #  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
 #-----------------------------------------------------------------------------
 
 from __future__ import absolute_import
 
 from zmq.eventloop import ioloop
 
 
-from IPython.kernel.restarter import KernelRestarter
+from jupyter_client.restarter import KernelRestarter
 from IPython.utils.traitlets import (
     Instance,
 )
 
 #-----------------------------------------------------------------------------
 # Code
 #-----------------------------------------------------------------------------
 
 class IOLoopKernelRestarter(KernelRestarter):
     """Monitor and autorestart a kernel."""
 
     loop = Instance('zmq.eventloop.ioloop.IOLoop')
     def _loop_default(self):
         return ioloop.IOLoop.instance()
 
     _pcallback = None
 
     def start(self):
         """Start the polling of the kernel."""
         if self._pcallback is None:
             self._pcallback = ioloop.PeriodicCallback(
                 self.poll, 1000*self.time_to_dead, self.loop
             )
             self._pcallback.start()
 
     def stop(self):
         """Stop the kernel polling."""
         if self._pcallback is not None:
             self._pcallback.stop()
             self._pcallback = None

jupyter_client/launcher.py

@@ -1,226 +1,226 b''
 """Utilities for launching kernels
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import os
 import sys
 from subprocess import Popen, PIPE
 
 from IPython.utils.encoding import getdefaultencoding
 from IPython.utils.py3compat import cast_bytes_py2
 
 
 def swallow_argv(argv, aliases=None, flags=None):
     """strip frontend-specific aliases and flags from an argument list
 
     For use primarily in frontend apps that want to pass a subset of command-line
     arguments through to a subprocess, where frontend-specific flags and aliases
     should be removed from the list.
 
     Parameters
     ----------
 
     argv : list(str)
         The starting argv, to be filtered
     aliases : container of aliases (dict, list, set, etc.)
         The frontend-specific aliases to be removed
     flags : container of flags (dict, list, set, etc.)
         The frontend-specific flags to be removed
 
     Returns
     -------
 
     argv : list(str)
         The argv list, excluding flags and aliases that have been stripped
     """
 
     if aliases is None:
         aliases = set()
     if flags is None:
         flags = set()
 
     stripped = list(argv) # copy
 
     swallow_next = False
     was_flag = False
     for a in argv:
         if a == '--':
             break
         if swallow_next:
             swallow_next = False
             # last arg was an alias, remove the next one
             # *unless* the last alias has a no-arg flag version, in which
             # case, don't swallow the next arg if it's also a flag:
             if not (was_flag and a.startswith('-')):
                 stripped.remove(a)
                 continue
         if a.startswith('-'):
             split = a.lstrip('-').split('=')
             name = split[0]
             # we use startswith because argparse accepts any arg to be specified
             # by any leading section, as long as it is unique,
             # so `--no-br` means `--no-browser` in the notebook, etc.
             if any(alias.startswith(name) for alias in aliases):
                 stripped.remove(a)
                 if len(split) == 1:
                     # alias passed with arg via space
                     swallow_next = True
                     # could have been a flag that matches an alias, e.g. `existing`
                     # in which case, we might not swallow the next arg
                     was_flag = name in flags
             elif len(split) == 1 and any(flag.startswith(name) for flag in flags):
                 # strip flag, but don't swallow next, as flags don't take args
                 stripped.remove(a)
 
     # return shortened list
     return stripped
 
 
 def make_ipkernel_cmd(mod='IPython.kernel', executable=None, extra_arguments=[], **kw):
     """Build Popen command list for launching an IPython kernel.
 
     Parameters
     ----------
     mod : str, optional (default 'IPython.kernel')
         A string of an IPython module whose __main__ starts an IPython kernel
 
     executable : str, optional (default sys.executable)
         The Python executable to use for the kernel process.
 
     extra_arguments : list, optional
         A list of extra arguments to pass when executing the launch code.
 
     Returns
     -------
 
     A Popen command list
     """
     if executable is None:
         executable = sys.executable
     arguments = [ executable, '-m', mod, '-f', '{connection_file}' ]
     arguments.extend(extra_arguments)
 
     return arguments
 
 
 def launch_kernel(cmd, stdin=None, stdout=None, stderr=None, env=None,
                         independent=False,
                         cwd=None,
                         **kw
                         ):
     """ Launches a localhost kernel, binding to the specified ports.
 
     Parameters
     ----------
     cmd : Popen list,
         A string of Python code that imports and executes a kernel entry point.
 
     stdin, stdout, stderr : optional (default None)
         Standards streams, as defined in subprocess.Popen.
 
     independent : bool, optional (default False)
         If set, the kernel process is guaranteed to survive if this process
         dies. If not set, an effort is made to ensure that the kernel is killed
         when this process dies. Note that in this case it is still good practice
         to kill kernels manually before exiting.
 
     cwd : path, optional
         The working dir of the kernel process (default: cwd of this process).
 
     Returns
     -------
 
     Popen instance for the kernel subprocess
     """
 
     # Popen will fail (sometimes with a deadlock) if stdin, stdout, and stderr
     # are invalid. Unfortunately, there is in general no way to detect whether
     # they are valid.  The following two blocks redirect them to (temporary)
     # pipes in certain important cases.
 
     # If this process has been backgrounded, our stdin is invalid. Since there
     # is no compelling reason for the kernel to inherit our stdin anyway, we'll
     # place this one safe and always redirect.
     redirect_in = True
     _stdin = PIPE if stdin is None else stdin
 
     # If this process in running on pythonw, we know that stdin, stdout, and
     # stderr are all invalid.
     redirect_out = sys.executable.endswith('pythonw.exe')
     if redirect_out:
         blackhole = open(os.devnull, 'w')
         _stdout = blackhole if stdout is None else stdout
         _stderr = blackhole if stderr is None else stderr
     else:
         _stdout, _stderr = stdout, stderr
 
     env = env if (env is not None) else os.environ.copy()
 
     encoding = getdefaultencoding(prefer_stream=False)
     kwargs = dict(
         stdin=_stdin,
         stdout=_stdout,
         stderr=_stderr,
         cwd=cwd,
         env=env,
     )
 
     # Spawn a kernel.
     if sys.platform == 'win32':
         # Popen on Python 2 on Windows cannot handle unicode args or cwd
         cmd = [ cast_bytes_py2(c, encoding) for c in cmd ]
         if cwd:
             cwd = cast_bytes_py2(cwd, sys.getfilesystemencoding() or 'ascii')
             kwargs['cwd'] = cwd
 
-        from IPython.kernel.zmq.parentpoller import ParentPollerWindows
+        from jupyter_client.parentpoller import ParentPollerWindows
         # Create a Win32 event for interrupting the kernel
         # and store it in an environment variable.
         interrupt_event = ParentPollerWindows.create_interrupt_event()
         env["JPY_INTERRUPT_EVENT"] = str(interrupt_event)
         # deprecated old env name:
         env["IPY_INTERRUPT_EVENT"] = env["JPY_INTERRUPT_EVENT"]
 
         try:
             from _winapi import DuplicateHandle, GetCurrentProcess, \
                 DUPLICATE_SAME_ACCESS, CREATE_NEW_PROCESS_GROUP
         except:
             from _subprocess import DuplicateHandle, GetCurrentProcess, \
                 DUPLICATE_SAME_ACCESS, CREATE_NEW_PROCESS_GROUP
         # Launch the kernel process
         if independent:
             kwargs['creationflags'] = CREATE_NEW_PROCESS_GROUP
         else:
             pid = GetCurrentProcess()
             handle = DuplicateHandle(pid, pid, pid, 0,
                                      True, # Inheritable by new processes.
                                      DUPLICATE_SAME_ACCESS)
             env['JPY_PARENT_PID'] = str(int(handle))
 
         proc = Popen(cmd, **kwargs)
 
         # Attach the interrupt event to the Popen objet so it can be used later.
         proc.win32_interrupt_event = interrupt_event
 
     else:
         if independent:
             kwargs['preexec_fn'] = lambda: os.setsid()
         else:
             env['JPY_PARENT_PID'] = str(os.getpid())
 
         proc = Popen(cmd, **kwargs)
 
     # Clean up pipes created to work around Popen bug.
     if redirect_in:
         if stdin is None:
             proc.stdin.close()
 
     return proc
 
 __all__ = [
     'swallow_argv',
     'make_ipkernel_cmd',
     'launch_kernel',
 ]

jupyter_client/manager.py

@@ -1,442 +1,442 b''
 """Base class to manage a running kernel"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import absolute_import
 
 from contextlib import contextmanager
 import os
 import re
 import signal
 import sys
 import time
 import warnings
 try:
     from queue import Empty  # Py 3
 except ImportError:
     from Queue import Empty  # Py 2
 
 import zmq
 
 from IPython.utils.importstring import import_item
 from IPython.utils.localinterfaces import is_local_ip, local_ips
 from IPython.utils.path import get_ipython_dir
 from IPython.utils.traitlets import (
     Any, Instance, Unicode, List, Bool, Type, DottedObjectName
 )
-from IPython.kernel import (
+from jupyter_client import (
     launch_kernel,
     kernelspec,
 )
 from .connect import ConnectionFileMixin
-from .zmq.session import Session
+from .session import Session
 from .managerabc import (
     KernelManagerABC
 )
 
 
 class KernelManager(ConnectionFileMixin):
     """Manages a single kernel in a subprocess on this host.
 
     This version starts kernels with Popen.
     """
 
     # The PyZMQ Context to use for communication with the kernel.
     context = Instance(zmq.Context)
     def _context_default(self):
         return zmq.Context.instance()
 
     # the class to create with our `client` method
-    client_class = DottedObjectName('IPython.kernel.blocking.BlockingKernelClient')
+    client_class = DottedObjectName('jupyter_client.blocking.BlockingKernelClient')
     client_factory = Type(allow_none=True)
     def _client_class_changed(self, name, old, new):
         self.client_factory = import_item(str(new))
 
     # The kernel process with which the KernelManager is communicating.
     # generally a Popen instance
     kernel = Any()
 
     kernel_spec_manager = Instance(kernelspec.KernelSpecManager)
 
     def _kernel_spec_manager_default(self):
         return kernelspec.KernelSpecManager(ipython_dir=self.ipython_dir)
 
     kernel_name = Unicode(kernelspec.NATIVE_KERNEL_NAME)
 
     kernel_spec = Instance(kernelspec.KernelSpec)
 
     def _kernel_spec_default(self):
         return self.kernel_spec_manager.get_kernel_spec(self.kernel_name)
 
     def _kernel_name_changed(self, name, old, new):
         if new == 'python':
             self.kernel_name = kernelspec.NATIVE_KERNEL_NAME
             # This triggered another run of this function, so we can exit now
             return
         self.kernel_spec = self.kernel_spec_manager.get_kernel_spec(new)
         self.ipython_kernel = new in {'python', 'python2', 'python3'}
 
     kernel_cmd = List(Unicode, config=True,
         help="""DEPRECATED: Use kernel_name instead.
 
         The Popen Command to launch the kernel.
         Override this if you have a custom kernel.
         If kernel_cmd is specified in a configuration file,
         IPython does not pass any arguments to the kernel,
         because it cannot make any assumptions about the
         arguments that the kernel understands. In particular,
         this means that the kernel does not receive the
         option --debug if it given on the IPython command line.
         """
     )
 
     def _kernel_cmd_changed(self, name, old, new):
         warnings.warn("Setting kernel_cmd is deprecated, use kernel_spec to "
                       "start different kernels.")
         self.ipython_kernel = False
 
     ipython_kernel = Bool(True)
 
     ipython_dir = Unicode()
     def _ipython_dir_default(self):
         return get_ipython_dir()
 
     # Protected traits
     _launch_args = Any()
     _control_socket = Any()
 
     _restarter = Any()
 
     autorestart = Bool(False, config=True,
         help="""Should we autorestart the kernel if it dies."""
     )
 
     def __del__(self):
         self._close_control_socket()
         self.cleanup_connection_file()
 
     #--------------------------------------------------------------------------
     # Kernel restarter
     #--------------------------------------------------------------------------
 
     def start_restarter(self):
         pass
 
     def stop_restarter(self):
         pass
 
     def add_restart_callback(self, callback, event='restart'):
         """register a callback to be called when a kernel is restarted"""
         if self._restarter is None:
             return
         self._restarter.add_callback(callback, event)
 
     def remove_restart_callback(self, callback, event='restart'):
         """unregister a callback to be called when a kernel is restarted"""
         if self._restarter is None:
             return
         self._restarter.remove_callback(callback, event)
 
     #--------------------------------------------------------------------------
     # create a Client connected to our Kernel
     #--------------------------------------------------------------------------
 
     def client(self, **kwargs):
         """Create a client configured to connect to our kernel"""
         if self.client_factory is None:
             self.client_factory = import_item(self.client_class)
 
         kw = {}
         kw.update(self.get_connection_info())
         kw.update(dict(
             connection_file=self.connection_file,
             session=self.session,
             parent=self,
         ))
 
         # add kwargs last, for manual overrides
         kw.update(kwargs)
         return self.client_factory(**kw)
 
     #--------------------------------------------------------------------------
     # Kernel management
     #--------------------------------------------------------------------------
 
     def format_kernel_cmd(self, extra_arguments=None):
         """replace templated args (e.g. {connection_file})"""
         extra_arguments = extra_arguments or []
         if self.kernel_cmd:
             cmd = self.kernel_cmd + extra_arguments
         else:
             cmd = self.kernel_spec.argv + extra_arguments
 
         ns = dict(connection_file=self.connection_file)
         ns.update(self._launch_args)
 
         pat = re.compile(r'\{([A-Za-z0-9_]+)\}')
         def from_ns(match):
             """Get the key out of ns if it's there, otherwise no change."""
             return ns.get(match.group(1), match.group())
 
         return [ pat.sub(from_ns, arg) for arg 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)
 
     # Control socket used for polite kernel shutdown
 
     def _connect_control_socket(self):
         if self._control_socket is None:
             self._control_socket = self.connect_control()
             self._control_socket.linger = 100
 
     def _close_control_socket(self):
         if self._control_socket is None:
             return
         self._control_socket.close()
         self._control_socket = None
 
     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 not is_local_ip(self.ip):
             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
         extra_arguments = kw.pop('extra_arguments', [])
         kernel_cmd = self.format_kernel_cmd(extra_arguments=extra_arguments)
         if self.kernel_cmd:
             # If kernel_cmd has been set manually, don't refer to a kernel spec
             env = os.environ
         else:
             # Environment variables from kernel spec are added to os.environ
             env = os.environ.copy()
             env.update(self.kernel_spec.env or {})
         # launch the kernel subprocess
         self.kernel = self._launch_kernel(kernel_cmd, env=env,
                                     **kw)
         self.start_restarter()
         self._connect_control_socket()
 
     def request_shutdown(self, restart=False):
         """Send a shutdown request via control channel
 
         On Windows, this just kills kernels instead, because the shutdown
         messages don't work.
         """
         content = dict(restart=restart)
         msg = self.session.msg("shutdown_request", content=content)
         self.session.send(self._control_socket, msg)
 
     def finish_shutdown(self, waittime=1, pollinterval=0.1):
         """Wait for kernel shutdown, then kill process if it doesn't shutdown.
 
         This does not send shutdown requests - use :meth:`request_shutdown`
         first.
         """
         for i in range(int(waittime/pollinterval)):
             if self.is_alive():
                 time.sleep(pollinterval)
             else:
                 break
         else:
             # OK, we've waited long enough.
             if self.has_kernel:
                 self._kill_kernel()
 
     def cleanup(self, connection_file=True):
         """Clean up resources when the kernel is shut down"""
         if connection_file:
             self.cleanup_connection_file()
 
         self.cleanup_ipc_files()
         self._close_control_socket()
 
     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.
         """
         # Stop monitoring for restarting while we shutdown.
         self.stop_restarter()
 
         if now:
             self._kill_kernel()
         else:
             self.request_shutdown(restart=restart)
             # 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.finish_shutdown()
 
         self.cleanup(connection_file=not restart)
 
     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)
 
     @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:
 
             # 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 .zmq.parentpoller import ParentPollerWindows as Poller
+                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!")
 
     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
         else:
             # we don't have a kernel
             return False
 
 
 KernelManagerABC.register(KernelManager)
 
 
 def start_new_kernel(startup_timeout=60, kernel_name='python', **kwargs):
     """Start a new kernel, and return its Manager and Client"""
     km = KernelManager(kernel_name=kernel_name)
     km.start_kernel(**kwargs)
     kc = km.client()
     kc.start_channels()
     kc.wait_for_ready()
 
     return km, kc
 
 @contextmanager
 def run_kernel(**kwargs):
     """Context manager to create a kernel in a subprocess.
 
     The kernel is shut down when the context exits.
 
     Returns
     -------
     kernel_client: connected KernelClient instance
     """
     km, kc = start_new_kernel(**kwargs)
     try:
         yield kc
     finally:
         kc.stop_channels()
         km.shutdown_kernel(now=True)

jupyter_client/managerabc.py

@@ -1,53 +1,53 b''
 """Abstract base class for kernel managers."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import abc
 
 from IPython.utils.py3compat import with_metaclass
 
 
 class KernelManagerABC(with_metaclass(abc.ABCMeta, object)):
     """KernelManager ABC.
 
     The docstrings for this class can be found in the base implementation:
 
-    `IPython.kernel.kernelmanager.KernelManager`
+    `jupyter_client.kernelmanager.KernelManager`
     """
 
     @abc.abstractproperty
     def kernel(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.abstractmethod
     def is_alive(self):
         pass

jupyter_client/multikernelmanager.py

@@ -1,319 +1,319 b''
 """A kernel manager for multiple kernels"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import absolute_import
 
 import os
 import uuid
 
 import zmq
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.utils.importstring import import_item
 from IPython.utils.traitlets import (
     Instance, Dict, List, Unicode, Any, DottedObjectName
 )
 from IPython.utils.py3compat import unicode_type
 
 from .kernelspec import NATIVE_KERNEL_NAME
 
 class DuplicateKernelError(Exception):
     pass
 
 
 def kernel_method(f):
     """decorator for proxying MKM.method(kernel_id) to individual KMs by ID"""
     def wrapped(self, kernel_id, *args, **kwargs):
         # get the kernel
         km = self.get_kernel(kernel_id)
         method = getattr(km, f.__name__)
         # call the kernel's method
         r = method(*args, **kwargs)
         # last thing, call anything defined in the actual class method
         # such as logging messages
         f(self, kernel_id, *args, **kwargs)
         # return the method result
         return r
     return wrapped
 
 
 class MultiKernelManager(LoggingConfigurable):
     """A class for managing multiple kernels."""
 
     ipython_kernel_argv = List(Unicode)
 
     default_kernel_name = Unicode(NATIVE_KERNEL_NAME, config=True,
         help="The name of the default kernel to start"
     )
 
     kernel_manager_class = DottedObjectName(
-        "IPython.kernel.ioloop.IOLoopKernelManager", config=True,
+        "jupyter_client.ioloop.IOLoopKernelManager", 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, kernel_name=None, **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_type(uuid.uuid4()))
         if kernel_id in self:
             raise DuplicateKernelError('Kernel already exists: %s' % kernel_id)
 
         if kernel_name is None:
             kernel_name = self.default_kernel_name
         # 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),
                     parent=self, autorestart=True, log=self.log, kernel_name=kernel_name,
         )
         # FIXME: remove special treatment of IPython kernels
         if km.ipython_kernel:
             kwargs.setdefault('extra_arguments', self.ipython_kernel_argv)
         km.start_kernel(**kwargs)
         self._kernels[kernel_id] = km
         return kernel_id
 
     @kernel_method
     def shutdown_kernel(self, kernel_id, now=False, restart=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.
         restart : bool
             Will the kernel be restarted?
         """
         self.log.info("Kernel shutdown: %s" % kernel_id)
         self.remove_kernel(kernel_id)
 
     @kernel_method
     def request_shutdown(self, kernel_id, restart=False):
         """Ask a kernel to shut down by its kernel uuid"""
 
     @kernel_method
     def finish_shutdown(self, kernel_id, waittime=1, pollinterval=0.1):
         """Wait for a kernel to finish shutting down, and kill it if it doesn't
         """
         self.log.info("Kernel shutdown: %s" % kernel_id)
 
     @kernel_method
     def cleanup(self, kernel_id, connection_file=True):
         """Clean up a kernel's resources"""
 
     def remove_kernel(self, kernel_id):
         """remove a kernel from our mapping.
 
         Mainly so that a kernel can be removed if it is already dead,
         without having to call shutdown_kernel.
 
         The kernel object is returned.
         """
         return self._kernels.pop(kernel_id)
 
     def shutdown_all(self, now=False):
         """Shutdown all kernels."""
         kids = self.list_kernel_ids()
         for kid in kids:
             self.request_shutdown(kid)
         for kid in kids:
             self.finish_shutdown(kid)
             self.cleanup(kid)
             self.remove_kernel(kid)
 
     @kernel_method
     def interrupt_kernel(self, kernel_id):
         """Interrupt (SIGINT) the kernel by its uuid.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         self.log.info("Kernel interrupted: %s" % kernel_id)
 
     @kernel_method
     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.
         """
         self.log.info("Signaled Kernel %s with %s" % (kernel_id, signum))
 
     @kernel_method
     def restart_kernel(self, kernel_id, now=False):
         """Restart a kernel by its uuid, keeping the same ports.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel to interrupt.
         """
         self.log.info("Kernel restarted: %s" % kernel_id)
 
     @kernel_method
     def is_alive(self, kernel_id):
         """Is the kernel alive.
 
         This calls KernelManager.is_alive() which calls Popen.poll on the
         actual kernel subprocess.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel.
         """
 
     def _check_kernel_id(self, kernel_id):
         """check that a kernel id is valid"""
         if kernel_id not in self:
             raise KeyError("Kernel with id not found: %s" % kernel_id)
 
     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.
         """
         self._check_kernel_id(kernel_id)
         return self._kernels[kernel_id]
 
     @kernel_method
     def add_restart_callback(self, kernel_id, callback, event='restart'):
         """add a callback for the KernelRestarter"""
 
     @kernel_method
     def remove_restart_callback(self, kernel_id, callback, event='restart'):
         """remove a callback for the KernelRestarter"""
 
     @kernel_method
     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).
         """
 
     @kernel_method
     def connect_iopub(self, kernel_id, identity=None):
         """Return a zmq Socket connected to the iopub channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel
         identity : bytes (optional)
             The zmq identity of the socket
 
         Returns
         =======
         stream : zmq Socket or ZMQStream
         """
 
     @kernel_method
     def connect_shell(self, kernel_id, identity=None):
         """Return a zmq Socket connected to the shell channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel
         identity : bytes (optional)
             The zmq identity of the socket
 
         Returns
         =======
         stream : zmq Socket or ZMQStream
         """
 
     @kernel_method
     def connect_stdin(self, kernel_id, identity=None):
         """Return a zmq Socket connected to the stdin channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel
         identity : bytes (optional)
             The zmq identity of the socket
 
         Returns
         =======
         stream : zmq Socket or ZMQStream
         """
 
     @kernel_method
     def connect_hb(self, kernel_id, identity=None):
         """Return a zmq Socket connected to the hb channel.
 
         Parameters
         ==========
         kernel_id : uuid
             The id of the kernel
         identity : bytes (optional)
             The zmq identity of the socket
 
         Returns
         =======
         stream : zmq Socket or ZMQStream
         """

jupyter_client/restarter.py

@@ -1,111 +1,111 b''
 """A basic kernel monitor with autorestarting.
 
 This watches a kernel's state using KernelManager.is_alive and auto
 restarts the kernel if it dies.
 
 It is an incomplete base class, and must be subclassed.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from IPython.config.configurable import LoggingConfigurable
 from IPython.utils.traitlets import (
     Instance, Float, Dict, Bool, Integer,
 )
 
 
 class KernelRestarter(LoggingConfigurable):
     """Monitor and autorestart a kernel."""
 
-    kernel_manager = Instance('IPython.kernel.KernelManager')
+    kernel_manager = Instance('jupyter_client.KernelManager')
 
     debug = Bool(False, config=True,
         help="""Whether to include every poll event in debugging output.
 
         Has to be set explicitly, because there will be *a lot* of output.
         """
     )
 
     time_to_dead = Float(3.0, config=True,
         help="""Kernel heartbeat interval in seconds."""
     )
 
     restart_limit = Integer(5, config=True,
         help="""The number of consecutive autorestarts before the kernel is presumed dead."""
     )
     _restarting = Bool(False)
     _restart_count = Integer(0)
 
     callbacks = Dict()
     def _callbacks_default(self):
         return dict(restart=[], dead=[])
 
     def start(self):
         """Start the polling of the kernel."""
         raise NotImplementedError("Must be implemented in a subclass")
 
     def stop(self):
         """Stop the kernel polling."""
         raise NotImplementedError("Must be implemented in a subclass")
 
     def add_callback(self, f, event='restart'):
         """register a callback to fire on a particular event
 
         Possible values for event:
 
           'restart' (default): kernel has died, and will be restarted.
           'dead': restart has failed, kernel will be left dead.
 
         """
         self.callbacks[event].append(f)
 
     def remove_callback(self, f, event='restart'):
         """unregister a callback to fire on a particular event
 
         Possible values for event:
 
           'restart' (default): kernel has died, and will be restarted.
           'dead': restart has failed, kernel will be left dead.
 
         """
         try:
             self.callbacks[event].remove(f)
         except ValueError:
             pass
 
     def _fire_callbacks(self, event):
         """fire our callbacks for a particular event"""
         for callback in self.callbacks[event]:
             try:
                 callback()
             except Exception as e:
                 self.log.error("KernelRestarter: %s callback %r failed", event, callback, exc_info=True)
 
     def poll(self):
         if self.debug:
             self.log.debug('Polling kernel...')
         if not self.kernel_manager.is_alive():
             if self._restarting:
                 self._restart_count += 1
             else:
                 self._restart_count = 1
 
             if self._restart_count >= self.restart_limit:
                 self.log.warn("KernelRestarter: restart failed")
                 self._fire_callbacks('dead')
                 self._restarting = False
                 self._restart_count = 0
                 self.stop()
             else:
                 self.log.info('KernelRestarter: restarting kernel (%i/%i)',
                     self._restart_count,
                     self.restart_limit
                 )
                 self._fire_callbacks('restart')
                 self.kernel_manager.restart_kernel(now=True)
                 self._restarting = True
         else:
             if self._restarting:
                 self.log.debug("KernelRestarter: restart apparently succeeded")
             self._restarting = False

jupyter_client/session.py

@@ -1,881 +1,881 b''
 """Session object for building, serializing, sending, and receiving messages in
 IPython. The Session object supports serialization, HMAC signatures, and
 metadata on messages.
 
 Also defined here are utilities for working with Sessions:
 * A SessionFactory to be used as a base class for configurables that work with
 Sessions.
 * A Message object for convenience that allows attribute-access to the msg dict.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import hashlib
 import hmac
 import logging
 import os
 import pprint
 import random
 import uuid
 import warnings
 from datetime import datetime
 
 try:
     import cPickle
     pickle = cPickle
 except:
     cPickle = None
     import pickle
 
 try:
     # We are using compare_digest to limit the surface of timing attacks
     from hmac import compare_digest
 except ImportError:
     # Python < 2.7.7: When digests don't match no feedback is provided,
     # limiting the surface of attack
     def compare_digest(a,b): return a == b
 
 import zmq
 from zmq.utils import jsonapi
 from zmq.eventloop.ioloop import IOLoop
 from zmq.eventloop.zmqstream import ZMQStream
 
 from IPython.core.release import kernel_protocol_version
 from IPython.config.configurable import Configurable, LoggingConfigurable
 from IPython.utils import io
 from IPython.utils.importstring import import_item
 from IPython.utils.jsonutil import extract_dates, squash_dates, date_default
 from IPython.utils.py3compat import (str_to_bytes, str_to_unicode, unicode_type,
                                      iteritems)
 from IPython.utils.traitlets import (CBytes, Unicode, Bool, Any, Instance, Set,
                                         DottedObjectName, CUnicode, Dict, Integer,
                                         TraitError,
 )
 from IPython.utils.pickleutil import PICKLE_PROTOCOL
-from IPython.kernel.adapter import adapt
 from IPython.kernel.zmq.serialize import MAX_ITEMS, MAX_BYTES
+from jupyter_client.adapter import adapt
 
 #-----------------------------------------------------------------------------
 # utility functions
 #-----------------------------------------------------------------------------
 
 def squash_unicode(obj):
     """coerce unicode back to bytestrings."""
     if isinstance(obj,dict):
         for key in obj.keys():
             obj[key] = squash_unicode(obj[key])
             if isinstance(key, unicode_type):
                 obj[squash_unicode(key)] = obj.pop(key)
     elif isinstance(obj, list):
         for i,v in enumerate(obj):
             obj[i] = squash_unicode(v)
     elif isinstance(obj, unicode_type):
         obj = obj.encode('utf8')
     return obj
 
 #-----------------------------------------------------------------------------
 # globals and defaults
 #-----------------------------------------------------------------------------
 
 # ISO8601-ify datetime objects
 # allow unicode
 # disallow nan, because it's not actually valid JSON
 json_packer = lambda obj: jsonapi.dumps(obj, default=date_default,
     ensure_ascii=False, allow_nan=False,
 )
 json_unpacker = lambda s: jsonapi.loads(s)
 
 pickle_packer = lambda o: pickle.dumps(squash_dates(o), PICKLE_PROTOCOL)
 pickle_unpacker = pickle.loads
 
 default_packer = json_packer
 default_unpacker = json_unpacker
 
 DELIM = b"<IDS|MSG>"
 # singleton dummy tracker, which will always report as done
 DONE = zmq.MessageTracker()
 
 #-----------------------------------------------------------------------------
 # Mixin tools for apps that use Sessions
 #-----------------------------------------------------------------------------
 
 session_aliases = dict(
     ident = 'Session.session',
     user = 'Session.username',
     keyfile = 'Session.keyfile',
 )
 
 session_flags  = {
     'secure' : ({'Session' : { 'key' : str_to_bytes(str(uuid.uuid4())),
                             'keyfile' : '' }},
         """Use HMAC digests for authentication of messages.
         Setting this flag will generate a new UUID to use as the HMAC key.
         """),
     'no-secure' : ({'Session' : { 'key' : b'', 'keyfile' : '' }},
         """Don't authenticate messages."""),
 }
 
 def default_secure(cfg):
     """Set the default behavior for a config environment to be secure.
 
     If Session.key/keyfile have not been set, set Session.key to
     a new random UUID.
     """
     warnings.warn("default_secure is deprecated", DeprecationWarning)
     if 'Session' in cfg:
         if 'key' in cfg.Session or 'keyfile' in cfg.Session:
             return
     # key/keyfile not specified, generate new UUID:
     cfg.Session.key = str_to_bytes(str(uuid.uuid4()))
 
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SessionFactory(LoggingConfigurable):
     """The Base class for configurables that have a Session, Context, logger,
     and IOLoop.
     """
 
     logname = Unicode('')
     def _logname_changed(self, name, old, new):
         self.log = logging.getLogger(new)
 
     # not configurable:
     context = Instance('zmq.Context')
     def _context_default(self):
         return zmq.Context.instance()
 
-    session = Instance('IPython.kernel.zmq.session.Session',
+    session = Instance('jupyter_client.session.Session',
                        allow_none=True)
 
     loop = Instance('zmq.eventloop.ioloop.IOLoop')
     def _loop_default(self):
         return IOLoop.instance()
 
     def __init__(self, **kwargs):
         super(SessionFactory, self).__init__(**kwargs)
 
         if self.session is None:
             # construct the session
             self.session = Session(**kwargs)
 
 
 class Message(object):
     """A simple message object that maps dict keys to attributes.
 
     A Message can be created from a dict and a dict from a Message instance
     simply by calling dict(msg_obj)."""
 
     def __init__(self, msg_dict):
         dct = self.__dict__
         for k, v in iteritems(dict(msg_dict)):
             if isinstance(v, dict):
                 v = Message(v)
             dct[k] = v
 
     # Having this iterator lets dict(msg_obj) work out of the box.
     def __iter__(self):
         return iter(iteritems(self.__dict__))
 
     def __repr__(self):
         return repr(self.__dict__)
 
     def __str__(self):
         return pprint.pformat(self.__dict__)
 
     def __contains__(self, k):
         return k in self.__dict__
 
     def __getitem__(self, k):
         return self.__dict__[k]
 
 
 def msg_header(msg_id, msg_type, username, session):
     date = datetime.now()
     version = kernel_protocol_version
     return locals()
 
 def extract_header(msg_or_header):
     """Given a message or header, return the header."""
     if not msg_or_header:
         return {}
     try:
         # See if msg_or_header is the entire message.
         h = msg_or_header['header']
     except KeyError:
         try:
             # See if msg_or_header is just the header
             h = msg_or_header['msg_id']
         except KeyError:
             raise
         else:
             h = msg_or_header
     if not isinstance(h, dict):
         h = dict(h)
     return h
 
 class Session(Configurable):
     """Object for handling serialization and sending of messages.
 
     The Session object handles building messages and sending them
     with ZMQ sockets or ZMQStream objects.  Objects can communicate with each
     other over the network via Session objects, and only need to work with the
     dict-based IPython message spec. The Session will handle
     serialization/deserialization, security, and metadata.
 
     Sessions support configurable serialization via packer/unpacker traits,
     and signing with HMAC digests via the key/keyfile traits.
 
     Parameters
     ----------
 
     debug : bool
         whether to trigger extra debugging statements
     packer/unpacker : str : 'json', 'pickle' or import_string
         importstrings for methods to serialize message parts.  If just
         'json' or 'pickle', predefined JSON and pickle packers will be used.
         Otherwise, the entire importstring must be used.
 
         The functions must accept at least valid JSON input, and output *bytes*.
 
         For example, to use msgpack:
         packer = 'msgpack.packb', unpacker='msgpack.unpackb'
     pack/unpack : callables
         You can also set the pack/unpack callables for serialization directly.
     session : bytes
         the ID of this Session object.  The default is to generate a new UUID.
     username : unicode
         username added to message headers.  The default is to ask the OS.
     key : bytes
         The key used to initialize an HMAC signature.  If unset, messages
         will not be signed or checked.
     keyfile : filepath
         The file containing a key.  If this is set, `key` will be initialized
         to the contents of the file.
 
     """
 
     debug=Bool(False, config=True, help="""Debug output in the Session""")
 
     packer = DottedObjectName('json',config=True,
             help="""The name of the packer for serializing messages.
             Should be one of 'json', 'pickle', or an import name
             for a custom callable serializer.""")
     def _packer_changed(self, name, old, new):
         if new.lower() == 'json':
             self.pack = json_packer
             self.unpack = json_unpacker
             self.unpacker = new
         elif new.lower() == 'pickle':
             self.pack = pickle_packer
             self.unpack = pickle_unpacker
             self.unpacker = new
         else:
             self.pack = import_item(str(new))
 
     unpacker = DottedObjectName('json', config=True,
         help="""The name of the unpacker for unserializing messages.
         Only used with custom functions for `packer`.""")
     def _unpacker_changed(self, name, old, new):
         if new.lower() == 'json':
             self.pack = json_packer
             self.unpack = json_unpacker
             self.packer = new
         elif new.lower() == 'pickle':
             self.pack = pickle_packer
             self.unpack = pickle_unpacker
             self.packer = new
         else:
             self.unpack = import_item(str(new))
 
     session = CUnicode(u'', config=True,
         help="""The UUID identifying this session.""")
     def _session_default(self):
         u = unicode_type(uuid.uuid4())
         self.bsession = u.encode('ascii')
         return u
 
     def _session_changed(self, name, old, new):
         self.bsession = self.session.encode('ascii')
 
     # bsession is the session as bytes
     bsession = CBytes(b'')
 
     username = Unicode(str_to_unicode(os.environ.get('USER', 'username')),
         help="""Username for the Session. Default is your system username.""",
         config=True)
 
     metadata = Dict({}, config=True,
         help="""Metadata dictionary, which serves as the default top-level metadata dict for each message.""")
 
     # if 0, no adapting to do.
     adapt_version = Integer(0)
 
     # message signature related traits:
 
     key = CBytes(config=True,
         help="""execution key, for signing messages.""")
     def _key_default(self):
         return str_to_bytes(str(uuid.uuid4()))
 
     def _key_changed(self):
         self._new_auth()
 
     signature_scheme = Unicode('hmac-sha256', config=True,
         help="""The digest scheme used to construct the message signatures.
         Must have the form 'hmac-HASH'.""")
     def _signature_scheme_changed(self, name, old, new):
         if not new.startswith('hmac-'):
             raise TraitError("signature_scheme must start with 'hmac-', got %r" % new)
         hash_name = new.split('-', 1)[1]
         try:
             self.digest_mod = getattr(hashlib, hash_name)
         except AttributeError:
             raise TraitError("hashlib has no such attribute: %s" % hash_name)
         self._new_auth()
 
     digest_mod = Any()
     def _digest_mod_default(self):
         return hashlib.sha256
     
     auth = Instance(hmac.HMAC, allow_none=True)
     
     def _new_auth(self):
         if self.key:
             self.auth = hmac.HMAC(self.key, digestmod=self.digest_mod)
         else:
             self.auth = None
 
     digest_history = Set()
     digest_history_size = Integer(2**16, config=True,
         help="""The maximum number of digests to remember.
 
         The digest history will be culled when it exceeds this value.
         """
     )
 
     keyfile = Unicode('', config=True,
         help="""path to file containing execution key.""")
     def _keyfile_changed(self, name, old, new):
         with open(new, 'rb') as f:
             self.key = f.read().strip()
 
     # for protecting against sends from forks
     pid = Integer()
 
     # serialization traits:
 
     pack = Any(default_packer) # the actual packer function
     def _pack_changed(self, name, old, new):
         if not callable(new):
             raise TypeError("packer must be callable, not %s"%type(new))
 
     unpack = Any(default_unpacker) # the actual packer function
     def _unpack_changed(self, name, old, new):
         # unpacker is not checked - it is assumed to be
         if not callable(new):
             raise TypeError("unpacker must be callable, not %s"%type(new))
 
     # thresholds:
     copy_threshold = Integer(2**16, config=True,
         help="Threshold (in bytes) beyond which a buffer should be sent without copying.")
     buffer_threshold = Integer(MAX_BYTES, config=True,
         help="Threshold (in bytes) beyond which an object's buffer should be extracted to avoid pickling.")
     item_threshold = Integer(MAX_ITEMS, config=True,
         help="""The maximum number of items for a container to be introspected for custom serialization.
         Containers larger than this are pickled outright.
         """
     )
 
 
     def __init__(self, **kwargs):
         """create a Session object
 
         Parameters
         ----------
 
         debug : bool
             whether to trigger extra debugging statements
         packer/unpacker : str : 'json', 'pickle' or import_string
             importstrings for methods to serialize message parts.  If just
             'json' or 'pickle', predefined JSON and pickle packers will be used.
             Otherwise, the entire importstring must be used.
 
             The functions must accept at least valid JSON input, and output
             *bytes*.
 
             For example, to use msgpack:
             packer = 'msgpack.packb', unpacker='msgpack.unpackb'
         pack/unpack : callables
             You can also set the pack/unpack callables for serialization
             directly.
         session : unicode (must be ascii)
             the ID of this Session object.  The default is to generate a new
             UUID.
         bsession : bytes
             The session as bytes
         username : unicode
             username added to message headers.  The default is to ask the OS.
         key : bytes
             The key used to initialize an HMAC signature.  If unset, messages
             will not be signed or checked.
         signature_scheme : str
             The message digest scheme. Currently must be of the form 'hmac-HASH',
             where 'HASH' is a hashing function available in Python's hashlib.
             The default is 'hmac-sha256'.
             This is ignored if 'key' is empty.
         keyfile : filepath
             The file containing a key.  If this is set, `key` will be
             initialized to the contents of the file.
         """
         super(Session, self).__init__(**kwargs)
         self._check_packers()
         self.none = self.pack({})
         # ensure self._session_default() if necessary, so bsession is defined:
         self.session
         self.pid = os.getpid()
         self._new_auth()
 
     @property
     def msg_id(self):
         """always return new uuid"""
         return str(uuid.uuid4())
 
     def _check_packers(self):
         """check packers for datetime support."""
         pack = self.pack
         unpack = self.unpack
 
         # check simple serialization
         msg = dict(a=[1,'hi'])
         try:
             packed = pack(msg)
         except Exception as e:
             msg = "packer '{packer}' could not serialize a simple message: {e}{jsonmsg}"
             if self.packer == 'json':
                 jsonmsg = "\nzmq.utils.jsonapi.jsonmod = %s" % jsonapi.jsonmod
             else:
                 jsonmsg = ""
             raise ValueError(
                 msg.format(packer=self.packer, e=e, jsonmsg=jsonmsg)
             )
 
         # ensure packed message is bytes
         if not isinstance(packed, bytes):
             raise ValueError("message packed to %r, but bytes are required"%type(packed))
 
         # check that unpack is pack's inverse
         try:
             unpacked = unpack(packed)
             assert unpacked == msg
         except Exception as e:
             msg = "unpacker '{unpacker}' could not handle output from packer '{packer}': {e}{jsonmsg}"
             if self.packer == 'json':
                 jsonmsg = "\nzmq.utils.jsonapi.jsonmod = %s" % jsonapi.jsonmod
             else:
                 jsonmsg = ""
             raise ValueError(
                 msg.format(packer=self.packer, unpacker=self.unpacker, e=e, jsonmsg=jsonmsg)
             )
 
         # check datetime support
         msg = dict(t=datetime.now())
         try:
             unpacked = unpack(pack(msg))
             if isinstance(unpacked['t'], datetime):
                 raise ValueError("Shouldn't deserialize to datetime")
         except Exception:
             self.pack = lambda o: pack(squash_dates(o))
             self.unpack = lambda s: unpack(s)
 
     def msg_header(self, msg_type):
         return msg_header(self.msg_id, msg_type, self.username, self.session)
 
     def msg(self, msg_type, content=None, parent=None, header=None, metadata=None):
         """Return the nested message dict.
 
         This format is different from what is sent over the wire. The
         serialize/deserialize methods converts this nested message dict to the wire
         format, which is a list of message parts.
         """
         msg = {}
         header = self.msg_header(msg_type) if header is None else header
         msg['header'] = header
         msg['msg_id'] = header['msg_id']
         msg['msg_type'] = header['msg_type']
         msg['parent_header'] = {} if parent is None else extract_header(parent)
         msg['content'] = {} if content is None else content
         msg['metadata'] = self.metadata.copy()
         if metadata is not None:
             msg['metadata'].update(metadata)
         return msg
 
     def sign(self, msg_list):
         """Sign a message with HMAC digest. If no auth, return b''.
 
         Parameters
         ----------
         msg_list : list
             The [p_header,p_parent,p_content] part of the message list.
         """
         if self.auth is None:
             return b''
         h = self.auth.copy()
         for m in msg_list:
             h.update(m)
         return str_to_bytes(h.hexdigest())
 
     def serialize(self, msg, ident=None):
         """Serialize the message components to bytes.
 
         This is roughly the inverse of deserialize. The serialize/deserialize
         methods work with full message lists, whereas pack/unpack work with
         the individual message parts in the message list.
 
         Parameters
         ----------
         msg : dict or Message
             The next message dict as returned by the self.msg method.
 
         Returns
         -------
         msg_list : list
             The list of bytes objects to be sent with the format::
 
                 [ident1, ident2, ..., DELIM, HMAC, p_header, p_parent,
                  p_metadata, p_content, buffer1, buffer2, ...]
 
             In this list, the ``p_*`` entities are the packed or serialized
             versions, so if JSON is used, these are utf8 encoded JSON strings.
         """
         content = msg.get('content', {})
         if content is None:
             content = self.none
         elif isinstance(content, dict):
             content = self.pack(content)
         elif isinstance(content, bytes):
             # content is already packed, as in a relayed message
             pass
         elif isinstance(content, unicode_type):
             # should be bytes, but JSON often spits out unicode
             content = content.encode('utf8')
         else:
             raise TypeError("Content incorrect type: %s"%type(content))
 
         real_message = [self.pack(msg['header']),
                         self.pack(msg['parent_header']),
                         self.pack(msg['metadata']),
                         content,
         ]
 
         to_send = []
 
         if isinstance(ident, list):
             # accept list of idents
             to_send.extend(ident)
         elif ident is not None:
             to_send.append(ident)
         to_send.append(DELIM)
 
         signature = self.sign(real_message)
         to_send.append(signature)
 
         to_send.extend(real_message)
 
         return to_send
 
     def send(self, stream, msg_or_type, content=None, parent=None, ident=None,
              buffers=None, track=False, header=None, metadata=None):
         """Build and send a message via stream or socket.
 
         The message format used by this function internally is as follows:
 
         [ident1,ident2,...,DELIM,HMAC,p_header,p_parent,p_content,
          buffer1,buffer2,...]
 
         The serialize/deserialize methods convert the nested message dict into this
         format.
 
         Parameters
         ----------
 
         stream : zmq.Socket or ZMQStream
             The socket-like object used to send the data.
         msg_or_type : str or Message/dict
             Normally, msg_or_type will be a msg_type unless a message is being
             sent more than once. If a header is supplied, this can be set to
             None and the msg_type will be pulled from the header.
 
         content : dict or None
             The content of the message (ignored if msg_or_type is a message).
         header : dict or None
             The header dict for the message (ignored if msg_to_type is a message).
         parent : Message or dict or None
             The parent or parent header describing the parent of this message
             (ignored if msg_or_type is a message).
         ident : bytes or list of bytes
             The zmq.IDENTITY routing path.
         metadata : dict or None
             The metadata describing the message
         buffers : list or None
             The already-serialized buffers to be appended to the message.
         track : bool
             Whether to track.  Only for use with Sockets, because ZMQStream
             objects cannot track messages.
 
 
         Returns
         -------
         msg : dict
             The constructed message.
         """
         if not isinstance(stream, zmq.Socket):
             # ZMQStreams and dummy sockets do not support tracking.
             track = False
 
         if isinstance(msg_or_type, (Message, dict)):
             # We got a Message or message dict, not a msg_type so don't
             # build a new Message.
             msg = msg_or_type
             buffers = buffers or msg.get('buffers', [])
         else:
             msg = self.msg(msg_or_type, content=content, parent=parent,
                            header=header, metadata=metadata)
         if not os.getpid() == self.pid:
             io.rprint("WARNING: attempted to send message from fork")
             io.rprint(msg)
             return
         buffers = [] if buffers is None else buffers
         if self.adapt_version:
             msg = adapt(msg, self.adapt_version)
         to_send = self.serialize(msg, ident)
         to_send.extend(buffers)
         longest = max([ len(s) for s in to_send ])
         copy = (longest < self.copy_threshold)
 
         if buffers and track and not copy:
             # only really track when we are doing zero-copy buffers
             tracker = stream.send_multipart(to_send, copy=False, track=True)
         else:
             # use dummy tracker, which will be done immediately
             tracker = DONE
             stream.send_multipart(to_send, copy=copy)
 
         if self.debug:
             pprint.pprint(msg)
             pprint.pprint(to_send)
             pprint.pprint(buffers)
 
         msg['tracker'] = tracker
 
         return msg
 
     def send_raw(self, stream, msg_list, flags=0, copy=True, ident=None):
         """Send a raw message via ident path.
 
         This method is used to send a already serialized message.
 
         Parameters
         ----------
         stream : ZMQStream or Socket
             The ZMQ stream or socket to use for sending the message.
         msg_list : list
             The serialized list of messages to send. This only includes the
             [p_header,p_parent,p_metadata,p_content,buffer1,buffer2,...] portion of
             the message.
         ident : ident or list
             A single ident or a list of idents to use in sending.
         """
         to_send = []
         if isinstance(ident, bytes):
             ident = [ident]
         if ident is not None:
             to_send.extend(ident)
 
         to_send.append(DELIM)
         to_send.append(self.sign(msg_list))
         to_send.extend(msg_list)
         stream.send_multipart(to_send, flags, copy=copy)
 
     def recv(self, socket, mode=zmq.NOBLOCK, content=True, copy=True):
         """Receive and unpack a message.
 
         Parameters
         ----------
         socket : ZMQStream or Socket
             The socket or stream to use in receiving.
 
         Returns
         -------
         [idents], msg
             [idents] is a list of idents and msg is a nested message dict of
             same format as self.msg returns.
         """
         if isinstance(socket, ZMQStream):
             socket = socket.socket
         try:
             msg_list = socket.recv_multipart(mode, copy=copy)
         except zmq.ZMQError as e:
             if e.errno == zmq.EAGAIN:
                 # We can convert EAGAIN to None as we know in this case
                 # recv_multipart won't return None.
                 return None,None
             else:
                 raise
         # split multipart message into identity list and message dict
         # invalid large messages can cause very expensive string comparisons
         idents, msg_list = self.feed_identities(msg_list, copy)
         try:
             return idents, self.deserialize(msg_list, content=content, copy=copy)
         except Exception as e:
             # TODO: handle it
             raise e
 
     def feed_identities(self, msg_list, copy=True):
         """Split the identities from the rest of the message.
 
         Feed until DELIM is reached, then return the prefix as idents and
         remainder as msg_list. This is easily broken by setting an IDENT to DELIM,
         but that would be silly.
 
         Parameters
         ----------
         msg_list : a list of Message or bytes objects
             The message to be split.
         copy : bool
             flag determining whether the arguments are bytes or Messages
 
         Returns
         -------
         (idents, msg_list) : two lists
             idents will always be a list of bytes, each of which is a ZMQ
             identity. msg_list will be a list of bytes or zmq.Messages of the
             form [HMAC,p_header,p_parent,p_content,buffer1,buffer2,...] and
             should be unpackable/unserializable via self.deserialize at this
             point.
         """
         if copy:
             idx = msg_list.index(DELIM)
             return msg_list[:idx], msg_list[idx+1:]
         else:
             failed = True
             for idx,m in enumerate(msg_list):
                 if m.bytes == DELIM:
                     failed = False
                     break
             if failed:
                 raise ValueError("DELIM not in msg_list")
             idents, msg_list = msg_list[:idx], msg_list[idx+1:]
             return [m.bytes for m in idents], msg_list
 
     def _add_digest(self, signature):
         """add a digest to history to protect against replay attacks"""
         if self.digest_history_size == 0:
             # no history, never add digests
             return
 
         self.digest_history.add(signature)
         if len(self.digest_history) > self.digest_history_size:
             # threshold reached, cull 10%
             self._cull_digest_history()
 
     def _cull_digest_history(self):
         """cull the digest history
 
         Removes a randomly selected 10% of the digest history
         """
         current = len(self.digest_history)
         n_to_cull = max(int(current // 10), current - self.digest_history_size)
         if n_to_cull >= current:
             self.digest_history = set()
             return
         to_cull = random.sample(self.digest_history, n_to_cull)
         self.digest_history.difference_update(to_cull)
 
     def deserialize(self, msg_list, content=True, copy=True):
         """Unserialize a msg_list to a nested message dict.
 
         This is roughly the inverse of serialize. The serialize/deserialize
         methods work with full message lists, whereas pack/unpack work with
         the individual message parts in the message list.
 
         Parameters
         ----------
         msg_list : list of bytes or Message objects
             The list of message parts of the form [HMAC,p_header,p_parent,
             p_metadata,p_content,buffer1,buffer2,...].
         content : bool (True)
             Whether to unpack the content dict (True), or leave it packed
             (False).
         copy : bool (True)
             Whether msg_list contains bytes (True) or the non-copying Message
             objects in each place (False).
 
         Returns
         -------
         msg : dict
             The nested message dict with top-level keys [header, parent_header,
             content, buffers].  The buffers are returned as memoryviews.
         """
         minlen = 5
         message = {}
         if not copy:
             # pyzmq didn't copy the first parts of the message, so we'll do it
             for i in range(minlen):
                 msg_list[i] = msg_list[i].bytes
         if self.auth is not None:
             signature = msg_list[0]
             if not signature:
                 raise ValueError("Unsigned Message")
             if signature in self.digest_history:
                 raise ValueError("Duplicate Signature: %r" % signature)
             self._add_digest(signature)
             check = self.sign(msg_list[1:5])
             if not compare_digest(signature, check):
                 raise ValueError("Invalid Signature: %r" % signature)
         if not len(msg_list) >= minlen:
             raise TypeError("malformed message, must have at least %i elements"%minlen)
         header = self.unpack(msg_list[1])
         message['header'] = extract_dates(header)
         message['msg_id'] = header['msg_id']
         message['msg_type'] = header['msg_type']
         message['parent_header'] = extract_dates(self.unpack(msg_list[2]))
         message['metadata'] = self.unpack(msg_list[3])
         if content:
             message['content'] = self.unpack(msg_list[4])
         else:
             message['content'] = msg_list[4]
         buffers = [memoryview(b) for b in msg_list[5:]]
         if buffers and buffers[0].shape is None:
             # force copy to workaround pyzmq #646
             buffers = [memoryview(b.bytes) for b in msg_list[5:]]
         message['buffers'] = buffers
         # adapt to the current version
         return adapt(message)
 
     def unserialize(self, *args, **kwargs):
         warnings.warn(
             "Session.unserialize is deprecated. Use Session.deserialize.",
             DeprecationWarning,
         )
         return self.deserialize(*args, **kwargs)
 
 
 def test_msg2obj():
     am = dict(x=1)
     ao = Message(am)
     assert ao.x == am['x']
 
     am['y'] = dict(z=1)
     ao = Message(am)
     assert ao.y.z == am['y']['z']
 
     k1, k2 = 'y', 'z'
     assert ao[k1][k2] == am[k1][k2]
 
     am2 = dict(ao)
     assert am['x'] == am2['x']
     assert am['y']['z'] == am2['y']['z']

jupyter_client/tests/test_adapter.py

@@ -1,375 +1,375 b''
 """Tests for adapting IPython msg spec versions"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import copy
 import json
 from unittest import TestCase
 import nose.tools as nt
 
-from IPython.kernel.adapter import adapt, V4toV5, V5toV4, code_to_line
-from IPython.kernel.zmq.session import Session
+from jupyter_client.adapter import adapt, V4toV5, V5toV4, code_to_line
+from jupyter_client.session import Session
 
 
 def test_default_version():
     s = Session()
     msg = s.msg("msg_type")
     msg['header'].pop('version')
     original = copy.deepcopy(msg)
     adapted = adapt(original)
     nt.assert_equal(adapted['header']['version'], V4toV5.version)
 
 def test_code_to_line_no_code():
     line, pos = code_to_line("", 0)
     nt.assert_equal(line, "")
     nt.assert_equal(pos, 0)
 
 class AdapterTest(TestCase):
 
     def setUp(self):
         self.session = Session()
 
     def adapt(self, msg, version=None):
         original = copy.deepcopy(msg)
         adapted = adapt(msg, version or self.to_version)
         return original, adapted
 
     def check_header(self, msg):
         pass
 
 
 class V4toV5TestCase(AdapterTest):
     from_version = 4
     to_version = 5
 
     def msg(self, msg_type, content):
         """Create a v4 msg (same as v5, minus version header)"""
         msg = self.session.msg(msg_type, content)
         msg['header'].pop('version')
         return msg
 
     def test_same_version(self):
         msg = self.msg("execute_result",
             content={'status' : 'ok'}
         )
         original, adapted = self.adapt(msg, self.from_version)
 
         self.assertEqual(original, adapted)
 
     def test_no_adapt(self):
         msg = self.msg("input_reply", {'value' : 'some text'})
         v4, v5 = self.adapt(msg)
         self.assertEqual(v5['header']['version'], V4toV5.version)
         v5['header'].pop('version')
         self.assertEqual(v4, v5)
 
     def test_rename_type(self):
         for v5_type, v4_type in [
                 ('execute_result', 'pyout'),
                 ('execute_input', 'pyin'),
                 ('error', 'pyerr'),
             ]:
             msg = self.msg(v4_type, {'key' : 'value'})
             v4, v5 = self.adapt(msg)
             self.assertEqual(v5['header']['version'], V4toV5.version)
             self.assertEqual(v5['header']['msg_type'], v5_type)
             self.assertEqual(v4['content'], v5['content'])
 
     def test_execute_request(self):
         msg = self.msg("execute_request", {
             'code' : 'a=5',
             'silent' : False,
             'user_expressions' : {'a' : 'apple'},
             'user_variables' : ['b'],
         })
         v4, v5 = self.adapt(msg)
         self.assertEqual(v4['header']['msg_type'], v5['header']['msg_type'])
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v5c['user_expressions'], {'a' : 'apple', 'b': 'b'})
         self.assertNotIn('user_variables', v5c)
         self.assertEqual(v5c['code'], v4c['code'])
 
     def test_execute_reply(self):
         msg = self.msg("execute_reply", {
             'status': 'ok',
             'execution_count': 7,
             'user_variables': {'a': 1},
             'user_expressions': {'a+a': 2},
             'payload': [{'source':'page', 'text':'blah'}]
         })
         v4, v5 = self.adapt(msg)
         v5c = v5['content']
         self.assertNotIn('user_variables', v5c)
         self.assertEqual(v5c['user_expressions'], {'a': 1, 'a+a': 2})
         self.assertEqual(v5c['payload'], [{'source': 'page',
                                            'data': {'text/plain': 'blah'}}
                                          ])
 
     def test_complete_request(self):
         msg = self.msg("complete_request", {
             'text' : 'a.is',
             'line' : 'foo = a.is',
             'block' : None,
             'cursor_pos' : 10,
         })
         v4, v5 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
         for key in ('text', 'line', 'block'):
             self.assertNotIn(key, v5c)
         self.assertEqual(v5c['cursor_pos'], v4c['cursor_pos'])
         self.assertEqual(v5c['code'], v4c['line'])
 
     def test_complete_reply(self):
         msg = self.msg("complete_reply", {
             'matched_text' : 'a.is',
             'matches' : ['a.isalnum',
                         'a.isalpha',
                         'a.isdigit',
                         'a.islower',
                         ],
         })
         v4, v5 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
 
         self.assertEqual(v5c['matches'], v4c['matches'])
         self.assertEqual(v5c['metadata'], {})
         self.assertEqual(v5c['cursor_start'], -4)
         self.assertEqual(v5c['cursor_end'], None)
 
     def test_object_info_request(self):
         msg = self.msg("object_info_request", {
             'oname' : 'foo',
             'detail_level' : 1,
         })
         v4, v5 = self.adapt(msg)
         self.assertEqual(v5['header']['msg_type'], 'inspect_request')
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v5c['code'], v4c['oname'])
         self.assertEqual(v5c['cursor_pos'], len(v4c['oname']))
         self.assertEqual(v5c['detail_level'], v4c['detail_level'])
 
     def test_object_info_reply(self):
         msg = self.msg("object_info_reply", {
             'oname' : 'foo',
             'found' : True,
             'status' : 'ok',
             'definition' : 'foo(a=5)',
             'docstring' : "the docstring",
         })
         v4, v5 = self.adapt(msg)
         self.assertEqual(v5['header']['msg_type'], 'inspect_reply')
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(sorted(v5c), [ 'data', 'found', 'metadata', 'name', 'status'])
         text = v5c['data']['text/plain']
         self.assertEqual(text, '\n'.join([v4c['definition'], v4c['docstring']]))
 
     def test_kernel_info_reply(self):
         msg = self.msg("kernel_info_reply", {
             'language': 'python',
             'language_version': [2,8,0],
             'ipython_version': [1,2,3],
         })
         v4, v5 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v5c, {
             'protocol_version': '4.1',
             'implementation': 'ipython',
             'implementation_version': '1.2.3',
             'language_info': {
                 'name': 'python',
                 'version': '2.8.0',
             },
             'banner' : '',
         })
 
     # iopub channel
 
     def test_display_data(self):
         jsondata = dict(a=5)
         msg = self.msg("display_data", {
             'data' : {
                 'text/plain' : 'some text',
                 'application/json' : json.dumps(jsondata)
             },
             'metadata' : {'text/plain' : { 'key' : 'value' }},
         })
         v4, v5 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v5c['metadata'], v4c['metadata'])
         self.assertEqual(v5c['data']['text/plain'], v4c['data']['text/plain'])
         self.assertEqual(v5c['data']['application/json'], jsondata)
 
     # stdin channel
 
     def test_input_request(self):
         msg = self.msg('input_request', {'prompt': "$>"})
         v4, v5 = self.adapt(msg)
         self.assertEqual(v5['content']['prompt'], v4['content']['prompt'])
         self.assertFalse(v5['content']['password'])
 
 
 class V5toV4TestCase(AdapterTest):
     from_version = 5
     to_version = 4
 
     def msg(self, msg_type, content):
         return self.session.msg(msg_type, content)
 
     def test_same_version(self):
         msg = self.msg("execute_result",
             content={'status' : 'ok'}
         )
         original, adapted = self.adapt(msg, self.from_version)
 
         self.assertEqual(original, adapted)
 
     def test_no_adapt(self):
         msg = self.msg("input_reply", {'value' : 'some text'})
         v5, v4 = self.adapt(msg)
         self.assertNotIn('version', v4['header'])
         v5['header'].pop('version')
         self.assertEqual(v4, v5)
 
     def test_rename_type(self):
         for v5_type, v4_type in [
                 ('execute_result', 'pyout'),
                 ('execute_input', 'pyin'),
                 ('error', 'pyerr'),
             ]:
             msg = self.msg(v5_type, {'key' : 'value'})
             v5, v4 = self.adapt(msg)
             self.assertEqual(v4['header']['msg_type'], v4_type)
             nt.assert_not_in('version', v4['header'])
             self.assertEqual(v4['content'], v5['content'])
 
     def test_execute_request(self):
         msg = self.msg("execute_request", {
             'code' : 'a=5',
             'silent' : False,
             'user_expressions' : {'a' : 'apple'},
         })
         v5, v4 = self.adapt(msg)
         self.assertEqual(v4['header']['msg_type'], v5['header']['msg_type'])
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v4c['user_variables'], [])
         self.assertEqual(v5c['code'], v4c['code'])
 
     def test_complete_request(self):
         msg = self.msg("complete_request", {
             'code' : 'def foo():\n'
                      '    a.is\n'
                      'foo()',
             'cursor_pos': 19,
         })
         v5, v4 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
         self.assertNotIn('code', v4c)
         self.assertEqual(v4c['line'], v5c['code'].splitlines(True)[1])
         self.assertEqual(v4c['cursor_pos'], 8)
         self.assertEqual(v4c['text'], '')
         self.assertEqual(v4c['block'], None)
 
     def test_complete_reply(self):
         msg = self.msg("complete_reply", {
             'cursor_start' : 10,
             'cursor_end' : 14,
             'matches' : ['a.isalnum',
                         'a.isalpha',
                         'a.isdigit',
                         'a.islower',
                         ],
             'metadata' : {},
         })
         v5, v4 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v4c['matched_text'], 'a.is')
         self.assertEqual(v4c['matches'], v5c['matches'])
 
     def test_inspect_request(self):
         msg = self.msg("inspect_request", {
             'code' : 'def foo():\n'
                      '    apple\n'
                      'bar()',
             'cursor_pos': 18,
             'detail_level' : 1,
         })
         v5, v4 = self.adapt(msg)
         self.assertEqual(v4['header']['msg_type'], 'object_info_request')
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v4c['oname'], 'apple')
         self.assertEqual(v5c['detail_level'], v4c['detail_level'])
 
     def test_inspect_reply(self):
         msg = self.msg("inspect_reply", {
             'name' : 'foo',
             'found' : True,
             'data' : {'text/plain' : 'some text'},
             'metadata' : {},
         })
         v5, v4 = self.adapt(msg)
         self.assertEqual(v4['header']['msg_type'], 'object_info_reply')
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(sorted(v4c), ['found', 'oname'])
         self.assertEqual(v4c['found'], False)
 
     def test_kernel_info_reply(self):
         msg = self.msg("kernel_info_reply", {
             'protocol_version': '5.0',
             'implementation': 'ipython',
             'implementation_version': '1.2.3',
             'language_info': {
                 'name': 'python',
                 'version': '2.8.0',
                 'mimetype': 'text/x-python',
             },
             'banner' : 'the banner',
         })
         v5, v4 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
         info = v5c['language_info']
         self.assertEqual(v4c, {
             'protocol_version': [5,0],
             'language': 'python',
             'language_version': [2,8,0],
             'ipython_version': [1,2,3],
         })
 
     # iopub channel
 
     def test_display_data(self):
         jsondata = dict(a=5)
         msg = self.msg("display_data", {
             'data' : {
                 'text/plain' : 'some text',
                 'application/json' : jsondata,
             },
             'metadata' : {'text/plain' : { 'key' : 'value' }},
         })
         v5, v4 = self.adapt(msg)
         v4c = v4['content']
         v5c = v5['content']
         self.assertEqual(v5c['metadata'], v4c['metadata'])
         self.assertEqual(v5c['data']['text/plain'], v4c['data']['text/plain'])
         self.assertEqual(v4c['data']['application/json'], json.dumps(jsondata))
 
     # stdin channel
 
     def test_input_request(self):
         msg = self.msg('input_request', {'prompt': "$>", 'password' : True})
         v5, v4 = self.adapt(msg)
         self.assertEqual(v5['content']['prompt'], v4['content']['prompt'])
         self.assertNotIn('password', v4['content'])

jupyter_client/tests/test_connect.py

@@ -1,141 +1,141 b''
 """Tests for kernel connection utilities
 
 Authors
 -------
 * MinRK
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import json
 import os
 
 import nose.tools as nt
 
 from IPython.config import Config
 from IPython.consoleapp import IPythonConsoleApp
 from IPython.core.application import BaseIPythonApplication
 from IPython.utils.tempdir import TemporaryDirectory, TemporaryWorkingDirectory
 from IPython.utils.py3compat import str_to_bytes
-from IPython.kernel import connect
-from IPython.kernel.zmq.session import Session
+from jupyter_client import connect
+from jupyter_client.session import Session
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 class DummyConsoleApp(BaseIPythonApplication, IPythonConsoleApp):
     def initialize(self, argv=[]):
         BaseIPythonApplication.initialize(self, argv=argv)
         self.init_connection_file()
 
 sample_info = dict(ip='1.2.3.4', transport='ipc',
         shell_port=1, hb_port=2, iopub_port=3, stdin_port=4, control_port=5,
         key=b'abc123', signature_scheme='hmac-md5',
     )
 
 def test_write_connection_file():
     with TemporaryDirectory() as d:
         cf = os.path.join(d, 'kernel.json')
         connect.write_connection_file(cf, **sample_info)
         nt.assert_true(os.path.exists(cf))
         with open(cf, 'r') as f:
             info = json.load(f)
     info['key'] = str_to_bytes(info['key'])
     nt.assert_equal(info, sample_info)
 
 
 def test_load_connection_file_session():
     """test load_connection_file() after """
     session = Session()
     app = DummyConsoleApp(session=Session())
     app.initialize(argv=[])
     session = app.session
 
     with TemporaryDirectory() as d:
         cf = os.path.join(d, 'kernel.json')
         connect.write_connection_file(cf, **sample_info)
         app.connection_file = cf
         app.load_connection_file()
 
     nt.assert_equal(session.key, sample_info['key'])
     nt.assert_equal(session.signature_scheme, sample_info['signature_scheme'])
 
 
 def test_app_load_connection_file():
     """test `ipython console --existing` loads a connection file"""
     with TemporaryDirectory() as d:
         cf = os.path.join(d, 'kernel.json')
         connect.write_connection_file(cf, **sample_info)
         app = DummyConsoleApp(connection_file=cf)
         app.initialize(argv=[])
 
     for attr, expected in sample_info.items():
         if attr in ('key', 'signature_scheme'):
             continue
         value = getattr(app, attr)
         nt.assert_equal(value, expected, "app.%s = %s != %s" % (attr, value, expected))
 
 def test_get_connection_file():
     cfg = Config()
     with TemporaryWorkingDirectory() as d:
         cfg.ProfileDir.location = d
         cf = 'kernel.json'
         app = DummyConsoleApp(config=cfg, connection_file=cf)
         app.initialize(argv=[])
 
         profile_cf = os.path.join(app.profile_dir.location, 'security', cf)
         nt.assert_equal(profile_cf, app.connection_file)
         with open(profile_cf, 'w') as f:
             f.write("{}")
         nt.assert_true(os.path.exists(profile_cf))
         nt.assert_equal(connect.get_connection_file(app), profile_cf)
 
         app.connection_file = cf
         nt.assert_equal(connect.get_connection_file(app), profile_cf)
 
 def test_find_connection_file():
     cfg = Config()
     with TemporaryDirectory() as d:
         cfg.ProfileDir.location = d
         cf = 'kernel.json'
         app = DummyConsoleApp(config=cfg, connection_file=cf)
         app.initialize(argv=[])
         BaseIPythonApplication._instance = app
 
         profile_cf = os.path.join(app.profile_dir.location, 'security', cf)
         with open(profile_cf, 'w') as f:
             f.write("{}")
 
         for query in (
             'kernel.json',
             'kern*',
             '*ernel*',
             'k*',
             ):
             nt.assert_equal(connect.find_connection_file(query), profile_cf)
 
         BaseIPythonApplication._instance = None
 
 def test_get_connection_info():
     with TemporaryDirectory() as d:
         cf = os.path.join(d, 'kernel.json')
         connect.write_connection_file(cf, **sample_info)
         json_info = connect.get_connection_info(cf)
         info = connect.get_connection_info(cf, unpack=True)
 
     nt.assert_equal(type(json_info), type(""))
     nt.assert_equal(info, sample_info)
 
     info2 = json.loads(json_info)
     info2['key'] = str_to_bytes(info2['key'])
     nt.assert_equal(info2, sample_info)

jupyter_client/tests/test_kernelmanager.py

@@ -1,53 +1,53 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.kernel import KernelManager
+from jupyter_client import KernelManager
 
 class TestKernelManager(TestCase):
 
     def _get_tcp_km(self):
         c = Config()
         km = KernelManager(config=c)
         return km
 
     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)
         self.assertTrue(km.is_alive())
         km.restart_kernel(now=True)
         self.assertTrue(km.is_alive())
         km.interrupt_kernel()
         self.assertTrue(isinstance(km, KernelManager))
         km.shutdown_kernel(now=True)
 
     def test_tcp_lifecycle(self):
         km = self._get_tcp_km()
         self._run_lifecycle(km)
 
     @dec.skip_win32
     def test_ipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)
 
     def test_get_connect_info(self):
         km = self._get_tcp_km()
         cinfo = km.get_connection_info()
         keys = sorted(cinfo.keys())
         expected = sorted([
             'ip', 'transport',
             'hb_port', 'shell_port', 'stdin_port', 'iopub_port', 'control_port',
             'key', 'signature_scheme',
         ])
         self.assertEqual(keys, expected)

jupyter_client/tests/test_kernelspec.py

@@ -1,64 +1,64 b''
 import json
 import os
 from os.path import join as pjoin
 import unittest
 
 from IPython.testing.decorators import onlyif
 from IPython.utils.tempdir import TemporaryDirectory
-from IPython.kernel import kernelspec
+from jupyter_client import kernelspec
 
 sample_kernel_json = {'argv':['cat', '{connection_file}'],
                       'display_name':'Test kernel',
                      }
 
 class KernelSpecTests(unittest.TestCase):
     def setUp(self):
         td = TemporaryDirectory()
         self.addCleanup(td.cleanup)
         self.sample_kernel_dir = pjoin(td.name, 'kernels', 'Sample')
         os.makedirs(self.sample_kernel_dir)
         json_file = pjoin(self.sample_kernel_dir, 'kernel.json')
         with open(json_file, 'w') as f:
             json.dump(sample_kernel_json, f)
 
         self.ksm = kernelspec.KernelSpecManager(ipython_dir=td.name)
 
         td2 = TemporaryDirectory()
         self.addCleanup(td2.cleanup)
         self.installable_kernel = td2.name
         with open(pjoin(self.installable_kernel, 'kernel.json'), 'w') as f:
             json.dump(sample_kernel_json, f)
 
     def test_find_kernel_specs(self):
         kernels = self.ksm.find_kernel_specs()
         self.assertEqual(kernels['sample'], self.sample_kernel_dir)
 
     def test_get_kernel_spec(self):
         ks = self.ksm.get_kernel_spec('SAMPLE')  # Case insensitive
         self.assertEqual(ks.resource_dir, self.sample_kernel_dir)
         self.assertEqual(ks.argv, sample_kernel_json['argv'])
         self.assertEqual(ks.display_name, sample_kernel_json['display_name'])
         self.assertEqual(ks.env, {})
 
     def test_install_kernel_spec(self):
         self.ksm.install_kernel_spec(self.installable_kernel,
                                      kernel_name='tstinstalled',
                                      user=True)
         self.assertIn('tstinstalled', self.ksm.find_kernel_specs())
 
         with self.assertRaises(OSError):
             self.ksm.install_kernel_spec(self.installable_kernel,
                                          kernel_name='tstinstalled',
                                          user=True)
 
         # Smoketest that this succeeds
         self.ksm.install_kernel_spec(self.installable_kernel,
                                      kernel_name='tstinstalled',
                                      replace=True, user=True)
 
     @onlyif(os.name != 'nt' and not os.access('/usr/local/share', os.W_OK), "needs Unix system without root privileges")
     def test_cant_install_kernel_spec(self):
         with self.assertRaises(OSError):
             self.ksm.install_kernel_spec(self.installable_kernel,
                                          kernel_name='tstinstalled',
                                          user=False)

jupyter_client/tests/test_launcher.py

@@ -1,57 +1,57 b''
 """Tests for kernel utility functions
 
 Authors
 -------
 * MinRK
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2011, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Third-party imports
 import nose.tools as nt
 
 # Our own imports
-from IPython.kernel.launcher import swallow_argv
+from jupyter_client.launcher import swallow_argv
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 def test_swallow_argv():
     tests = [
         # expected  , argv       , aliases, flags
         (['-a', '5'], ['-a', '5'], None, None),
         (['5'], ['-a', '5'], None, ['a']),
         ([], ['-a', '5'], ['a'], None),
         ([], ['-a', '5'], ['a'], ['a']),
         ([], ['--foo'], None, ['foo']),
         ([], ['--foo'], ['foobar'], []),
         ([], ['--foo', '5'], ['foo'], []),
         ([], ['--foo=5'], ['foo'], []),
         (['--foo=5'], ['--foo=5'], [], ['foo']),
         (['5'], ['--foo', '5'], [], ['foo']),
         (['bar'], ['--foo', '5', 'bar'], ['foo'], ['foo']),
         (['bar'], ['--foo=5', 'bar'], ['foo'], ['foo']),
         (['5','bar'], ['--foo', '5', 'bar'], None, ['foo']),
         (['bar'], ['--foo', '5', 'bar'], ['foo'], None),
         (['bar'], ['--foo=5', 'bar'], ['foo'], None),
     ]
     for expected, argv, aliases, flags in tests:
         stripped = swallow_argv(argv, aliases=aliases, flags=flags)
         message = '\n'.join(['',
             "argv: %r" % argv,
             "aliases: %r" % aliases,
             "flags : %r" % flags,
             "expected : %r" % expected,
             "returned : %r" % stripped,
         ])
         nt.assert_equal(expected, stripped, message)

jupyter_client/tests/test_multikernelmanager.py

@@ -1,86 +1,86 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.utils.localinterfaces import localhost
-from IPython.kernel import KernelManager
-from IPython.kernel.multikernelmanager import MultiKernelManager
+from jupyter_client import KernelManager
+from jupyter_client.multikernelmanager import MultiKernelManager
 
 class TestKernelManager(TestCase):
 
     def _get_tcp_km(self):
         c = Config()
         km = MultiKernelManager(config=c)
         return km
 
     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(km.is_alive(kid))
         self.assertTrue(kid in km)
         self.assertTrue(kid in km.list_kernel_ids())
         self.assertEqual(len(km),1)
         km.restart_kernel(kid, now=True)
         self.assertTrue(km.is_alive(kid))
         self.assertTrue(kid in km.list_kernel_ids())
         km.interrupt_kernel(kid)
         k = km.get_kernel(kid)
         self.assertTrue(isinstance(k, KernelManager))
         km.shutdown_kernel(kid, now=True)
         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.connect_iopub(kid)
         stream.close()
         self.assertTrue('shell_port' in cinfo)
         stream = km.connect_shell(kid)
         stream.close()
         self.assertTrue('hb_port' in cinfo)
         stream = km.connect_hb(kid)
         stream.close()
         km.shutdown_kernel(kid, now=True)
 
     def test_tcp_lifecycle(self):
         km = self._get_tcp_km()
         self._run_lifecycle(km)
 
     def test_shutdown_all(self):
         km = self._get_tcp_km()
         kid = km.start_kernel(stdout=PIPE, stderr=PIPE)
         self.assertIn(kid, km)
         km.shutdown_all()
         self.assertNotIn(kid, km)
         # shutdown again is okay, because we have no kernels
         km.shutdown_all()
 
     def test_tcp_cinfo(self):
         km = self._get_tcp_km()
         self._run_cinfo(km, 'tcp', localhost())
 
     @dec.skip_win32
     def test_ipc_lifecycle(self):
         km = self._get_ipc_km()
         self._run_lifecycle(km)
 
     @dec.skip_win32
     def test_ipc_cinfo(self):
         km = self._get_ipc_km()
         self._run_cinfo(km, 'ipc', 'test')

jupyter_client/tests/test_public_api.py

@@ -1,40 +1,40 b''
-"""Test the IPython.kernel public API
+"""Test the jupyter_client public API
 
 Authors
 -------
 * MinRK
 """
 #-----------------------------------------------------------------------------
 # Copyright (c) 2013, the IPython Development Team.
 #
 # Distributed under the terms of the Modified BSD License.
 #
 # The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 import nose.tools as nt
 
-from IPython.kernel import launcher, connect
+from jupyter_client import launcher, connect
 from IPython import kernel
 
 #-----------------------------------------------------------------------------
 # Classes and functions
 #-----------------------------------------------------------------------------
 
 def test_kms():
     for base in ("", "Multi"):
         KM = base + "KernelManager"
         nt.assert_in(KM, dir(kernel))
 
 def test_kcs():
     for base in ("", "Blocking"):
         KM = base + "KernelClient"
         nt.assert_in(KM, dir(kernel))
 
 def test_launcher():
     for name in launcher.__all__:
         nt.assert_in(name, dir(kernel))
 
 def test_connect():
     for name in connect.__all__:
         nt.assert_in(name, dir(kernel))

jupyter_client/tests/test_session.py

@@ -1,318 +1,318 b''
 """test building messages with Session"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 import hmac
 import os
 import uuid
 from datetime import datetime
 
 import zmq
 
 from zmq.tests import BaseZMQTestCase
 from zmq.eventloop.zmqstream import ZMQStream
 
-from IPython.kernel.zmq import session as ss
+from jupyter_client import session as ss
 
 from IPython.testing.decorators import skipif, module_not_available
 from IPython.utils.py3compat import string_types
 from IPython.utils import jsonutil
 
 def _bad_packer(obj):
     raise TypeError("I don't work")
 
 def _bad_unpacker(bytes):
     raise TypeError("I don't work either")
 
 class SessionTestCase(BaseZMQTestCase):
 
     def setUp(self):
         BaseZMQTestCase.setUp(self)
         self.session = ss.Session()
 
 
 class TestSession(SessionTestCase):
 
     def test_msg(self):
         """message format"""
         msg = self.session.msg('execute')
         thekeys = set('header parent_header metadata content msg_type msg_id'.split())
         s = set(msg.keys())
         self.assertEqual(s, thekeys)
         self.assertTrue(isinstance(msg['content'],dict))
         self.assertTrue(isinstance(msg['metadata'],dict))
         self.assertTrue(isinstance(msg['header'],dict))
         self.assertTrue(isinstance(msg['parent_header'],dict))
         self.assertTrue(isinstance(msg['msg_id'],str))
         self.assertTrue(isinstance(msg['msg_type'],str))
         self.assertEqual(msg['header']['msg_type'], 'execute')
         self.assertEqual(msg['msg_type'], 'execute')
 
     def test_serialize(self):
         msg = self.session.msg('execute', content=dict(a=10, b=1.1))
         msg_list = self.session.serialize(msg, ident=b'foo')
         ident, msg_list = self.session.feed_identities(msg_list)
         new_msg = self.session.deserialize(msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_id'],msg['msg_id'])
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
         self.assertEqual(new_msg['header'],msg['header'])
         self.assertEqual(new_msg['content'],msg['content'])
         self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         self.assertEqual(new_msg['metadata'],msg['metadata'])
         # ensure floats don't come out as Decimal:
         self.assertEqual(type(new_msg['content']['b']),type(new_msg['content']['b']))
 
     def test_default_secure(self):
         self.assertIsInstance(self.session.key, bytes)
         self.assertIsInstance(self.session.auth, hmac.HMAC)
 
     def test_send(self):
         ctx = zmq.Context.instance()
         A = ctx.socket(zmq.PAIR)
         B = ctx.socket(zmq.PAIR)
         A.bind("inproc://test")
         B.connect("inproc://test")
 
         msg = self.session.msg('execute', content=dict(a=10))
         self.session.send(A, msg, ident=b'foo', buffers=[b'bar'])
 
         ident, msg_list = self.session.feed_identities(B.recv_multipart())
         new_msg = self.session.deserialize(msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_id'],msg['msg_id'])
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
         self.assertEqual(new_msg['header'],msg['header'])
         self.assertEqual(new_msg['content'],msg['content'])
         self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         self.assertEqual(new_msg['metadata'],msg['metadata'])
         self.assertEqual(new_msg['buffers'],[b'bar'])
 
         content = msg['content']
         header = msg['header']
         header['msg_id'] = self.session.msg_id
         parent = msg['parent_header']
         metadata = msg['metadata']
         msg_type = header['msg_type']
         self.session.send(A, None, content=content, parent=parent,
             header=header, metadata=metadata, ident=b'foo', buffers=[b'bar'])
         ident, msg_list = self.session.feed_identities(B.recv_multipart())
         new_msg = self.session.deserialize(msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_id'],header['msg_id'])
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
         self.assertEqual(new_msg['header'],msg['header'])
         self.assertEqual(new_msg['content'],msg['content'])
         self.assertEqual(new_msg['metadata'],msg['metadata'])
         self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         self.assertEqual(new_msg['buffers'],[b'bar'])
 
         header['msg_id'] = self.session.msg_id
 
         self.session.send(A, msg, ident=b'foo', buffers=[b'bar'])
         ident, new_msg = self.session.recv(B)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_id'],header['msg_id'])
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
         self.assertEqual(new_msg['header'],msg['header'])
         self.assertEqual(new_msg['content'],msg['content'])
         self.assertEqual(new_msg['metadata'],msg['metadata'])
         self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         self.assertEqual(new_msg['buffers'],[b'bar'])
 
         A.close()
         B.close()
         ctx.term()
 
     def test_args(self):
         """initialization arguments for Session"""
         s = self.session
         self.assertTrue(s.pack is ss.default_packer)
         self.assertTrue(s.unpack is ss.default_unpacker)
         self.assertEqual(s.username, os.environ.get('USER', u'username'))
 
         s = ss.Session()
         self.assertEqual(s.username, os.environ.get('USER', u'username'))
 
         self.assertRaises(TypeError, ss.Session, pack='hi')
         self.assertRaises(TypeError, ss.Session, unpack='hi')
         u = str(uuid.uuid4())
         s = ss.Session(username=u'carrot', session=u)
         self.assertEqual(s.session, u)
         self.assertEqual(s.username, u'carrot')
 
     def test_tracking(self):
         """test tracking messages"""
         a,b = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
         s = self.session
         s.copy_threshold = 1
         stream = ZMQStream(a)
         msg = s.send(a, 'hello', track=False)
         self.assertTrue(msg['tracker'] is ss.DONE)
         msg = s.send(a, 'hello', track=True)
         self.assertTrue(isinstance(msg['tracker'], zmq.MessageTracker))
         M = zmq.Message(b'hi there', track=True)
         msg = s.send(a, 'hello', buffers=[M], track=True)
         t = msg['tracker']
         self.assertTrue(isinstance(t, zmq.MessageTracker))
         self.assertRaises(zmq.NotDone, t.wait, .1)
         del M
         t.wait(1) # this will raise
 
 
     def test_unique_msg_ids(self):
         """test that messages receive unique ids"""
         ids = set()
         for i in range(2**12):
             h = self.session.msg_header('test')
             msg_id = h['msg_id']
             self.assertTrue(msg_id not in ids)
             ids.add(msg_id)
 
     def test_feed_identities(self):
         """scrub the front for zmq IDENTITIES"""
         theids = "engine client other".split()
         content = dict(code='whoda',stuff=object())
         themsg = self.session.msg('execute',content=content)
         pmsg = theids
 
     def test_session_id(self):
         session = ss.Session()
         # get bs before us
         bs = session.bsession
         us = session.session
         self.assertEqual(us.encode('ascii'), bs)
         session = ss.Session()
         # get us before bs
         us = session.session
         bs = session.bsession
         self.assertEqual(us.encode('ascii'), bs)
         # change propagates:
         session.session = 'something else'
         bs = session.bsession
         us = session.session
         self.assertEqual(us.encode('ascii'), bs)
         session = ss.Session(session='stuff')
         # get us before bs
         self.assertEqual(session.bsession, session.session.encode('ascii'))
         self.assertEqual(b'stuff', session.bsession)
 
     def test_zero_digest_history(self):
         session = ss.Session(digest_history_size=0)
         for i in range(11):
             session._add_digest(uuid.uuid4().bytes)
         self.assertEqual(len(session.digest_history), 0)
 
     def test_cull_digest_history(self):
         session = ss.Session(digest_history_size=100)
         for i in range(100):
             session._add_digest(uuid.uuid4().bytes)
         self.assertTrue(len(session.digest_history) == 100)
         session._add_digest(uuid.uuid4().bytes)
         self.assertTrue(len(session.digest_history) == 91)
         for i in range(9):
             session._add_digest(uuid.uuid4().bytes)
         self.assertTrue(len(session.digest_history) == 100)
         session._add_digest(uuid.uuid4().bytes)
         self.assertTrue(len(session.digest_history) == 91)
 
     def test_bad_pack(self):
         try:
             session = ss.Session(pack=_bad_packer)
         except ValueError as e:
             self.assertIn("could not serialize", str(e))
             self.assertIn("don't work", str(e))
         else:
             self.fail("Should have raised ValueError")
 
     def test_bad_unpack(self):
         try:
             session = ss.Session(unpack=_bad_unpacker)
         except ValueError as e:
             self.assertIn("could not handle output", str(e))
             self.assertIn("don't work either", str(e))
         else:
             self.fail("Should have raised ValueError")
 
     def test_bad_packer(self):
         try:
             session = ss.Session(packer=__name__ + '._bad_packer')
         except ValueError as e:
             self.assertIn("could not serialize", str(e))
             self.assertIn("don't work", str(e))
         else:
             self.fail("Should have raised ValueError")
 
     def test_bad_unpacker(self):
         try:
             session = ss.Session(unpacker=__name__ + '._bad_unpacker')
         except ValueError as e:
             self.assertIn("could not handle output", str(e))
             self.assertIn("don't work either", str(e))
         else:
             self.fail("Should have raised ValueError")
 
     def test_bad_roundtrip(self):
         with self.assertRaises(ValueError):
             session = ss.Session(unpack=lambda b: 5)
 
     def _datetime_test(self, session):
         content = dict(t=datetime.now())
         metadata = dict(t=datetime.now())
         p = session.msg('msg')
         msg = session.msg('msg', content=content, metadata=metadata, parent=p['header'])
         smsg = session.serialize(msg)
         msg2 = session.deserialize(session.feed_identities(smsg)[1])
         assert isinstance(msg2['header']['date'], datetime)
         self.assertEqual(msg['header'], msg2['header'])
         self.assertEqual(msg['parent_header'], msg2['parent_header'])
         self.assertEqual(msg['parent_header'], msg2['parent_header'])
         assert isinstance(msg['content']['t'], datetime)
         assert isinstance(msg['metadata']['t'], datetime)
         assert isinstance(msg2['content']['t'], string_types)
         assert isinstance(msg2['metadata']['t'], string_types)
         self.assertEqual(msg['content'], jsonutil.extract_dates(msg2['content']))
         self.assertEqual(msg['content'], jsonutil.extract_dates(msg2['content']))
 
     def test_datetimes(self):
         self._datetime_test(self.session)
 
     def test_datetimes_pickle(self):
         session = ss.Session(packer='pickle')
         self._datetime_test(session)
 
     @skipif(module_not_available('msgpack'))
     def test_datetimes_msgpack(self):
         import msgpack
 
         session = ss.Session(
             pack=msgpack.packb,
             unpack=lambda buf: msgpack.unpackb(buf, encoding='utf8'),
         )
         self._datetime_test(session)
 
     def test_send_raw(self):
         ctx = zmq.Context.instance()
         A = ctx.socket(zmq.PAIR)
         B = ctx.socket(zmq.PAIR)
         A.bind("inproc://test")
         B.connect("inproc://test")
 
         msg = self.session.msg('execute', content=dict(a=10))
         msg_list = [self.session.pack(msg[part]) for part in
                     ['header', 'parent_header', 'metadata', 'content']]
         self.session.send_raw(A, msg_list, ident=b'foo')
 
         ident, new_msg_list = self.session.feed_identities(B.recv_multipart())
         new_msg = self.session.deserialize(new_msg_list)
         self.assertEqual(ident[0], b'foo')
         self.assertEqual(new_msg['msg_type'],msg['msg_type'])
         self.assertEqual(new_msg['header'],msg['header'])
         self.assertEqual(new_msg['parent_header'],msg['parent_header'])
         self.assertEqual(new_msg['content'],msg['content'])
         self.assertEqual(new_msg['metadata'],msg['metadata'])
 
         A.close()
         B.close()
         ctx.term()

jupyter_client/threaded.py

@@ -1,230 +1,230 b''
 """ Defines a KernelClient that provides thread-safe sockets with async callbacks on message replies.
 """
 from __future__ import absolute_import
 import atexit
 import errno
 from threading import Thread
 import time
 
 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
 from IPython.utils.traitlets import Type, Instance
-from IPython.kernel.channels import HBChannel
-from IPython.kernel import KernelClient
-from IPython.kernel.channels import HBChannel
+from jupyter_client.channels import HBChannel
+from jupyter_client import KernelClient
+from jupyter_client.channels import HBChannel
 
 class ThreadedZMQSocketChannel(object):
     """A ZMQ socket invoking a callback in the ioloop"""
     session = None
     socket = None
     ioloop = None
     stream = None
     _inspect = None
 
     def __init__(self, socket, session, loop):
         """Create a channel.
 
         Parameters
         ----------
         socket : :class:`zmq.Socket`
             The ZMQ socket to use.
         session : :class:`session.Session`
             The session to use.
         loop
             A pyzmq ioloop to connect the socket to using a ZMQStream
         """
         super(ThreadedZMQSocketChannel, self).__init__()
 
         self.socket = socket
         self.session = session
         self.ioloop = loop
 
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
 
     _is_alive = False
     def is_alive(self):
         return self._is_alive
 
     def start(self):
         self._is_alive = True
 
     def stop(self):
         self._is_alive = False
 
     def close(self):
         if self.socket is not None:
             try:
                 self.socket.close(linger=0)
             except Exception:
                 pass
             self.socket = None
 
     def 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)
         msg = self.session.deserialize(smsg)
         # let client inspect messages
         if self._inspect:
             self._inspect(msg)
         self.call_handlers(msg)
 
     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 level
         handlers are called in the application thread.
         """
         pass
 
     def process_events(self):
         """Subclasses should override this with a method
         processing any pending GUI events.
         """
         pass
 
 
     def flush(self, timeout=1.0):
         """Immediately processes all pending messages on this channel.
 
         This is only used for the IOPub channel.
 
         Callers should use this method to ensure that :meth:`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 range(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 IOLoopThread(Thread):
     """Run a pyzmq ioloop in a thread to send and receive messages
     """
     def __init__(self, loop):
         super(IOLoopThread, self).__init__()
         self.daemon = True
         atexit.register(self._notice_exit)
         self.ioloop = loop or ioloop.IOLoop()
 
     def _notice_exit(self):
         self._exiting = True
 
     def run(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 :meth:`~threading.Thread.join` and returns when the thread
         terminates. :class:`RuntimeError` will be raised if
         :meth:`~threading.Thread.start` is called again.
         """
         if self.ioloop is not None:
             self.ioloop.stop()
         self.join()
         self.close()
 
     def close(self):
         if self.ioloop is not None:
             try:
                 self.ioloop.close(all_fds=True)
             except Exception:
                 pass
 
 
 class ThreadedKernelClient(KernelClient):
     """ A KernelClient that provides thread-safe sockets with async callbacks on message replies.
     """
 
     _ioloop = None
     @property
     def ioloop(self):
         if self._ioloop is None:
             self._ioloop = ioloop.IOLoop()
         return self._ioloop
 
     ioloop_thread = Instance(IOLoopThread)
 
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         if shell:
             self.shell_channel._inspect = self._check_kernel_info_reply
 
         self.ioloop_thread = IOLoopThread(self.ioloop)
         self.ioloop_thread.start()
 
         super(ThreadedKernelClient, self).start_channels(shell, iopub, stdin, hb)
 
     def _check_kernel_info_reply(self, msg):
         """This is run in the ioloop thread when the kernel info reply is recieved
         """
         if msg['msg_type'] == 'kernel_info_reply':
             self._handle_kernel_info_reply(msg)
             self.shell_channel._inspect = None
 
     def stop_channels(self):
         super(ThreadedKernelClient, self).stop_channels()
         if self.ioloop_thread.is_alive():
             self.ioloop_thread.stop()
 
     iopub_channel_class = Type(ThreadedZMQSocketChannel)
     shell_channel_class = Type(ThreadedZMQSocketChannel)
     stdin_channel_class = Type(ThreadedZMQSocketChannel)
     hb_channel_class = Type(HBChannel)