Merge pull request #8175 from minrk/bigsplit-kernel

Big Split: IPython.kernel

IPython/kernel/session.py

@@ -0,0 +1,883 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 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
+#-----------------------------------------------------------------------------
+
+# default values for the thresholds:
+MAX_ITEMS = 64
+MAX_BYTES = 1024
+
+# 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('jupyter_client.session.Session')
+
+    loop = Instance('zmq.eventloop.ioloop.IOLoop', allow_none=False)
+    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)
+
+    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']

ipython_kernel/__init__.py

@@ -0,0 +1,1 b''
+from .connect import *
  No newline at end of file

ipython_kernel/__main__.py

@@ -0,0 +1,3 b''
+if __name__ == '__main__':
+    from ipython_kernel import kernelapp as app
+    app.launch_new_instance()

ipython_kernel/connect.py

@@ -0,0 +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.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('jupyter_client.session.Session')
+    def _session_default(self):
+        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',
+]

ipython_kernel/launcher.py

@@ -0,0 +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 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',
+]

ipython_kernel/session.py

@@ -0,0 +1,1 b''
+from jupyter_client.session import *

jupyter_client/__init__.py

@@ -0,0 +1,8 b''
+"""IPython kernels and associated utilities"""
+
+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/adapter.py

@@ -0,0 +1,374 b''
+"""Adapters for IPython msg spec versions."""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import json
+
+from IPython.core.release import kernel_protocol_version_info
+from IPython.utils.tokenutil import token_at_cursor
+
+
+def code_to_line(code, cursor_pos):
+    """Turn a multiline code block and cursor position into a single line
+    and new cursor position.
+
+    For adapting ``complete_`` and ``object_info_request``.
+    """
+    if not code:
+        return "", 0
+    for line in code.splitlines(True):
+        n = len(line)
+        if cursor_pos > n:
+            cursor_pos -= n
+        else:
+            break
+    return line, cursor_pos
+
+
+class Adapter(object):
+    """Base class for adapting messages
+
+    Override message_type(msg) methods to create adapters.
+    """
+
+    msg_type_map = {}
+
+    def update_header(self, msg):
+        return msg
+
+    def update_metadata(self, msg):
+        return msg
+
+    def update_msg_type(self, msg):
+        header = msg['header']
+        msg_type = header['msg_type']
+        if msg_type in self.msg_type_map:
+            msg['msg_type'] = header['msg_type'] = self.msg_type_map[msg_type]
+        return msg
+
+    def handle_reply_status_error(self, msg):
+        """This will be called *instead of* the regular handler
+
+        on any reply with status != ok
+        """
+        return msg
+
+    def __call__(self, msg):
+        msg = self.update_header(msg)
+        msg = self.update_metadata(msg)
+        msg = self.update_msg_type(msg)
+        header = msg['header']
+
+        handler = getattr(self, header['msg_type'], None)
+        if handler is None:
+            return msg
+
+        # handle status=error replies separately (no change, at present)
+        if msg['content'].get('status', None) in {'error', 'aborted'}:
+            return self.handle_reply_status_error(msg)
+        return handler(msg)
+
+def _version_str_to_list(version):
+    """convert a version string to a list of ints
+
+    non-int segments are excluded
+    """
+    v = []
+    for part in version.split('.'):
+        try:
+            v.append(int(part))
+        except ValueError:
+            pass
+    return v
+
+class V5toV4(Adapter):
+    """Adapt msg protocol v5 to v4"""
+
+    version = '4.1'
+
+    msg_type_map = {
+        'execute_result' : 'pyout',
+        'execute_input' : 'pyin',
+        'error' : 'pyerr',
+        'inspect_request' : 'object_info_request',
+        'inspect_reply' : 'object_info_reply',
+    }
+
+    def update_header(self, msg):
+        msg['header'].pop('version', None)
+        return msg
+
+    # shell channel
+
+    def kernel_info_reply(self, msg):
+        v4c = {}
+        content = msg['content']
+        for key in ('language_version', 'protocol_version'):
+            if key in content:
+                v4c[key] = _version_str_to_list(content[key])
+        if content.get('implementation', '') == 'ipython' \
+            and 'implementation_version' in content:
+            v4c['ipython_version'] = _version_str_to_list(content['implementation_version'])
+        language_info = content.get('language_info', {})
+        language = language_info.get('name', '')
+        v4c.setdefault('language', language)
+        if 'version' in language_info:
+            v4c.setdefault('language_version', _version_str_to_list(language_info['version']))
+        msg['content'] = v4c
+        return msg
+
+    def execute_request(self, msg):
+        content = msg['content']
+        content.setdefault('user_variables', [])
+        return msg
+
+    def execute_reply(self, msg):
+        content = msg['content']
+        content.setdefault('user_variables', {})
+        # TODO: handle payloads
+        return msg
+
+    def complete_request(self, msg):
+        content = msg['content']
+        code = content['code']
+        cursor_pos = content['cursor_pos']
+        line, cursor_pos = code_to_line(code, cursor_pos)
+
+        new_content = msg['content'] = {}
+        new_content['text'] = ''
+        new_content['line'] = line
+        new_content['block'] = None
+        new_content['cursor_pos'] = cursor_pos
+        return msg
+
+    def complete_reply(self, msg):
+        content = msg['content']
+        cursor_start = content.pop('cursor_start')
+        cursor_end = content.pop('cursor_end')
+        match_len = cursor_end - cursor_start
+        content['matched_text'] = content['matches'][0][:match_len]
+        content.pop('metadata', None)
+        return msg
+
+    def object_info_request(self, msg):
+        content = msg['content']
+        code = content['code']
+        cursor_pos = content['cursor_pos']
+        line, _ = code_to_line(code, cursor_pos)
+
+        new_content = msg['content'] = {}
+        new_content['oname'] = token_at_cursor(code, cursor_pos)
+        new_content['detail_level'] = content['detail_level']
+        return msg
+
+    def object_info_reply(self, msg):
+        """inspect_reply can't be easily backward compatible"""
+        msg['content'] = {'found' : False, 'oname' : 'unknown'}
+        return msg
+
+    # iopub channel
+
+    def stream(self, msg):
+        content = msg['content']
+        content['data'] = content.pop('text')
+        return msg
+
+    def display_data(self, msg):
+        content = msg['content']
+        content.setdefault("source", "display")
+        data = content['data']
+        if 'application/json' in data:
+            try:
+                data['application/json'] = json.dumps(data['application/json'])
+            except Exception:
+                # warn?
+                pass
+        return msg
+
+    # stdin channel
+
+    def input_request(self, msg):
+        msg['content'].pop('password', None)
+        return msg
+
+
+class V4toV5(Adapter):
+    """Convert msg spec V4 to V5"""
+    version = '5.0'
+
+    # invert message renames above
+    msg_type_map = {v:k for k,v in V5toV4.msg_type_map.items()}
+
+    def update_header(self, msg):
+        msg['header']['version'] = self.version
+        return msg
+
+    # shell channel
+
+    def kernel_info_reply(self, msg):
+        content = msg['content']
+        for key in ('protocol_version', 'ipython_version'):
+            if key in content:
+                content[key] = '.'.join(map(str, content[key]))
+
+        content.setdefault('protocol_version', '4.1')
+
+        if content['language'].startswith('python') and 'ipython_version' in content:
+            content['implementation'] = 'ipython'
+            content['implementation_version'] = content.pop('ipython_version')
+
+        language = content.pop('language')
+        language_info = content.setdefault('language_info', {})
+        language_info.setdefault('name', language)
+        if 'language_version' in content:
+            language_version = '.'.join(map(str, content.pop('language_version')))
+            language_info.setdefault('version', language_version)
+
+        content['banner'] = ''
+        return msg
+
+    def execute_request(self, msg):
+        content = msg['content']
+        user_variables = content.pop('user_variables', [])
+        user_expressions = content.setdefault('user_expressions', {})
+        for v in user_variables:
+            user_expressions[v] = v
+        return msg
+
+    def execute_reply(self, msg):
+        content = msg['content']
+        user_expressions = content.setdefault('user_expressions', {})
+        user_variables = content.pop('user_variables', {})
+        if user_variables:
+            user_expressions.update(user_variables)
+
+        # Pager payloads became a mime bundle
+        for payload in content.get('payload', []):
+            if payload.get('source', None) == 'page' and ('text' in payload):
+                if 'data' not in payload:
+                    payload['data'] = {}
+                payload['data']['text/plain'] = payload.pop('text')
+
+        return msg
+
+    def complete_request(self, msg):
+        old_content = msg['content']
+
+        new_content = msg['content'] = {}
+        new_content['code'] = old_content['line']
+        new_content['cursor_pos'] = old_content['cursor_pos']
+        return msg
+
+    def complete_reply(self, msg):
+        # complete_reply needs more context than we have to get cursor_start and end.
+        # use special end=null to indicate current cursor position and negative offset
+        # for start relative to the cursor.
+        # start=None indicates that start == end (accounts for no -0).
+        content = msg['content']
+        new_content = msg['content'] = {'status' : 'ok'}
+        new_content['matches'] = content['matches']
+        if content['matched_text']:
+            new_content['cursor_start'] = -len(content['matched_text'])
+        else:
+            # no -0, use None to indicate that start == end
+            new_content['cursor_start'] = None
+        new_content['cursor_end'] = None
+        new_content['metadata'] = {}
+        return msg
+
+    def inspect_request(self, msg):
+        content = msg['content']
+        name = content['oname']
+
+        new_content = msg['content'] = {}
+        new_content['code'] = name
+        new_content['cursor_pos'] = len(name)
+        new_content['detail_level'] = content['detail_level']
+        return msg
+
+    def inspect_reply(self, msg):
+        """inspect_reply can't be easily backward compatible"""
+        content = msg['content']
+        new_content = msg['content'] = {'status' : 'ok'}
+        found = new_content['found'] = content['found']
+        new_content['name'] = content['oname']
+        new_content['data'] = data = {}
+        new_content['metadata'] = {}
+        if found:
+            lines = []
+            for key in ('call_def', 'init_definition', 'definition'):
+                if content.get(key, False):
+                    lines.append(content[key])
+                    break
+            for key in ('call_docstring', 'init_docstring', 'docstring'):
+                if content.get(key, False):
+                    lines.append(content[key])
+                    break
+            if not lines:
+                lines.append("<empty docstring>")
+            data['text/plain'] = '\n'.join(lines)
+        return msg
+
+    # iopub channel
+
+    def stream(self, msg):
+        content = msg['content']
+        content['text'] = content.pop('data')
+        return msg
+
+    def display_data(self, msg):
+        content = msg['content']
+        content.pop("source", None)
+        data = content['data']
+        if 'application/json' in data:
+            try:
+                data['application/json'] = json.loads(data['application/json'])
+            except Exception:
+                # warn?
+                pass
+        return msg
+
+    # stdin channel
+
+    def input_request(self, msg):
+        msg['content'].setdefault('password', False)
+        return msg
+
+
+
+def adapt(msg, to_version=kernel_protocol_version_info[0]):
+    """Adapt a single message to a target version
+
+    Parameters
+    ----------
+
+    msg : dict
+        An IPython message.
+    to_version : int, optional
+        The target major version.
+        If unspecified, adapt to the current version for IPython.
+
+    Returns
+    -------
+
+    msg : dict
+        An IPython message appropriate in the new version.
+    """
+    header = msg['header']
+    if 'version' in header:
+        from_version = int(header['version'].split('.')[0])
+    else:
+        # assume last version before adding the key to the header
+        from_version = 4
+    adapter = adapters.get((from_version, to_version), None)
+    if adapter is None:
+        return msg
+    return adapter(msg)
+
+
+# one adapter per major version from,to
+adapters = {
+    (5,4) : V5toV4(),
+    (4,5) : V4toV5(),
+}

jupyter_client/channels.py

@@ -0,0 +1,203 b''
+"""Base classes to manage a Client's interaction with a running kernel"""
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+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 IPython.core.release import kernel_protocol_version_info
+
+from .channelsabc import HBChannelABC
+
+#-----------------------------------------------------------------------------
+# Constants and exceptions
+#-----------------------------------------------------------------------------
+
+major_protocol_version = kernel_protocol_version_info[0]
+
+class InvalidPortNumber(Exception):
+    pass
+
+class HBChannel(Thread):
+    """The heartbeat channel which monitors the kernel heartbeat.
+
+    Note that the heartbeat channel is paused by default. As long as you start
+    this channel, the kernel manager will ensure that it is paused and un-paused
+    as appropriate.
+    """
+    context = None
+    session = None
+    socket = None
+    address = None
+    _exiting = False
+
+    time_to_dead = 1.
+    poller = None
+    _running = None
+    _pause = None
+    _beating = None
+
+    def __init__(self, context=None, session=None, address=None):
+        """Create the heartbeat monitor thread.
+
+        Parameters
+        ----------
+        context : :class:`zmq.Context`
+            The ZMQ context to use.
+        session : :class:`session.Session`
+            The session to use.
+        address : zmq url
+            Standard (ip, port) tuple that the kernel is listening on.
+        """
+        super(HBChannel, self).__init__()
+        self.daemon = True
+
+        self.context = context
+        self.session = session
+        if isinstance(address, tuple):
+            if address[1] == 0:
+                message = 'The port number for a channel cannot be 0.'
+                raise InvalidPortNumber(message)
+            address = "tcp://%s:%i" % address
+        self.address = address
+        atexit.register(self._notice_exit)
+
+        self._running = False
+        self._pause = True
+        self.poller = zmq.Poller()
+
+    def _notice_exit(self):
+        self._exiting = True
+
+    def _create_socket(self):
+        if self.socket is not None:
+            # close previous socket, before opening a new one
+            self.poller.unregister(self.socket)
+            self.socket.close()
+        self.socket = self.context.socket(zmq.REQ)
+        self.socket.linger = 1000
+        self.socket.connect(self.address)
+
+        self.poller.register(self.socket, zmq.POLLIN)
+
+    def _poll(self, start_time):
+        """poll for heartbeat replies until we reach self.time_to_dead.
+
+        Ignores interrupts, and returns the result of poll(), which
+        will be an empty list if no messages arrived before the timeout,
+        or the event tuple if there is a message to receive.
+        """
+
+        until_dead = self.time_to_dead - (time.time() - start_time)
+        # ensure poll at least once
+        until_dead = max(until_dead, 1e-3)
+        events = []
+        while True:
+            try:
+                events = self.poller.poll(1000 * until_dead)
+            except ZMQError as e:
+                if e.errno == errno.EINTR:
+                    # ignore interrupts during heartbeat
+                    # this may never actually happen
+                    until_dead = self.time_to_dead - (time.time() - start_time)
+                    until_dead = max(until_dead, 1e-3)
+                    pass
+                else:
+                    raise
+            except Exception:
+                if self._exiting:
+                    break
+                else:
+                    raise
+            else:
+                break
+        return events
+
+    def run(self):
+        """The thread's main activity.  Call start() instead."""
+        self._create_socket()
+        self._running = True
+        self._beating = True
+
+        while self._running:
+            if self._pause:
+                # just sleep, and skip the rest of the loop
+                time.sleep(self.time_to_dead)
+                continue
+
+            since_last_heartbeat = 0.0
+            # io.rprint('Ping from HB channel') # dbg
+            # no need to catch EFSM here, because the previous event was
+            # either a recv or connect, which cannot be followed by EFSM
+            self.socket.send(b'ping')
+            request_time = time.time()
+            ready = self._poll(request_time)
+            if ready:
+                self._beating = True
+                # the poll above guarantees we have something to recv
+                self.socket.recv()
+                # sleep the remainder of the cycle
+                remainder = self.time_to_dead - (time.time() - request_time)
+                if remainder > 0:
+                    time.sleep(remainder)
+                continue
+            else:
+                # nothing was received within the time limit, signal heart failure
+                self._beating = False
+                since_last_heartbeat = time.time() - request_time
+                self.call_handlers(since_last_heartbeat)
+                # and close/reopen the socket, because the REQ/REP cycle has been broken
+                self._create_socket()
+                continue
+
+    def pause(self):
+        """Pause the heartbeat."""
+        self._pause = True
+
+    def unpause(self):
+        """Unpause the heartbeat."""
+        self._pause = False
+
+    def is_beating(self):
+        """Is the heartbeat running and responsive (and not paused)."""
+        if self.is_alive() and not self._pause and self._beating:
+            return True
+        else:
+            return False
+
+    def stop(self):
+        """Stop the channel's event loop and join its thread."""
+        self._running = False
+        self.join()
+        self.close()
+
+    def close(self):
+        if self.socket is not None:
+            try:
+                self.socket.close(linger=0)
+            except Exception:
+                pass
+            self.socket = None
+
+    def call_handlers(self, since_last_heartbeat):
+        """This method is called in the ioloop thread when a message arrives.
+
+        Subclasses should override this method to handle incoming messages.
+        It is important to remember that this method is called in the thread
+        so that some logic must be done to ensure that the application level
+        handlers are called in the application thread.
+        """
+        pass
+
+
+HBChannelABC.register(HBChannel)

jupyter_client/channelsabc.py

@@ -0,0 +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:
+
+    `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

@@ -0,0 +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 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

@@ -0,0 +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:
+
+    `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

@@ -0,0 +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.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('jupyter_client.session.Session')
+    def _session_default(self):
+        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/kernelspec.py

@@ -0,0 +1,237 b''
+import io
+import json
+import os
+import shutil
+import sys
+
+pjoin = os.path.join
+
+from IPython.utils.path import get_ipython_dir
+from IPython.utils.py3compat import PY3
+from IPython.utils.traitlets import HasTraits, List, Unicode, Dict, Any, Set
+from IPython.config import Configurable
+from .launcher import make_ipkernel_cmd
+
+if os.name == 'nt':
+    programdata = os.environ.get('PROGRAMDATA', None)
+    if programdata:
+        SYSTEM_KERNEL_DIRS = [pjoin(programdata, 'jupyter', 'kernels')]
+    else:  # PROGRAMDATA is not defined by default on XP.
+        SYSTEM_KERNEL_DIRS = []
+else:
+    SYSTEM_KERNEL_DIRS = ["/usr/share/jupyter/kernels",
+                          "/usr/local/share/jupyter/kernels",
+                         ]
+
+NATIVE_KERNEL_NAME = 'python3' if PY3 else 'python2'
+
+def _pythonfirst(s):
+    "Sort key function that will put strings starting with 'python' first."
+    if s == NATIVE_KERNEL_NAME:
+        return '  ' + s  # Two spaces to sort this first of all
+    elif s.startswith('python'):
+        # Space is not valid in kernel names, so this should sort first
+        return ' ' + s
+    return s
+
+class KernelSpec(HasTraits):
+    argv = List()
+    display_name = Unicode()
+    language = Unicode()
+    env = Dict()
+    resource_dir = Unicode()
+
+    @classmethod
+    def from_resource_dir(cls, resource_dir):
+        """Create a KernelSpec object by reading kernel.json
+
+        Pass the path to the *directory* containing kernel.json.
+        """
+        kernel_file = pjoin(resource_dir, 'kernel.json')
+        with io.open(kernel_file, 'r', encoding='utf-8') as f:
+            kernel_dict = json.load(f)
+        return cls(resource_dir=resource_dir, **kernel_dict)
+
+    def to_dict(self):
+        d = dict(argv=self.argv,
+                 env=self.env,
+                 display_name=self.display_name,
+                 language=self.language,
+                )
+
+        return d
+
+    def to_json(self):
+        return json.dumps(self.to_dict())
+
+def _is_kernel_dir(path):
+    """Is ``path`` a kernel directory?"""
+    return os.path.isdir(path) and os.path.isfile(pjoin(path, 'kernel.json'))
+
+def _list_kernels_in(dir):
+    """Return a mapping of kernel names to resource directories from dir.
+
+    If dir is None or does not exist, returns an empty dict.
+    """
+    if dir is None or not os.path.isdir(dir):
+        return {}
+    return {f.lower(): pjoin(dir, f) for f in os.listdir(dir)
+                        if _is_kernel_dir(pjoin(dir, f))}
+
+class NoSuchKernel(KeyError):
+    def __init__(self, name):
+        self.name = name
+
+class KernelSpecManager(Configurable):
+    ipython_dir = Unicode()
+    def _ipython_dir_default(self):
+        return get_ipython_dir()
+
+    user_kernel_dir = Unicode()
+    def _user_kernel_dir_default(self):
+        return pjoin(self.ipython_dir, 'kernels')
+
+    @property
+    def env_kernel_dir(self):
+        return pjoin(sys.prefix, 'share', 'jupyter', 'kernels')
+
+    whitelist = Set(config=True,
+        help="""Whitelist of allowed kernel names.
+
+        By default, all installed kernels are allowed.
+        """
+    )
+    kernel_dirs = List(
+        help="List of kernel directories to search. Later ones take priority over earlier."
+    )
+    def _kernel_dirs_default(self):
+        dirs = SYSTEM_KERNEL_DIRS[:]
+        if self.env_kernel_dir not in dirs:
+            dirs.append(self.env_kernel_dir)
+        dirs.append(self.user_kernel_dir)
+        return dirs
+
+    @property
+    def _native_kernel_dict(self):
+        """Makes a kernel directory for the native kernel.
+
+        The native kernel is the kernel using the same Python runtime as this
+        process. This will put its information in the user kernels directory.
+        """
+        return {
+                'argv': make_ipkernel_cmd(),
+                'display_name': 'Python %i' % (3 if PY3 else 2),
+                'language': 'python',
+               }
+
+    @property
+    def _native_kernel_resource_dir(self):
+        return pjoin(os.path.dirname(__file__), 'resources')
+
+    def find_kernel_specs(self):
+        """Returns a dict mapping kernel names to resource directories."""
+        d = {}
+        for kernel_dir in self.kernel_dirs:
+            d.update(_list_kernels_in(kernel_dir))
+
+        d[NATIVE_KERNEL_NAME] = self._native_kernel_resource_dir
+        if self.whitelist:
+            # filter if there's a whitelist
+            d = {name:spec for name,spec in d.items() if name in self.whitelist}
+        return d
+        # TODO: Caching?
+
+    def get_kernel_spec(self, kernel_name):
+        """Returns a :class:`KernelSpec` instance for the given kernel_name.
+
+        Raises :exc:`NoSuchKernel` if the given kernel name is not found.
+        """
+        if kernel_name in {'python', NATIVE_KERNEL_NAME} and \
+            (not self.whitelist or kernel_name in self.whitelist):
+            return KernelSpec(resource_dir=self._native_kernel_resource_dir,
+                              **self._native_kernel_dict)
+
+        d = self.find_kernel_specs()
+        try:
+            resource_dir = d[kernel_name.lower()]
+        except KeyError:
+            raise NoSuchKernel(kernel_name)
+        return KernelSpec.from_resource_dir(resource_dir)
+
+    def _get_destination_dir(self, kernel_name, user=False):
+        if user:
+            return os.path.join(self.user_kernel_dir, kernel_name)
+        else:
+            if SYSTEM_KERNEL_DIRS:
+                return os.path.join(SYSTEM_KERNEL_DIRS[-1], kernel_name)
+            else:
+                raise EnvironmentError("No system kernel directory is available")
+
+
+    def install_kernel_spec(self, source_dir, kernel_name=None, user=False,
+                            replace=False):
+        """Install a kernel spec by copying its directory.
+
+        If ``kernel_name`` is not given, the basename of ``source_dir`` will
+        be used.
+
+        If ``user`` is False, it will attempt to install into the systemwide
+        kernel registry. If the process does not have appropriate permissions,
+        an :exc:`OSError` will be raised.
+
+        If ``replace`` is True, this will replace an existing kernel of the same
+        name. Otherwise, if the destination already exists, an :exc:`OSError`
+        will be raised.
+        """
+        if not kernel_name:
+            kernel_name = os.path.basename(source_dir)
+        kernel_name = kernel_name.lower()
+
+        destination = self._get_destination_dir(kernel_name, user=user)
+
+        if replace and os.path.isdir(destination):
+            shutil.rmtree(destination)
+
+        shutil.copytree(source_dir, destination)
+
+    def install_native_kernel_spec(self, user=False):
+        """Install the native kernel spec to the filesystem
+
+        This allows a Python 3 frontend to use a Python 2 kernel, or vice versa.
+        The kernelspec will be written pointing to the Python executable on
+        which this is run.
+
+        If ``user`` is False, it will attempt to install into the systemwide
+        kernel registry. If the process does not have appropriate permissions,
+        an :exc:`OSError` will be raised.
+        """
+        path = self._get_destination_dir(NATIVE_KERNEL_NAME, user=user)
+        os.makedirs(path, mode=0o755)
+        with open(pjoin(path, 'kernel.json'), 'w') as f:
+            json.dump(self._native_kernel_dict, f, indent=1)
+        copy_from = self._native_kernel_resource_dir
+        for file in os.listdir(copy_from):
+            shutil.copy(pjoin(copy_from, file), path)
+        return path
+
+def find_kernel_specs():
+    """Returns a dict mapping kernel names to resource directories."""
+    return KernelSpecManager().find_kernel_specs()
+
+def get_kernel_spec(kernel_name):
+    """Returns a :class:`KernelSpec` instance for the given kernel_name.
+
+    Raises KeyError if the given kernel name is not found.
+    """
+    return KernelSpecManager().get_kernel_spec(kernel_name)
+
+def install_kernel_spec(source_dir, kernel_name=None, user=False, replace=False):
+    return KernelSpecManager().install_kernel_spec(source_dir, kernel_name,
+                                                    user, replace)
+
+install_kernel_spec.__doc__ = KernelSpecManager.install_kernel_spec.__doc__
+
+def install_native_kernel_spec(user=False):
+    return KernelSpecManager().install_native_kernel_spec(user=user)
+
+install_native_kernel_spec.__doc__ = KernelSpecManager.install_native_kernel_spec.__doc__

jupyter_client/kernelspecapp.py

@@ -0,0 +1,142 b''
+
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
+
+import errno
+import os.path
+
+from IPython.config.application import Application
+from IPython.core.application import (
+    BaseIPythonApplication, base_flags, base_aliases
+)
+from IPython.utils.traitlets import Instance, Dict, Unicode, Bool
+
+from .kernelspec import KernelSpecManager, _pythonfirst
+
+class ListKernelSpecs(BaseIPythonApplication):
+    description = """List installed kernel specifications."""
+    kernel_spec_manager = Instance(KernelSpecManager)
+
+    # Not all of the base aliases are meaningful (e.g. profile)
+    aliases = {k: base_aliases[k] for k in ['ipython-dir', 'log-level']}
+    flags = {'debug': base_flags['debug'],}
+
+    def _kernel_spec_manager_default(self):
+        return KernelSpecManager(parent=self, ipython_dir=self.ipython_dir)
+
+    def start(self):
+        print("Available kernels:")
+        for kernelname in sorted(self.kernel_spec_manager.find_kernel_specs(),
+                                 key=_pythonfirst):
+            print("  %s" % kernelname)
+
+
+class InstallKernelSpec(BaseIPythonApplication):
+    description = """Install a kernel specification directory."""
+    kernel_spec_manager = Instance(KernelSpecManager)
+
+    def _kernel_spec_manager_default(self):
+        return KernelSpecManager(ipython_dir=self.ipython_dir)
+
+    sourcedir = Unicode()
+    kernel_name = Unicode("", config=True,
+        help="Install the kernel spec with this name"
+    )
+    def _kernel_name_default(self):
+        return os.path.basename(self.sourcedir)
+
+    user = Bool(False, config=True,
+        help="""
+        Try to install the kernel spec to the per-user directory instead of
+        the system or environment directory.
+        """
+    )
+    replace = Bool(False, config=True,
+        help="Replace any existing kernel spec with this name."
+    )
+
+    aliases = {'name': 'InstallKernelSpec.kernel_name'}
+    for k in ['ipython-dir', 'log-level']:
+        aliases[k] = base_aliases[k]
+
+    flags = {'user': ({'InstallKernelSpec': {'user': True}},
+                "Install to the per-user kernel registry"),
+             'replace': ({'InstallKernelSpec': {'replace': True}},
+                "Replace any existing kernel spec with this name."),
+             'debug': base_flags['debug'],
+            }
+
+    def parse_command_line(self, argv):
+        super(InstallKernelSpec, self).parse_command_line(argv)
+        # accept positional arg as profile name
+        if self.extra_args:
+            self.sourcedir = self.extra_args[0]
+        else:
+            print("No source directory specified.")
+            self.exit(1)
+
+    def start(self):
+        try:
+            self.kernel_spec_manager.install_kernel_spec(self.sourcedir,
+                                                 kernel_name=self.kernel_name,
+                                                 user=self.user,
+                                                 replace=self.replace,
+                                                )
+        except OSError as e:
+            if e.errno == errno.EACCES:
+                print("Permission denied")
+                self.exit(1)
+            elif e.errno == errno.EEXIST:
+                print("A kernel spec is already present at %s" % e.filename)
+                self.exit(1)
+            raise
+
+class InstallNativeKernelSpec(BaseIPythonApplication):
+    description = """Install the native kernel spec directory for this Python."""
+    kernel_spec_manager = Instance(KernelSpecManager)
+
+    def _kernel_spec_manager_default(self):
+        return KernelSpecManager(ipython_dir=self.ipython_dir)
+
+    user = Bool(False, config=True,
+        help="""
+        Try to install the kernel spec to the per-user directory instead of
+        the system or environment directory.
+        """
+    )
+
+    # Not all of the base aliases are meaningful (e.g. profile)
+    aliases = {k: base_aliases[k] for k in ['ipython-dir', 'log-level']}
+    flags = {'user': ({'InstallNativeKernelSpec': {'user': True}},
+                "Install to the per-user kernel registry"),
+             'debug': base_flags['debug'],
+            }
+
+    def start(self):
+        try:
+            self.kernel_spec_manager.install_native_kernel_spec(user=self.user)
+        except OSError as e:
+            self.exit(e)
+
+class KernelSpecApp(Application):
+    name = "ipython kernelspec"
+    description = """Manage IPython kernel specifications."""
+
+    subcommands = Dict({
+        'list': (ListKernelSpecs, ListKernelSpecs.description.splitlines()[0]),
+        'install': (InstallKernelSpec, InstallKernelSpec.description.splitlines()[0]),
+        'install-self': (InstallNativeKernelSpec, InstallNativeKernelSpec.description.splitlines()[0]),
+    })
+
+    aliases = {}
+    flags = {}
+
+    def start(self):
+        if self.subapp is None:
+            print("No subcommand specified. Must specify one of: %s"% list(self.subcommands))
+            print()
+            self.print_description()
+            self.print_subcommands()
+            self.exit(1)
+        else:
+            return self.subapp.start()

jupyter_client/launcher.py

@@ -0,0 +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 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

@@ -0,0 +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 jupyter_client import (
+    launch_kernel,
+    kernelspec,
+)
+from .connect import ConnectionFileMixin
+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('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 .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

@@ -0,0 +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:
+
+    `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

@@ -0,0 +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(
+        "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

@@ -0,0 +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('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/threaded.py

@@ -0,0 +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 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, allow_none=True)
+
+    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)

IPython/consoleapp.py

@@ -25,7 +25,8 b' from IPython.utils.traitlets import ('
     Dict, List, Unicode, CUnicode, CBool, Any
 )
 from IPython.kernel.zmq.session import Session
-from IPython.kernel.connect import ConnectionFileMixin
+from IPython.kernel import connect
+ConnectionFileMixin = connect.ConnectionFileMixin
 
 from IPython.utils.localinterfaces import localhost
 

IPython/kernel/__init__.py

@@ -1,11 +1,31 b''
-"""IPython kernels and associated utilities"""
+"""
+Shim to maintain backwards compatibility with old IPython.kernel imports.
+"""
+# Copyright (c) IPython Development Team.
+# Distributed under the terms of the Modified BSD License.
 
-# just for friendlier zmq version check
-from . import zmq
+import sys
+from warnings import warn
 
-from .connect import *
-from .launcher import *
-from .client import KernelClient
-from .manager import KernelManager, run_kernel
-from .blocking import BlockingKernelClient
-from .multikernelmanager import MultiKernelManager
+warn("The `IPython.kernel` package has been deprecated. "
+     "You should import from ipython_kernel or jupyter_client instead.")
+
+
+from IPython.utils.shimmodule import ShimModule
+
+# zmq subdir is gone
+sys.modules['IPython.kernel.zmq.session'] = ShimModule('session', mirror='jupyter_client.session')
+sys.modules['IPython.kernel.zmq'] = ShimModule('zmq', mirror='ipython_kernel')
+
+for pkg in ('comm', 'inprocess'):
+    sys.modules['IPython.kernel.%s' % pkg] = ShimModule(pkg, mirror='ipython_kernel.%s' % pkg)
+
+for pkg in ('ioloop', 'blocking'):
+    sys.modules['IPython.kernel.%s' % pkg] = ShimModule(pkg, mirror='jupyter_client.%s' % pkg)
+
+# required for `from IPython.kernel import PKG`
+from ipython_kernel import comm, inprocess
+from jupyter_client import ioloop, blocking
+# public API
+from ipython_kernel.connect import *
+from jupyter_client import *

IPython/kernel/__main__.py

@@ -1,3 +1,3 b''
 if __name__ == '__main__':
-    from IPython.kernel.zmq import kernelapp as app
+    from ipython_kernel.zmq import kernelapp as app
     app.launch_new_instance()

IPython/kernel/adapter.py

@@ -1,374 +1,1 b''
-"""Adapters for IPython msg spec versions."""
-
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the Modified BSD License.
-
-import json
-
-from IPython.core.release import kernel_protocol_version_info
-from IPython.utils.tokenutil import token_at_cursor
-
-
-def code_to_line(code, cursor_pos):
-    """Turn a multiline code block and cursor position into a single line
-    and new cursor position.
-    
-    For adapting ``complete_`` and ``object_info_request``.
-    """
-    if not code:
-        return "", 0
-    for line in code.splitlines(True):
-        n = len(line)
-        if cursor_pos > n:
-            cursor_pos -= n
-        else:
-            break
-    return line, cursor_pos
-
-
-class Adapter(object):
-    """Base class for adapting messages
-    
-    Override message_type(msg) methods to create adapters.
-    """
-    
-    msg_type_map = {}
-    
-    def update_header(self, msg):
-        return msg
-    
-    def update_metadata(self, msg):
-        return msg
-    
-    def update_msg_type(self, msg):
-        header = msg['header']
-        msg_type = header['msg_type']
-        if msg_type in self.msg_type_map:
-            msg['msg_type'] = header['msg_type'] = self.msg_type_map[msg_type]
-        return msg
-    
-    def handle_reply_status_error(self, msg):
-        """This will be called *instead of* the regular handler
-        
-        on any reply with status != ok
-        """
-        return msg
-    
-    def __call__(self, msg):
-        msg = self.update_header(msg)
-        msg = self.update_metadata(msg)
-        msg = self.update_msg_type(msg)
-        header = msg['header']
-        
-        handler = getattr(self, header['msg_type'], None)
-        if handler is None:
-            return msg
-        
-        # handle status=error replies separately (no change, at present)
-        if msg['content'].get('status', None) in {'error', 'aborted'}:
-            return self.handle_reply_status_error(msg)
-        return handler(msg)
-
-def _version_str_to_list(version):
-    """convert a version string to a list of ints
-    
-    non-int segments are excluded
-    """
-    v = []
-    for part in version.split('.'):
-        try:
-            v.append(int(part))
-        except ValueError:
-            pass
-    return v
-
-class V5toV4(Adapter):
-    """Adapt msg protocol v5 to v4"""
-    
-    version = '4.1'
-    
-    msg_type_map = {
-        'execute_result' : 'pyout',
-        'execute_input' : 'pyin',
-        'error' : 'pyerr',
-        'inspect_request' : 'object_info_request',
-        'inspect_reply' : 'object_info_reply',
-    }
-    
-    def update_header(self, msg):
-        msg['header'].pop('version', None)
-        return msg
-    
-    # shell channel
-    
-    def kernel_info_reply(self, msg):
-        v4c = {}
-        content = msg['content']
-        for key in ('language_version', 'protocol_version'):
-            if key in content:
-                v4c[key] = _version_str_to_list(content[key])
-        if content.get('implementation', '') == 'ipython' \
-            and 'implementation_version' in content:
-            v4c['ipython_version'] = _version_str_to_list(content['implementation_version'])
-        language_info = content.get('language_info', {})
-        language = language_info.get('name', '')
-        v4c.setdefault('language', language)
-        if 'version' in language_info:
-            v4c.setdefault('language_version', _version_str_to_list(language_info['version']))
-        msg['content'] = v4c
-        return msg
-    
-    def execute_request(self, msg):
-        content = msg['content']
-        content.setdefault('user_variables', [])
-        return msg
-    
-    def execute_reply(self, msg):
-        content = msg['content']
-        content.setdefault('user_variables', {})
-        # TODO: handle payloads
-        return msg
-    
-    def complete_request(self, msg):
-        content = msg['content']
-        code = content['code']
-        cursor_pos = content['cursor_pos']
-        line, cursor_pos = code_to_line(code, cursor_pos)
-        
-        new_content = msg['content'] = {}
-        new_content['text'] = ''
-        new_content['line'] = line
-        new_content['block'] = None
-        new_content['cursor_pos'] = cursor_pos
-        return msg
-    
-    def complete_reply(self, msg):
-        content = msg['content']
-        cursor_start = content.pop('cursor_start')
-        cursor_end = content.pop('cursor_end')
-        match_len = cursor_end - cursor_start
-        content['matched_text'] = content['matches'][0][:match_len]
-        content.pop('metadata', None)
-        return msg
-    
-    def object_info_request(self, msg):
-        content = msg['content']
-        code = content['code']
-        cursor_pos = content['cursor_pos']
-        line, _ = code_to_line(code, cursor_pos)
-        
-        new_content = msg['content'] = {}
-        new_content['oname'] = token_at_cursor(code, cursor_pos)
-        new_content['detail_level'] = content['detail_level']
-        return msg
-    
-    def object_info_reply(self, msg):
-        """inspect_reply can't be easily backward compatible"""
-        msg['content'] = {'found' : False, 'oname' : 'unknown'}
-        return msg
-    
-    # iopub channel
-    
-    def stream(self, msg):
-        content = msg['content']
-        content['data'] = content.pop('text')
-        return msg
-
-    def display_data(self, msg):
-        content = msg['content']
-        content.setdefault("source", "display")
-        data = content['data']
-        if 'application/json' in data:
-            try:
-                data['application/json'] = json.dumps(data['application/json'])
-            except Exception:
-                # warn?
-                pass
-        return msg
-    
-    # stdin channel
-    
-    def input_request(self, msg):
-        msg['content'].pop('password', None)
-        return msg
-
-
-class V4toV5(Adapter):
-    """Convert msg spec V4 to V5"""
-    version = '5.0'
-    
-    # invert message renames above
-    msg_type_map = {v:k for k,v in V5toV4.msg_type_map.items()}
-    
-    def update_header(self, msg):
-        msg['header']['version'] = self.version
-        return msg
-    
-    # shell channel
-    
-    def kernel_info_reply(self, msg):
-        content = msg['content']
-        for key in ('protocol_version', 'ipython_version'):
-            if key in content:
-                content[key] = '.'.join(map(str, content[key]))
-        
-        content.setdefault('protocol_version', '4.1')
-        
-        if content['language'].startswith('python') and 'ipython_version' in content:
-            content['implementation'] = 'ipython'
-            content['implementation_version'] = content.pop('ipython_version')
-        
-        language = content.pop('language')
-        language_info = content.setdefault('language_info', {})
-        language_info.setdefault('name', language)
-        if 'language_version' in content:
-            language_version = '.'.join(map(str, content.pop('language_version')))
-            language_info.setdefault('version', language_version)
-        
-        content['banner'] = ''
-        return msg
-    
-    def execute_request(self, msg):
-        content = msg['content']
-        user_variables = content.pop('user_variables', [])
-        user_expressions = content.setdefault('user_expressions', {})
-        for v in user_variables:
-            user_expressions[v] = v
-        return msg
-    
-    def execute_reply(self, msg):
-        content = msg['content']
-        user_expressions = content.setdefault('user_expressions', {})
-        user_variables = content.pop('user_variables', {})
-        if user_variables:
-            user_expressions.update(user_variables)
-
-        # Pager payloads became a mime bundle
-        for payload in content.get('payload', []):
-            if payload.get('source', None) == 'page' and ('text' in payload):
-                if 'data' not in payload:
-                    payload['data'] = {}
-                payload['data']['text/plain'] = payload.pop('text')
-
-        return msg
-    
-    def complete_request(self, msg):
-        old_content = msg['content']
-        
-        new_content = msg['content'] = {}
-        new_content['code'] = old_content['line']
-        new_content['cursor_pos'] = old_content['cursor_pos']
-        return msg
-    
-    def complete_reply(self, msg):
-        # complete_reply needs more context than we have to get cursor_start and end.
-        # use special end=null to indicate current cursor position and negative offset
-        # for start relative to the cursor.
-        # start=None indicates that start == end (accounts for no -0).
-        content = msg['content']
-        new_content = msg['content'] = {'status' : 'ok'}
-        new_content['matches'] = content['matches']
-        if content['matched_text']:
-            new_content['cursor_start'] = -len(content['matched_text'])
-        else:
-            # no -0, use None to indicate that start == end
-            new_content['cursor_start'] = None
-        new_content['cursor_end'] = None
-        new_content['metadata'] = {}
-        return msg
-    
-    def inspect_request(self, msg):
-        content = msg['content']
-        name = content['oname']
-        
-        new_content = msg['content'] = {}
-        new_content['code'] = name
-        new_content['cursor_pos'] = len(name)
-        new_content['detail_level'] = content['detail_level']
-        return msg
-    
-    def inspect_reply(self, msg):
-        """inspect_reply can't be easily backward compatible"""
-        content = msg['content']
-        new_content = msg['content'] = {'status' : 'ok'}
-        found = new_content['found'] = content['found']
-        new_content['name'] = content['oname']
-        new_content['data'] = data = {}
-        new_content['metadata'] = {}
-        if found:
-            lines = []
-            for key in ('call_def', 'init_definition', 'definition'):
-                if content.get(key, False):
-                    lines.append(content[key])
-                    break
-            for key in ('call_docstring', 'init_docstring', 'docstring'):
-                if content.get(key, False):
-                    lines.append(content[key])
-                    break
-            if not lines:
-                lines.append("<empty docstring>")
-            data['text/plain'] = '\n'.join(lines)
-        return msg
-    
-    # iopub channel
-    
-    def stream(self, msg):
-        content = msg['content']
-        content['text'] = content.pop('data')
-        return msg
-
-    def display_data(self, msg):
-        content = msg['content']
-        content.pop("source", None)
-        data = content['data']
-        if 'application/json' in data:
-            try:
-                data['application/json'] = json.loads(data['application/json'])
-            except Exception:
-                # warn?
-                pass
-        return msg
-    
-    # stdin channel
-    
-    def input_request(self, msg):
-        msg['content'].setdefault('password', False)
-        return msg
-    
-
-
-def adapt(msg, to_version=kernel_protocol_version_info[0]):
-    """Adapt a single message to a target version
-    
-    Parameters
-    ----------
-    
-    msg : dict
-        An IPython message.
-    to_version : int, optional
-        The target major version.
-        If unspecified, adapt to the current version for IPython.
-    
-    Returns
-    -------
-    
-    msg : dict
-        An IPython message appropriate in the new version.
-    """
-    header = msg['header']
-    if 'version' in header:
-        from_version = int(header['version'].split('.')[0])
-    else:
-        # assume last version before adding the key to the header
-        from_version = 4
-    adapter = adapters.get((from_version, to_version), None)
-    if adapter is None:
-        return msg
-    return adapter(msg)
-
-
-# one adapter per major version from,to
-adapters = {
-    (5,4) : V5toV4(),
-    (4,5) : V4toV5(),
-}
+from jupyter_client.adapter import *

IPython/kernel/channels.py

@@ -1,203 +1,1 b''
-"""Base classes to manage a Client's interaction with a running kernel"""
-
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the Modified BSD License.
-
-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 IPython.core.release import kernel_protocol_version_info
-
-from .channelsabc import HBChannelABC
-
-#-----------------------------------------------------------------------------
-# Constants and exceptions
-#-----------------------------------------------------------------------------
-
-major_protocol_version = kernel_protocol_version_info[0]
-
-class InvalidPortNumber(Exception):
-    pass
-
-class HBChannel(Thread):
-    """The heartbeat channel which monitors the kernel heartbeat.
-
-    Note that the heartbeat channel is paused by default. As long as you start
-    this channel, the kernel manager will ensure that it is paused and un-paused
-    as appropriate.
-    """
-    context = None
-    session = None
-    socket = None
-    address = None
-    _exiting = False
-
-    time_to_dead = 1.
-    poller = None
-    _running = None
-    _pause = None
-    _beating = None
-
-    def __init__(self, context=None, session=None, address=None):
-        """Create the heartbeat monitor thread.
-
-        Parameters
-        ----------
-        context : :class:`zmq.Context`
-            The ZMQ context to use.
-        session : :class:`session.Session`
-            The session to use.
-        address : zmq url
-            Standard (ip, port) tuple that the kernel is listening on.
-        """
-        super(HBChannel, self).__init__()
-        self.daemon = True
-
-        self.context = context
-        self.session = session
-        if isinstance(address, tuple):
-            if address[1] == 0:
-                message = 'The port number for a channel cannot be 0.'
-                raise InvalidPortNumber(message)
-            address = "tcp://%s:%i" % address
-        self.address = address
-        atexit.register(self._notice_exit)
-
-        self._running = False
-        self._pause = True
-        self.poller = zmq.Poller()
-
-    def _notice_exit(self):
-        self._exiting = True
-
-    def _create_socket(self):
-        if self.socket is not None:
-            # close previous socket, before opening a new one
-            self.poller.unregister(self.socket)
-            self.socket.close()
-        self.socket = self.context.socket(zmq.REQ)
-        self.socket.linger = 1000
-        self.socket.connect(self.address)
-
-        self.poller.register(self.socket, zmq.POLLIN)
-
-    def _poll(self, start_time):
-        """poll for heartbeat replies until we reach self.time_to_dead.
-
-        Ignores interrupts, and returns the result of poll(), which
-        will be an empty list if no messages arrived before the timeout,
-        or the event tuple if there is a message to receive.
-        """
-
-        until_dead = self.time_to_dead - (time.time() - start_time)
-        # ensure poll at least once
-        until_dead = max(until_dead, 1e-3)
-        events = []
-        while True:
-            try:
-                events = self.poller.poll(1000 * until_dead)
-            except ZMQError as e:
-                if e.errno == errno.EINTR:
-                    # ignore interrupts during heartbeat
-                    # this may never actually happen
-                    until_dead = self.time_to_dead - (time.time() - start_time)
-                    until_dead = max(until_dead, 1e-3)
-                    pass
-                else:
-                    raise
-            except Exception:
-                if self._exiting:
-                    break
-                else:
-                    raise
-            else:
-                break
-        return events
-
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self._create_socket()
-        self._running = True
-        self._beating = True
-
-        while self._running:
-            if self._pause:
-                # just sleep, and skip the rest of the loop
-                time.sleep(self.time_to_dead)
-                continue
-
-            since_last_heartbeat = 0.0
-            # io.rprint('Ping from HB channel') # dbg
-            # no need to catch EFSM here, because the previous event was
-            # either a recv or connect, which cannot be followed by EFSM
-            self.socket.send(b'ping')
-            request_time = time.time()
-            ready = self._poll(request_time)
-            if ready:
-                self._beating = True
-                # the poll above guarantees we have something to recv
-                self.socket.recv()
-                # sleep the remainder of the cycle
-                remainder = self.time_to_dead - (time.time() - request_time)
-                if remainder > 0:
-                    time.sleep(remainder)
-                continue
-            else:
-                # nothing was received within the time limit, signal heart failure
-                self._beating = False
-                since_last_heartbeat = time.time() - request_time
-                self.call_handlers(since_last_heartbeat)
-                # and close/reopen the socket, because the REQ/REP cycle has been broken
-                self._create_socket()
-                continue
-
-    def pause(self):
-        """Pause the heartbeat."""
-        self._pause = True
-
-    def unpause(self):
-        """Unpause the heartbeat."""
-        self._pause = False
-
-    def is_beating(self):
-        """Is the heartbeat running and responsive (and not paused)."""
-        if self.is_alive() and not self._pause and self._beating:
-            return True
-        else:
-            return False
-
-    def stop(self):
-        """Stop the channel's event loop and join its thread."""
-        self._running = False
-        self.join()
-        self.close()
-
-    def close(self):
-        if self.socket is not None:
-            try:
-                self.socket.close(linger=0)
-            except Exception:
-                pass
-            self.socket = None
-
-    def call_handlers(self, since_last_heartbeat):
-        """This method is called in the ioloop thread when a message arrives.
-
-        Subclasses should override this method to handle incoming messages.
-        It is important to remember that this method is called in the thread
-        so that some logic must be done to ensure that the application level
-        handlers are called in the application thread.
-        """
-        pass
-
-
-HBChannelABC.register(HBChannel)
+from jupyter_client.channels import *

IPython/kernel/channelsabc.py

@@ -1,49 +1,1 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`
-    """
-
-    @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
+from jupyter_client.channelsabc import *

IPython/kernel/client.py

@@ -1,390 +1,1 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 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)
+from jupyter_client.client import *

IPython/kernel/clientabc.py

@@ -1,80 +1,1 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`
-    """
-
-    @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
+from jupyter_client.clientabc import *

IPython/kernel/connect.py

@@ -1,576 +1,2 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
-        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')
-    def _session_default(self):
-        from IPython.kernel.zmq.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',
-]
+from ipython_kernel.connect import *
+from jupyter_client.connect import *

IPython/kernel/kernelspec.py

@@ -1,237 +1,1 b''
-import io
-import json
-import os
-import shutil
-import sys
-
-pjoin = os.path.join
-
-from IPython.utils.path import get_ipython_dir
-from IPython.utils.py3compat import PY3
-from IPython.utils.traitlets import HasTraits, List, Unicode, Dict, Any, Set
-from IPython.config import Configurable
-from .launcher import make_ipkernel_cmd
-
-if os.name == 'nt':
-    programdata = os.environ.get('PROGRAMDATA', None)
-    if programdata:
-        SYSTEM_KERNEL_DIRS = [pjoin(programdata, 'jupyter', 'kernels')]
-    else:  # PROGRAMDATA is not defined by default on XP.
-        SYSTEM_KERNEL_DIRS = []
-else:
-    SYSTEM_KERNEL_DIRS = ["/usr/share/jupyter/kernels",
-                          "/usr/local/share/jupyter/kernels",
-                         ]
-    
-NATIVE_KERNEL_NAME = 'python3' if PY3 else 'python2'
-
-def _pythonfirst(s):
-    "Sort key function that will put strings starting with 'python' first."
-    if s == NATIVE_KERNEL_NAME:
-        return '  ' + s  # Two spaces to sort this first of all
-    elif s.startswith('python'):
-        # Space is not valid in kernel names, so this should sort first
-        return ' ' + s
-    return s
-
-class KernelSpec(HasTraits):
-    argv = List()
-    display_name = Unicode()
-    language = Unicode()
-    env = Dict()
-    resource_dir = Unicode()
-    
-    @classmethod
-    def from_resource_dir(cls, resource_dir):
-        """Create a KernelSpec object by reading kernel.json
-        
-        Pass the path to the *directory* containing kernel.json.
-        """
-        kernel_file = pjoin(resource_dir, 'kernel.json')
-        with io.open(kernel_file, 'r', encoding='utf-8') as f:
-            kernel_dict = json.load(f)
-        return cls(resource_dir=resource_dir, **kernel_dict)
-    
-    def to_dict(self):
-        d = dict(argv=self.argv,
-                 env=self.env,
-                 display_name=self.display_name,
-                 language=self.language,
-                )
-
-        return d
-
-    def to_json(self):
-        return json.dumps(self.to_dict())
-
-def _is_kernel_dir(path):
-    """Is ``path`` a kernel directory?"""
-    return os.path.isdir(path) and os.path.isfile(pjoin(path, 'kernel.json'))
-
-def _list_kernels_in(dir):
-    """Return a mapping of kernel names to resource directories from dir.
-    
-    If dir is None or does not exist, returns an empty dict.
-    """
-    if dir is None or not os.path.isdir(dir):
-        return {}
-    return {f.lower(): pjoin(dir, f) for f in os.listdir(dir)
-                        if _is_kernel_dir(pjoin(dir, f))}
-
-class NoSuchKernel(KeyError):
-    def __init__(self, name):
-        self.name = name
-
-class KernelSpecManager(Configurable):
-    ipython_dir = Unicode()
-    def _ipython_dir_default(self):
-        return get_ipython_dir()
-
-    user_kernel_dir = Unicode()
-    def _user_kernel_dir_default(self):
-        return pjoin(self.ipython_dir, 'kernels')
-
-    @property
-    def env_kernel_dir(self):
-        return pjoin(sys.prefix, 'share', 'jupyter', 'kernels')
-    
-    whitelist = Set(config=True,
-        help="""Whitelist of allowed kernel names.
-        
-        By default, all installed kernels are allowed.
-        """
-    )
-    kernel_dirs = List(
-        help="List of kernel directories to search. Later ones take priority over earlier."    
-    )
-    def _kernel_dirs_default(self):
-        dirs = SYSTEM_KERNEL_DIRS[:]
-        if self.env_kernel_dir not in dirs:
-            dirs.append(self.env_kernel_dir)
-        dirs.append(self.user_kernel_dir)
-        return dirs
-
-    @property
-    def _native_kernel_dict(self):
-        """Makes a kernel directory for the native kernel.
-        
-        The native kernel is the kernel using the same Python runtime as this
-        process. This will put its information in the user kernels directory.
-        """
-        return {
-                'argv': make_ipkernel_cmd(),
-                'display_name': 'Python %i' % (3 if PY3 else 2),
-                'language': 'python',
-               }
-
-    @property
-    def _native_kernel_resource_dir(self):
-        return pjoin(os.path.dirname(__file__), 'resources')
-
-    def find_kernel_specs(self):
-        """Returns a dict mapping kernel names to resource directories."""
-        d = {}
-        for kernel_dir in self.kernel_dirs:
-            d.update(_list_kernels_in(kernel_dir))
-
-        d[NATIVE_KERNEL_NAME] = self._native_kernel_resource_dir
-        if self.whitelist:
-            # filter if there's a whitelist
-            d = {name:spec for name,spec in d.items() if name in self.whitelist}
-        return d
-        # TODO: Caching?
-
-    def get_kernel_spec(self, kernel_name):
-        """Returns a :class:`KernelSpec` instance for the given kernel_name.
-        
-        Raises :exc:`NoSuchKernel` if the given kernel name is not found.
-        """
-        if kernel_name in {'python', NATIVE_KERNEL_NAME} and \
-            (not self.whitelist or kernel_name in self.whitelist):
-            return KernelSpec(resource_dir=self._native_kernel_resource_dir,
-                              **self._native_kernel_dict)
-
-        d = self.find_kernel_specs()
-        try:
-            resource_dir = d[kernel_name.lower()]
-        except KeyError:
-            raise NoSuchKernel(kernel_name)
-        return KernelSpec.from_resource_dir(resource_dir)
-    
-    def _get_destination_dir(self, kernel_name, user=False):
-        if user:
-            return os.path.join(self.user_kernel_dir, kernel_name)
-        else:
-            if SYSTEM_KERNEL_DIRS:
-                return os.path.join(SYSTEM_KERNEL_DIRS[-1], kernel_name)
-            else:
-                raise EnvironmentError("No system kernel directory is available")
-
-
-    def install_kernel_spec(self, source_dir, kernel_name=None, user=False,
-                            replace=False):
-        """Install a kernel spec by copying its directory.
-        
-        If ``kernel_name`` is not given, the basename of ``source_dir`` will
-        be used.
-        
-        If ``user`` is False, it will attempt to install into the systemwide
-        kernel registry. If the process does not have appropriate permissions,
-        an :exc:`OSError` will be raised.
-        
-        If ``replace`` is True, this will replace an existing kernel of the same
-        name. Otherwise, if the destination already exists, an :exc:`OSError`
-        will be raised.
-        """
-        if not kernel_name:
-            kernel_name = os.path.basename(source_dir)
-        kernel_name = kernel_name.lower()
-        
-        destination = self._get_destination_dir(kernel_name, user=user)
-
-        if replace and os.path.isdir(destination):
-            shutil.rmtree(destination)
-
-        shutil.copytree(source_dir, destination)
-
-    def install_native_kernel_spec(self, user=False):
-        """Install the native kernel spec to the filesystem
-        
-        This allows a Python 3 frontend to use a Python 2 kernel, or vice versa.
-        The kernelspec will be written pointing to the Python executable on
-        which this is run.
-        
-        If ``user`` is False, it will attempt to install into the systemwide
-        kernel registry. If the process does not have appropriate permissions, 
-        an :exc:`OSError` will be raised.
-        """
-        path = self._get_destination_dir(NATIVE_KERNEL_NAME, user=user)
-        os.makedirs(path, mode=0o755)
-        with open(pjoin(path, 'kernel.json'), 'w') as f:
-            json.dump(self._native_kernel_dict, f, indent=1)
-        copy_from = self._native_kernel_resource_dir
-        for file in os.listdir(copy_from):
-            shutil.copy(pjoin(copy_from, file), path)
-        return path
-
-def find_kernel_specs():
-    """Returns a dict mapping kernel names to resource directories."""
-    return KernelSpecManager().find_kernel_specs()
-
-def get_kernel_spec(kernel_name):
-    """Returns a :class:`KernelSpec` instance for the given kernel_name.
-    
-    Raises KeyError if the given kernel name is not found.
-    """
-    return KernelSpecManager().get_kernel_spec(kernel_name)
-
-def install_kernel_spec(source_dir, kernel_name=None, user=False, replace=False):
-    return KernelSpecManager().install_kernel_spec(source_dir, kernel_name,
-                                                    user, replace)
-
-install_kernel_spec.__doc__ = KernelSpecManager.install_kernel_spec.__doc__
-
-def install_native_kernel_spec(user=False):
-    return KernelSpecManager().install_native_kernel_spec(user=user)
-
-install_native_kernel_spec.__doc__ = KernelSpecManager.install_native_kernel_spec.__doc__
+from jupyter_client.kernelspec import *

IPython/kernel/kernelspecapp.py

@@ -1,142 +1,1 b''
-
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the Modified BSD License.
-
-import errno
-import os.path
-
-from IPython.config.application import Application
-from IPython.core.application import (
-    BaseIPythonApplication, base_flags, base_aliases
-)
-from IPython.utils.traitlets import Instance, Dict, Unicode, Bool
-
-from .kernelspec import KernelSpecManager, _pythonfirst
-
-class ListKernelSpecs(BaseIPythonApplication):
-    description = """List installed kernel specifications."""
-    kernel_spec_manager = Instance(KernelSpecManager)
-
-    # Not all of the base aliases are meaningful (e.g. profile)
-    aliases = {k: base_aliases[k] for k in ['ipython-dir', 'log-level']}
-    flags = {'debug': base_flags['debug'],}
-
-    def _kernel_spec_manager_default(self):
-        return KernelSpecManager(parent=self, ipython_dir=self.ipython_dir)
-
-    def start(self):
-        print("Available kernels:")
-        for kernelname in sorted(self.kernel_spec_manager.find_kernel_specs(),
-                                 key=_pythonfirst):
-            print("  %s" % kernelname)
-
-
-class InstallKernelSpec(BaseIPythonApplication):
-    description = """Install a kernel specification directory."""
-    kernel_spec_manager = Instance(KernelSpecManager)
-
-    def _kernel_spec_manager_default(self):
-        return KernelSpecManager(ipython_dir=self.ipython_dir)
-
-    sourcedir = Unicode()
-    kernel_name = Unicode("", config=True,
-        help="Install the kernel spec with this name"
-    )
-    def _kernel_name_default(self):
-        return os.path.basename(self.sourcedir)
-
-    user = Bool(False, config=True,
-        help="""
-        Try to install the kernel spec to the per-user directory instead of
-        the system or environment directory.
-        """
-    )
-    replace = Bool(False, config=True,
-        help="Replace any existing kernel spec with this name."
-    )
-
-    aliases = {'name': 'InstallKernelSpec.kernel_name'}
-    for k in ['ipython-dir', 'log-level']:
-        aliases[k] = base_aliases[k]
-
-    flags = {'user': ({'InstallKernelSpec': {'user': True}},
-                "Install to the per-user kernel registry"),
-             'replace': ({'InstallKernelSpec': {'replace': True}},
-                "Replace any existing kernel spec with this name."),
-             'debug': base_flags['debug'],
-            }
-
-    def parse_command_line(self, argv):
-        super(InstallKernelSpec, self).parse_command_line(argv)
-        # accept positional arg as profile name
-        if self.extra_args:
-            self.sourcedir = self.extra_args[0]
-        else:
-            print("No source directory specified.")
-            self.exit(1)
-
-    def start(self):
-        try:
-            self.kernel_spec_manager.install_kernel_spec(self.sourcedir,
-                                                 kernel_name=self.kernel_name,
-                                                 user=self.user,
-                                                 replace=self.replace,
-                                                )
-        except OSError as e:
-            if e.errno == errno.EACCES:
-                print("Permission denied")
-                self.exit(1)
-            elif e.errno == errno.EEXIST:
-                print("A kernel spec is already present at %s" % e.filename)
-                self.exit(1)
-            raise
-
-class InstallNativeKernelSpec(BaseIPythonApplication):
-    description = """Install the native kernel spec directory for this Python."""
-    kernel_spec_manager = Instance(KernelSpecManager)
-
-    def _kernel_spec_manager_default(self):
-        return KernelSpecManager(ipython_dir=self.ipython_dir)
-
-    user = Bool(False, config=True,
-        help="""
-        Try to install the kernel spec to the per-user directory instead of
-        the system or environment directory.
-        """
-    )
-
-    # Not all of the base aliases are meaningful (e.g. profile)
-    aliases = {k: base_aliases[k] for k in ['ipython-dir', 'log-level']}
-    flags = {'user': ({'InstallNativeKernelSpec': {'user': True}},
-                "Install to the per-user kernel registry"),
-             'debug': base_flags['debug'],
-            }
-
-    def start(self):
-        try:
-            self.kernel_spec_manager.install_native_kernel_spec(user=self.user)
-        except OSError as e:
-            self.exit(e)
-
-class KernelSpecApp(Application):
-    name = "ipython kernelspec"
-    description = """Manage IPython kernel specifications."""
-
-    subcommands = Dict({
-        'list': (ListKernelSpecs, ListKernelSpecs.description.splitlines()[0]),
-        'install': (InstallKernelSpec, InstallKernelSpec.description.splitlines()[0]),
-        'install-self': (InstallNativeKernelSpec, InstallNativeKernelSpec.description.splitlines()[0]),
-    })
-
-    aliases = {}
-    flags = {}
-
-    def start(self):
-        if self.subapp is None:
-            print("No subcommand specified. Must specify one of: %s"% list(self.subcommands))
-            print()
-            self.print_description()
-            self.print_subcommands()
-            self.exit(1)
-        else:
-            return self.subapp.start()
+from jupyter_client.kernelspecapp import *

IPython/kernel/launcher.py

@@ -1,226 +1,1 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
-        # 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',
-]
+from jupyter_client.launcher import *

IPython/kernel/manager.py

@@ -1,442 +1,1 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 (
-    launch_kernel,
-    kernelspec,
-)
-from .connect import ConnectionFileMixin
-from .zmq.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_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
-                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)
+from jupyter_client.manager import *

IPython/kernel/managerabc.py

@@ -1,53 +1,1 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`
-    """
-
-    @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
+from jupyter_client.managerabc import *

IPython/kernel/multikernelmanager.py

@@ -1,319 +1,1 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,
-        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
-        """
+from jupyter_client.multikernelmanager import *

IPython/kernel/restarter.py

@@ -1,111 +1,1 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')
-    
-    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
+from jupyter_client.restarter import *

IPython/kernel/threaded.py

@@ -1,230 +1,1 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
-
-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)
+from jupyter_client.threaded import *

IPython/testing/iptest.py

@@ -172,6 +172,8 b' class TestSection(object):'
 
 shims = {
     'parallel': 'ipython_parallel',
+    'kernel': 'ipython_kernel',
+    'kernel.inprocess': 'ipython_kernel.inprocess',
 }
 
 # Name -> (include, exclude, dependencies_met)
@@ -230,10 +232,10 b" sec.requires('zmq')"
 # The in-process kernel tests are done in a separate section
 sec.exclude('inprocess')
 # importing gtk sets the default encoding, which we want to avoid
-sec.exclude('zmq.gui.gtkembed')
-sec.exclude('zmq.gui.gtk3embed')
+sec.exclude('gui.gtkembed')
+sec.exclude('gui.gtk3embed')
 if not have['matplotlib']:
-    sec.exclude('zmq.pylab')
+    sec.exclude('pylab')
 
 # kernel.inprocess:
 test_sections['kernel.inprocess'].requires('zmq')

IPython/utils/shimmodule.py

@@ -3,7 +3,6 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-import sys
 import types
 
 class ShimModule(types.ModuleType):
@@ -11,8 +10,11 b' class ShimModule(types.ModuleType):'
     def __init__(self, *args, **kwargs):
         self._mirror = kwargs.pop("mirror")
         super(ShimModule, self).__init__(*args, **kwargs)
-        if sys.version_info >= (3,4):
-            self.__spec__ = __import__(self._mirror).__spec__
+
+    @property
+    def __spec__(self):
+        """Don't produce __spec__ until requested"""
+        return __import__(self._mirror).__spec__
 
     def __getattr__(self, key):
         # Use the equivalent of import_item(name), see below

ipython_kernel/comm/comm.py

@@ -9,7 +9,7 b' import uuid'
 from zmq.eventloop.ioloop import IOLoop
 
 from IPython.config import LoggingConfigurable
-from IPython.kernel.zmq.kernelbase import Kernel
+from ipython_kernel.kernelbase import Kernel
 
 from IPython.utils.jsonutil import json_clean
 from IPython.utils.traitlets import Instance, Unicode, Bytes, Bool, Dict, Any
@@ -20,40 +20,40 b' class Comm(LoggingConfigurable):'
     # If this is instantiated by a non-IPython kernel, shell will be None
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
-    kernel = Instance('IPython.kernel.zmq.kernelbase.Kernel')
+    kernel = Instance('ipython_kernel.kernelbase.Kernel')
     def _kernel_default(self):
         if Kernel.initialized():
             return Kernel.instance()
-    
+
     iopub_socket = Any()
     def _iopub_socket_default(self):
         return self.kernel.iopub_socket
-    session = Instance('IPython.kernel.zmq.session.Session')
+    session = Instance('ipython_kernel.session.Session')
     def _session_default(self):
         if self.kernel is not None:
             return self.kernel.session
-    
+
     target_name = Unicode('comm')
     target_module = Unicode(None, allow_none=True, help="""requirejs module from
         which to load comm target.""")
-    
+
     topic = Bytes()
     def _topic_default(self):
         return ('comm-%s' % self.comm_id).encode('ascii')
-    
+
     _open_data = Dict(help="data dict, if any, to be included in comm_open")
     _close_data = Dict(help="data dict, if any, to be included in comm_close")
-    
+
     _msg_callback = Any()
     _close_callback = Any()
-    
+
     _closed = Bool(True)
     comm_id = Unicode()
     def _comm_id_default(self):
         return uuid.uuid4().hex
-    
+
     primary = Bool(True, help="Am I the primary or secondary Comm?")
-    
+
     def __init__(self, target_name='', data=None, **kwargs):
         if target_name:
             kwargs['target_name'] = target_name
@@ -63,7 +63,7 b' class Comm(LoggingConfigurable):'
             self.open(data)
         else:
             self._closed = False
-    
+
     def _publish_msg(self, msg_type, data=None, metadata=None, buffers=None, **keys):
         """Helper for sending a comm message on IOPub"""
         if threading.current_thread().name != 'MainThread' and IOLoop.initialized():
@@ -80,13 +80,13 b' class Comm(LoggingConfigurable):'
             ident=self.topic,
             buffers=buffers,
         )
-    
+
     def __del__(self):
         """trigger close on gc"""
         self.close()
-    
+
     # publishing messages
-    
+
     def open(self, data=None, metadata=None, buffers=None):
         """Open the frontend-side version of this comm"""
         if data is None:
@@ -107,7 +107,7 b' class Comm(LoggingConfigurable):'
         except:
             comm_manager.unregister_comm(self)
             raise
-    
+
     def close(self, data=None, metadata=None, buffers=None):
         """Close the frontend-side version of this comm"""
         if self._closed:
@@ -120,41 +120,41 b' class Comm(LoggingConfigurable):'
             data=data, metadata=metadata, buffers=buffers,
         )
         self.kernel.comm_manager.unregister_comm(self)
-    
+
     def send(self, data=None, metadata=None, buffers=None):
         """Send a message to the frontend-side version of this comm"""
         self._publish_msg('comm_msg',
             data=data, metadata=metadata, buffers=buffers,
         )
-    
+
     # registering callbacks
-    
+
     def on_close(self, callback):
         """Register a callback for comm_close
-        
+
         Will be called with the `data` of the close message.
-        
+
         Call `on_close(None)` to disable an existing callback.
         """
         self._close_callback = callback
-    
+
     def on_msg(self, callback):
         """Register a callback for comm_msg
-        
+
         Will be called with the `data` of any comm_msg messages.
-        
+
         Call `on_msg(None)` to disable an existing callback.
         """
         self._msg_callback = callback
-    
+
     # handling of incoming messages
-    
+
     def handle_close(self, msg):
         """Handle a comm_close message"""
         self.log.debug("handle_close[%s](%s)", self.comm_id, msg)
         if self._close_callback:
             self._close_callback(msg)
-    
+
     def handle_msg(self, msg):
         """Handle a comm_msg message"""
         self.log.debug("handle_msg[%s](%s)", self.comm_id, msg)

ipython_kernel/comm/manager.py

@@ -18,7 +18,7 b' from .comm import Comm'
 
 def lazy_keys(dikt):
     """Return lazy-evaluated string representation of a dictionary's keys
-    
+
     Key list is only constructed if it will actually be used.
     Used for debug-logging.
     """
@@ -27,43 +27,43 b' def lazy_keys(dikt):'
 
 class CommManager(LoggingConfigurable):
     """Manager for Comms in the Kernel"""
-    
+
     # If this is instantiated by a non-IPython kernel, shell will be None
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
-    kernel = Instance('IPython.kernel.zmq.kernelbase.Kernel')
+    kernel = Instance('ipython_kernel.kernelbase.Kernel')
 
     iopub_socket = Any()
     def _iopub_socket_default(self):
         return self.kernel.iopub_socket
-    session = Instance('IPython.kernel.zmq.session.Session')
+    session = Instance('ipython_kernel.session.Session')
     def _session_default(self):
         return self.kernel.session
-    
+
     comms = Dict()
     targets = Dict()
-    
+
     # Public APIs
-    
+
     def register_target(self, target_name, f):
         """Register a callable f for a given target name
-        
+
         f will be called with two arguments when a comm_open message is received with `target`:
-        
+
         - the Comm instance
         - the `comm_open` message itself.
-        
+
         f can be a Python callable or an import string for one.
         """
         if isinstance(f, string_types):
             f = import_item(f)
-        
+
         self.targets[target_name] = f
-    
+
     def unregister_target(self, target_name, f):
         """Unregister a callable registered with register_target"""
         return self.targets.pop(target_name);
-    
+
     def register_comm(self, comm):
         """Register a new comm"""
         comm_id = comm.comm_id
@@ -72,17 +72,17 b' class CommManager(LoggingConfigurable):'
         comm.iopub_socket = self.iopub_socket
         self.comms[comm_id] = comm
         return comm_id
-    
+
     def unregister_comm(self, comm):
         """Unregister a comm, and close its counterpart"""
         # unlike get_comm, this should raise a KeyError
         comm = self.comms.pop(comm.comm_id)
-    
+
     def get_comm(self, comm_id):
         """Get a comm with a particular id
-        
+
         Returns the comm if found, otherwise None.
-        
+
         This will not raise an error,
         it will log messages if the comm cannot be found.
         """
@@ -93,7 +93,7 b' class CommManager(LoggingConfigurable):'
         # call, because we store weakrefs
         comm = self.comms[comm_id]
         return comm
-    
+
     # Message handlers
     def comm_open(self, stream, ident, msg):
         """Handler for comm_open messages"""
@@ -116,14 +116,14 b' class CommManager(LoggingConfigurable):'
                 return
             except Exception:
                 self.log.error("Exception opening comm with target: %s", target_name, exc_info=True)
-        
+
         # Failure.
         try:
             comm.close()
         except:
-            self.log.error("""Could not close comm during `comm_open` failure 
+            self.log.error("""Could not close comm during `comm_open` failure
                 clean-up.  The comm may not have been opened yet.""", exc_info=True)
-    
+
     def comm_msg(self, stream, ident, msg):
         """Handler for comm_msg messages"""
         content = msg['content']
@@ -136,7 +136,7 b' class CommManager(LoggingConfigurable):'
             comm.handle_msg(msg)
         except Exception:
             self.log.error("Exception in comm_msg for %s", comm_id, exc_info=True)
-    
+
     def comm_close(self, stream, ident, msg):
         """Handler for comm_close messages"""
         content = msg['content']
@@ -147,7 +147,7 b' class CommManager(LoggingConfigurable):'
             self.log.debug("No such comm to close: %s", comm_id)
             return
         del self.comms[comm_id]
-        
+
         try:
             comm.handle_close(msg)
         except Exception:

ipython_kernel/datapub.py

@@ -13,11 +13,11 b''
 #-----------------------------------------------------------------------------
 
 from IPython.config import Configurable
-from IPython.kernel.inprocess.socket import SocketABC
+from ipython_kernel.inprocess.socket import SocketABC
 from IPython.utils.jsonutil import json_clean
 from IPython.utils.traitlets import Instance, Dict, CBytes
-from IPython.kernel.zmq.serialize import serialize_object
-from IPython.kernel.zmq.session import Session, extract_header
+from ipython_kernel.serialize import serialize_object
+from ipython_kernel.session import Session, extract_header
 
 #-----------------------------------------------------------------------------
 # Code
@@ -34,13 +34,13 b' class ZMQDataPublisher(Configurable):'
     def set_parent(self, parent):
         """Set the parent for outbound messages."""
         self.parent_header = extract_header(parent)
-    
+
     def publish_data(self, data):
         """publish a data_message on the IOPub channel
-    
+
         Parameters
         ----------
-    
+
         data : dict
             The data to be published. Think of it as a namespace.
         """
@@ -59,12 +59,12 b' class ZMQDataPublisher(Configurable):'
 
 def publish_data(data):
     """publish a data_message on the IOPub channel
-    
+
     Parameters
     ----------
-    
+
     data : dict
         The data to be published. Think of it as a namespace.
     """
-    from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
+    from ipython_kernel.zmqshell import ZMQInteractiveShell
     ZMQInteractiveShell.instance().data_pub.publish_data(data)

ipython_kernel/displayhook.py

@@ -6,7 +6,7 b''
 import sys
 
 from IPython.core.displayhook import DisplayHook
-from IPython.kernel.inprocess.socket import SocketABC
+from ipython_kernel.inprocess.socket import SocketABC
 from IPython.utils.jsonutil import encode_images
 from IPython.utils.py3compat import builtin_mod
 from IPython.utils.traitlets import Instance, Dict
@@ -71,4 +71,3 b' class ZMQShellDisplayHook(DisplayHook):'
         if self.msg['content']['data']:
             self.session.send(self.pub_socket, self.msg, ident=self.topic)
         self.msg = None
-

ipython_kernel/embed.py

@@ -16,19 +16,19 b' from .kernelapp import IPKernelApp'
 
 def embed_kernel(module=None, local_ns=None, **kwargs):
     """Embed and start an IPython kernel in a given scope.
-    
+
     Parameters
     ----------
     module : ModuleType, optional
         The module to load into IPython globals (default: caller)
     local_ns : dict, optional
         The namespace to load into IPython user namespace (default: caller)
-    
+
     kwargs : various, optional
         Further keyword args are relayed to the IPKernelApp constructor,
         allowing configuration of the Kernel.  Will only have an effect
         on the first embed_kernel call for a given process.
-    
+
     """
     # get the app if it exists, or set it up if it doesn't
     if IPKernelApp.initialized():
@@ -50,7 +50,7 b' def embed_kernel(module=None, local_ns=None, **kwargs):'
         module = caller_module
     if local_ns is None:
         local_ns = caller_locals
-    
+
     app.kernel.user_module = module
     app.kernel.user_ns = local_ns
     app.shell.set_completer_frame()

ipython_kernel/eventloops.py

@@ -14,9 +14,9 b' from IPython.utils import io'
 from IPython.lib.inputhook import _use_appnope
 
 def _notify_stream_qt(kernel, stream):
-    
+
     from IPython.external.qt_for_kernel import QtCore
-    
+
     if _use_appnope() and kernel._darwin_app_nap:
         from appnope import nope_scope as context
     else:
@@ -26,7 +26,7 b' def _notify_stream_qt(kernel, stream):'
         while stream.getsockopt(zmq.EVENTS) & zmq.POLLIN:
             with context():
                 kernel.do_one_iteration()
-    
+
     fd = stream.getsockopt(zmq.FD)
     notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read, kernel.app)
     notifier.activated.connect(process_stream_events)
@@ -41,22 +41,22 b' loop_map = {'
 
 def register_integration(*toolkitnames):
     """Decorator to register an event loop to integrate with the IPython kernel
-    
+
     The decorator takes names to register the event loop as for the %gui magic.
     You can provide alternative names for the same toolkit.
-    
+
     The decorated function should take a single argument, the IPython kernel
     instance, arrange for the event loop to call ``kernel.do_one_iteration()``
     at least every ``kernel._poll_interval`` seconds, and start the event loop.
-    
-    :mod:`IPython.kernel.zmq.eventloops` provides and registers such functions
+
+    :mod:`ipython_kernel.eventloops` provides and registers such functions
     for a few common event loops.
     """
     def decorator(func):
         for name in toolkitnames:
             loop_map[name] = func
         return func
-    
+
     return decorator
 
 
@@ -68,10 +68,10 b' def loop_qt4(kernel):'
 
     kernel.app = get_app_qt4([" "])
     kernel.app.setQuitOnLastWindowClosed(False)
-    
+
     for s in kernel.shell_streams:
         _notify_stream_qt(kernel, s)
-    
+
     start_event_loop_qt4(kernel.app)
 
 @register_integration('qt5')
@@ -87,7 +87,7 b' def loop_wx(kernel):'
 
     import wx
     from IPython.lib.guisupport import start_event_loop_wx
-    
+
     if _use_appnope() and kernel._darwin_app_nap:
         # we don't hook up App Nap contexts for Wx,
         # just disable it outright.
@@ -197,7 +197,7 b' def loop_cocoa(kernel):'
         "you must use matplotlib >= 1.1.0, or a native libtk."
         )
         return loop_tk(kernel)
-    
+
     from matplotlib.backends.backend_macosx import TimerMac, show
 
     # scale interval for sec->ms

ipython_kernel/gui/gtk3embed.py

@@ -38,7 +38,7 b' class GTKEmbed(object):'
 
     def _wire_kernel(self):
         """Initializes the kernel inside GTK.
-        
+
         This is meant to run only once at startup, so it does its job and
         returns False to ensure it doesn't get run again by GTK.
         """
@@ -46,7 +46,7 b' class GTKEmbed(object):'
         GObject.timeout_add(int(1000*self.kernel._poll_interval),
                             self.iterate_kernel)
         return False
-        
+
     def iterate_kernel(self):
         """Run one iteration of the kernel and return True.
 

ipython_kernel/gui/gtkembed.py

@@ -39,7 +39,7 b' class GTKEmbed(object):'
 
     def _wire_kernel(self):
         """Initializes the kernel inside GTK.
-        
+
         This is meant to run only once at startup, so it does its job and
         returns False to ensure it doesn't get run again by GTK.
         """
@@ -47,7 +47,7 b' class GTKEmbed(object):'
         gobject.timeout_add(int(1000*self.kernel._poll_interval),
                             self.iterate_kernel)
         return False
-        
+
     def iterate_kernel(self):
         """Run one iteration of the kernel and return True.
 

ipython_kernel/inprocess/blocking.py

@@ -17,7 +17,6 b' except ImportError:'
 # IPython imports
 from IPython.utils.io import raw_print
 from IPython.utils.traitlets import Type
-#from IPython.kernel.blocking.channels import BlockingChannelMixin
 
 # Local imports
 from .channels import (

ipython_kernel/inprocess/channels.py

@@ -3,7 +3,7 b''
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-from IPython.kernel.channelsabc import HBChannelABC
+from jupyter_client.channelsabc import HBChannelABC
 
 from .socket import DummySocket
 

ipython_kernel/inprocess/client.py

@@ -12,10 +12,10 b''
 #-----------------------------------------------------------------------------
 
 # IPython imports
-from IPython.kernel.inprocess.socket import DummySocket
+from ipython_kernel.inprocess.socket import DummySocket
 from IPython.utils.traitlets import Type, Instance
-from IPython.kernel.clientabc import KernelClientABC
-from IPython.kernel.client import KernelClient
+from jupyter_client.clientabc import KernelClientABC
+from jupyter_client.client import KernelClient
 
 # Local imports
 from .channels import (
@@ -32,10 +32,10 b' class InProcessKernelClient(KernelClient):'
     """A client for an in-process kernel.
 
     This class implements the interface of
-    `IPython.kernel.clientabc.KernelClientABC` and allows
+    `jupyter_client.clientabc.KernelClientABC` and allows
     (asynchronous) frontends to be used seamlessly with an in-process kernel.
 
-    See `IPython.kernel.client.KernelClient` for docstrings.
+    See `jupyter_client.client.KernelClient` for docstrings.
     """
 
     # The classes to use for the various channels.
@@ -44,7 +44,7 b' class InProcessKernelClient(KernelClient):'
     stdin_channel_class = Type(InProcessChannel)
     hb_channel_class = Type(InProcessHBChannel)
 
-    kernel = Instance('IPython.kernel.inprocess.ipkernel.InProcessKernel', 
+    kernel = Instance('ipython_kernel.inprocess.ipkernel.InProcessKernel',
                       allow_none=True)
 
     #--------------------------------------------------------------------------

ipython_kernel/inprocess/ipkernel.py

@@ -10,8 +10,8 b' import sys'
 from IPython.core.interactiveshell import InteractiveShellABC
 from IPython.utils.jsonutil import json_clean
 from IPython.utils.traitlets import Any, Enum, Instance, List, Type
-from IPython.kernel.zmq.ipkernel import IPythonKernel
-from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
+from ipython_kernel.ipkernel import IPythonKernel
+from ipython_kernel.zmqshell import ZMQInteractiveShell
 
 from .socket import DummySocket
 
@@ -27,7 +27,7 b' class InProcessKernel(IPythonKernel):'
 
     # The frontends connected to this kernel.
     frontends = List(
-        Instance('IPython.kernel.inprocess.client.InProcessKernelClient',
+        Instance('ipython_kernel.inprocess.client.InProcessKernelClient',
                  allow_none=True)
     )
 
@@ -114,25 +114,25 b' class InProcessKernel(IPythonKernel):'
         ident, msg = self.session.recv(self.iopub_socket, copy=False)
         for frontend in self.frontends:
             frontend.iopub_channel.call_handlers(msg)
-        
+
     #------ Trait initializers -----------------------------------------------
 
     def _log_default(self):
         return logging.getLogger(__name__)
 
     def _session_default(self):
-        from IPython.kernel.zmq.session import Session
+        from ipython_kernel.session import Session
         return Session(parent=self, key=b'')
 
     def _shell_class_default(self):
         return InProcessInteractiveShell
 
     def _stdout_default(self):
-        from IPython.kernel.zmq.iostream import OutStream
+        from ipython_kernel.iostream import OutStream
         return OutStream(self.session, self.iopub_socket, u'stdout', pipe=False)
 
     def _stderr_default(self):
-        from IPython.kernel.zmq.iostream import OutStream
+        from ipython_kernel.iostream import OutStream
         return OutStream(self.session, self.iopub_socket, u'stderr', pipe=False)
 
 #-----------------------------------------------------------------------------
@@ -141,7 +141,7 b' class InProcessKernel(IPythonKernel):'
 
 class InProcessInteractiveShell(ZMQInteractiveShell):
 
-    kernel = Instance('IPython.kernel.inprocess.ipkernel.InProcessKernel',
+    kernel = Instance('ipython_kernel.inprocess.ipkernel.InProcessKernel',
                       allow_none=True)
 
     #-------------------------------------------------------------------------
@@ -150,7 +150,7 b' class InProcessInteractiveShell(ZMQInteractiveShell):'
 
     def enable_gui(self, gui=None):
         """Enable GUI integration for the kernel."""
-        from IPython.kernel.zmq.eventloops import enable_gui
+        from ipython_kernel.eventloops import enable_gui
         if not gui:
             gui = self.kernel.gui
         return enable_gui(gui, kernel=self.kernel)

ipython_kernel/inprocess/manager.py

@@ -4,37 +4,37 b''
 # Distributed under the terms of the Modified BSD License.
 
 from IPython.utils.traitlets import Instance, DottedObjectName
-from IPython.kernel.managerabc import KernelManagerABC
-from IPython.kernel.manager import KernelManager
-from IPython.kernel.zmq.session import Session
+from jupyter_client.managerabc import KernelManagerABC
+from jupyter_client.manager import KernelManager
+from jupyter_client.session import Session
 
 
 class InProcessKernelManager(KernelManager):
     """A manager for an in-process kernel.
 
     This class implements the interface of
-    `IPython.kernel.kernelmanagerabc.KernelManagerABC` and allows
+    `jupyter_client.kernelmanagerabc.KernelManagerABC` and allows
     (asynchronous) frontends to be used seamlessly with an in-process kernel.
 
-    See `IPython.kernel.kernelmanager.KernelManager` for docstrings.
+    See `jupyter_client.kernelmanager.KernelManager` for docstrings.
     """
 
     # The kernel process with which the KernelManager is communicating.
-    kernel = Instance('IPython.kernel.inprocess.ipkernel.InProcessKernel',
+    kernel = Instance('ipython_kernel.inprocess.ipkernel.InProcessKernel',
                       allow_none=True)
     # the client class for KM.client() shortcut
-    client_class = DottedObjectName('IPython.kernel.inprocess.BlockingInProcessKernelClient')
-    
+    client_class = DottedObjectName('ipython_kernel.inprocess.BlockingInProcessKernelClient')
+
     def _session_default(self):
         # don't sign in-process messages
         return Session(key=b'', parent=self)
-    
+
     #--------------------------------------------------------------------------
     # Kernel management methods
     #--------------------------------------------------------------------------
 
     def start_kernel(self, **kwds):
-        from IPython.kernel.inprocess.ipkernel import InProcessKernel
+        from ipython_kernel.inprocess.ipkernel import InProcessKernel
         self.kernel = InProcessKernel(parent=self, session=self.session)
 
     def shutdown_kernel(self):

ipython_kernel/inprocess/socket.py

@@ -46,7 +46,7 b' SocketABC.register(zmq.Socket)'
 
 class DummySocket(HasTraits):
     """ A dummy socket implementing (part of) the zmq.Socket interface. """
-    
+
     queue = Instance(Queue, ())
     message_sent = Int(0) # Should be an Event
 

ipython_kernel/inprocess/tests/test_kernel.py

@@ -6,10 +6,10 b' from __future__ import print_function'
 import sys
 import unittest
 
-from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient
-from IPython.kernel.inprocess.manager import InProcessKernelManager
-from IPython.kernel.inprocess.ipkernel import InProcessKernel
-from IPython.kernel.tests.utils import assemble_output
+from ipython_kernel.inprocess.blocking import BlockingInProcessKernelClient
+from ipython_kernel.inprocess.manager import InProcessKernelManager
+from ipython_kernel.inprocess.ipkernel import InProcessKernel
+from ipython_kernel.tests.utils import assemble_output
 from IPython.testing.decorators import skipif_not_matplotlib
 from IPython.utils.io import capture_output
 from IPython.utils import py3compat
@@ -66,4 +66,3 b' class InProcessKernelTestCase(unittest.TestCase):'
         kc.execute('print("bar")')
         out, err = assemble_output(kc.iopub_channel)
         self.assertEqual(out, 'bar\n')
-

ipython_kernel/inprocess/tests/test_kernelmanager.py

@@ -5,8 +5,8 b' from __future__ import print_function'
 
 import unittest
 
-from IPython.kernel.inprocess.blocking import BlockingInProcessKernelClient
-from IPython.kernel.inprocess.manager import InProcessKernelManager
+from ipython_kernel.inprocess.blocking import BlockingInProcessKernelClient
+from ipython_kernel.inprocess.manager import InProcessKernelManager
 
 #-----------------------------------------------------------------------------
 # Test case

ipython_kernel/iostream.py

@@ -52,14 +52,14 b' class OutStream(object):'
         self._pipe_flag = pipe
         if pipe:
             self._setup_pipe_in()
-    
+
     def _setup_pipe_in(self):
         """setup listening pipe for subprocesses"""
         ctx = self.pub_socket.context
-        
+
         # use UUID to authenticate pipe messages
         self._pipe_uuid = uuid.uuid4().bytes
-        
+
         self._pipe_in = ctx.socket(zmq.PULL)
         self._pipe_in.linger = 0
         try:
@@ -81,7 +81,7 b' class OutStream(object):'
                 lambda s, event: self.flush(),
                 IOLoop.READ,
             )
-    
+
     def _setup_pipe_out(self):
         # must be new context after fork
         ctx = zmq.Context()
@@ -89,13 +89,13 b' class OutStream(object):'
         self._pipe_out = ctx.socket(zmq.PUSH)
         self._pipe_out_lock = threading.Lock()
         self._pipe_out.connect("tcp://127.0.0.1:%i" % self._pipe_port)
-    
+
     def _is_master_process(self):
         return os.getpid() == self._master_pid
-    
+
     def _is_master_thread(self):
         return threading.current_thread().ident == self._master_thread
-    
+
     def _have_pipe_out(self):
         return os.getpid() == self._pipe_pid
 
@@ -136,10 +136,10 b' class OutStream(object):'
                     self._start = 0
             else:
                 break
-    
+
     def _schedule_flush(self):
         """schedule a flush in the main thread
-        
+
         only works with a tornado/pyzmq eventloop running
         """
         if IOLoop.initialized():
@@ -147,14 +147,14 b' class OutStream(object):'
         else:
             # no async loop, at least force the timer
             self._start = 0
-    
+
     def flush(self):
         """trigger actual zmq send"""
         if self.pub_socket is None:
             raise ValueError(u'I/O operation on closed file')
-        
+
         mp_mode = self._check_mp_mode()
-        
+
         if mp_mode != CHILD:
             # we are master
             if not self._is_master_thread():
@@ -162,15 +162,15 b' class OutStream(object):'
                 # but at least they can schedule an async flush, or force the timer.
                 self._schedule_flush()
                 return
-            
+
             self._flush_from_subprocesses()
             data = self._flush_buffer()
-            
+
             if data:
                 content = {u'name':self.name, u'text':data}
                 msg = self.session.send(self.pub_socket, u'stream', content=content,
                                        parent=self.parent_header, ident=self.topic)
-            
+
                 if hasattr(self.pub_socket, 'flush'):
                     # socket itself has flush (presumably ZMQStream)
                     self.pub_socket.flush()
@@ -200,7 +200,7 b' class OutStream(object):'
 
     def readline(self, size=-1):
         raise IOError('Read not supported on a write only stream.')
-    
+
     def fileno(self):
         raise UnsupportedOperation("IOStream has no fileno.")
 
@@ -211,7 +211,7 b' class OutStream(object):'
             # Make sure that we're handling unicode
             if not isinstance(string, unicode_type):
                 string = string.decode(self.encoding, 'replace')
-            
+
             is_child = (self._check_mp_mode() == CHILD)
             self._buffer.write(string)
             if is_child:
@@ -243,7 +243,7 b' class OutStream(object):'
             self._buffer.close()
         self._new_buffer()
         return data
-    
+
     def _new_buffer(self):
         self._buffer = StringIO()
         self._start = -1

ipython_kernel/ipkernel.py

@@ -10,7 +10,7 b' from IPython.utils.tokenutil import token_at_cursor, line_at_cursor'
 from IPython.utils.traitlets import Instance, Type, Any, List
 from IPython.utils.decorators import undoc
 
-from ..comm import CommManager
+from .comm import CommManager
 from .kernelbase import Kernel as KernelBase
 from .serialize import serialize_object, unpack_apply_message
 from .zmqshell import ZMQInteractiveShell
@@ -63,7 +63,7 b' class IPythonKernel(KernelBase):'
         # TMP - hack while developing
         self.shell._reply_content = None
 
-        self.comm_manager = CommManager(shell=self.shell, parent=self, 
+        self.comm_manager = CommManager(shell=self.shell, parent=self,
                                         kernel=self)
         self.comm_manager.register_target('ipython.widget', lazy_import_handle_comm_opened)
 
@@ -71,7 +71,7 b' class IPythonKernel(KernelBase):'
         comm_msg_types = [ 'comm_open', 'comm_msg', 'comm_close' ]
         for msg_type in comm_msg_types:
             self.shell_handlers[msg_type] = getattr(self.comm_manager, msg_type)
-    
+
     help_links = List([
         {
             'text': "Python",
@@ -363,6 +363,6 b' class IPythonKernel(KernelBase):'
 class Kernel(IPythonKernel):
     def __init__(self, *args, **kwargs):
         import warnings
-        warnings.warn('Kernel is a deprecated alias of IPython.kernel.zmq.ipkernel.IPythonKernel',
+        warnings.warn('Kernel is a deprecated alias of ipython_kernel.ipkernel.IPythonKernel',
                       DeprecationWarning)
         super(Kernel, self).__init__(*args, **kwargs)

ipython_kernel/kernelapp.py

@@ -28,8 +28,8 b' from IPython.utils.traitlets import ('
     Any, Instance, Dict, Unicode, Integer, Bool, DottedObjectName, Type,
 )
 from IPython.utils.importstring import import_item
-from IPython.kernel import write_connection_file
-from IPython.kernel.connect import ConnectionFileMixin
+from jupyter_client import write_connection_file
+from ipython_kernel.connect import ConnectionFileMixin
 
 # local imports
 from .heartbeat import Heartbeat
@@ -99,10 +99,10 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
     flags = Dict(kernel_flags)
     classes = [IPythonKernel, ZMQInteractiveShell, ProfileDir, Session]
     # the kernel class, as an importstring
-    kernel_class = Type('IPython.kernel.zmq.ipkernel.IPythonKernel', config=True,
-                        klass='IPython.kernel.zmq.kernelbase.Kernel',
+    kernel_class = Type('ipython_kernel.ipkernel.IPythonKernel', config=True,
+                        klass='ipython_kernel.kernelbase.Kernel',
     help="""The Kernel subclass to be used.
-    
+
     This should allow easy re-use of the IPKernelApp entry point
     to configure and launch kernels other than IPython's own.
     """)
@@ -110,23 +110,23 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
     poller = Any() # don't restrict this even though current pollers are all Threads
     heartbeat = Instance(Heartbeat, allow_none=True)
     ports = Dict()
-    
+
     # connection info:
-    
+
     @property
     def abs_connection_file(self):
         if os.path.basename(self.connection_file) == self.connection_file:
             return os.path.join(self.profile_dir.security_dir, self.connection_file)
         else:
             return self.connection_file
-        
+
 
     # streams, etc.
     no_stdout = Bool(False, config=True, help="redirect stdout to the null device")
     no_stderr = Bool(False, config=True, help="redirect stderr to the null device")
-    outstream_class = DottedObjectName('IPython.kernel.zmq.iostream.OutStream',
+    outstream_class = DottedObjectName('ipython_kernel.iostream.OutStream',
         config=True, help="The importstring for the OutStream factory")
-    displayhook_class = DottedObjectName('IPython.kernel.zmq.displayhook.ZMQDisplayHook',
+    displayhook_class = DottedObjectName('ipython_kernel.displayhook.ZMQDisplayHook',
         config=True, help="The importstring for the DisplayHook factory")
 
     # polling
@@ -177,7 +177,7 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
         write_connection_file(cf, ip=self.ip, key=self.session.key, transport=self.transport,
         shell_port=self.shell_port, stdin_port=self.stdin_port, hb_port=self.hb_port,
         iopub_port=self.iopub_port, control_port=self.control_port)
-    
+
     def cleanup_connection_file(self):
         cf = self.abs_connection_file
         self.log.debug("Cleaning up connection file: %s", cf)
@@ -185,9 +185,9 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
             os.remove(cf)
         except (IOError, OSError):
             pass
-        
+
         self.cleanup_ipc_files()
-    
+
     def init_connection_file(self):
         if not self.connection_file:
             self.connection_file = "kernel-%s.json"%os.getpid()
@@ -203,7 +203,7 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
         except Exception:
             self.log.error("Failed to load connection file: %r", self.connection_file, exc_info=True)
             self.exit(1)
-    
+
     def init_sockets(self):
         # Create a context, a session, and the kernel sockets.
         self.log.info("Starting the kernel at pid: %i", os.getpid())
@@ -230,7 +230,7 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
         self.control_socket.linger = 1000
         self.control_port = self._bind_socket(self.control_socket, self.control_port)
         self.log.debug("control ROUTER Channel on port: %i" % self.control_port)
-    
+
     def init_heartbeat(self):
         """start the heart beating"""
         # heartbeat doesn't share context, because it mustn't be blocked
@@ -240,7 +240,7 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
         self.hb_port = self.heartbeat.port
         self.log.debug("Heartbeat REP Channel on port: %i" % self.hb_port)
         self.heartbeat.start()
-    
+
     def log_connection_info(self):
         """display connection info, and store ports"""
         basename = os.path.basename(self.connection_file)
@@ -280,7 +280,7 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
                 sys.stdout = sys.__stdout__ = blackhole
             if self.no_stderr:
                 sys.stderr = sys.__stderr__ = blackhole
-    
+
     def init_io(self):
         """Redirect input streams and set a display hook."""
         if self.outstream_class:
@@ -298,7 +298,7 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
         """Create the Kernel object itself"""
         shell_stream = ZMQStream(self.shell_socket)
         control_stream = ZMQStream(self.control_socket)
-        
+
         kernel_factory = self.kernel_class.instance
 
         kernel = kernel_factory(parent=self, session=self.session,

ipython_kernel/log.py

@@ -5,11 +5,11 b' from zmq.log.handlers import PUBHandler'
 class EnginePUBHandler(PUBHandler):
     """A simple PUBHandler subclass that sets root_topic"""
     engine=None
-    
+
     def __init__(self, engine, *args, **kwargs):
         PUBHandler.__init__(self,*args, **kwargs)
         self.engine = engine
-        
+
     @property
     def root_topic(self):
         """this is a property, in case the handler is created
@@ -18,4 +18,3 b' class EnginePUBHandler(PUBHandler):'
             return "engine.%i"%self.engine.id
         else:
             return "engine"
-    

ipython_kernel/pylab/backend_inline.py

@@ -65,7 +65,7 b' def draw_if_interactive():'
     # For further reference:
     # https://github.com/ipython/ipython/issues/1612
     # https://github.com/matplotlib/matplotlib/issues/835
-    
+
     if not hasattr(fig, 'show'):
         # Queue up `fig` for display
         fig.show = lambda *a: display(fig)
@@ -94,7 +94,7 b' def flush_figures():'
 
     This is meant to be called automatically and will call show() if, during
     prior code execution, there had been any calls to draw_if_interactive.
-    
+
     This function is meant to be used as a post_execute callback in IPython,
     so user-caused errors are handled with showtraceback() instead of being
     allowed to raise.  If this function is not called from within IPython,
@@ -102,7 +102,7 b' def flush_figures():'
     """
     if not show._draw_called:
         return
-    
+
     if InlineBackend.instance().close_figures:
         # ignore the tracking, just draw and close all figures
         try:
@@ -139,4 +139,3 b' def flush_figures():'
 # figurecanvas. This is set here to a Agg canvas
 # See https://github.com/matplotlib/matplotlib/pull/1125
 FigureCanvas = FigureCanvasAgg
-

ipython_kernel/pylab/config.py

@@ -68,14 +68,14 b' class InlineBackend(InlineBackendConfig):'
     )
 
     figure_formats = Set({'png'}, config=True,
-                          help="""A set of figure formats to enable: 'png', 
+                          help="""A set of figure formats to enable: 'png',
                           'retina', 'jpeg', 'svg', 'pdf'.""")
 
     def _update_figure_formatters(self):
         if self.shell is not None:
             from IPython.core.pylabtools import select_figure_formats
             select_figure_formats(self.shell, self.figure_formats, **self.print_figure_kwargs)
-    
+
     def _figure_formats_changed(self, name, old, new):
         if 'jpg' in new or 'jpeg' in new:
             if not pil_available():
@@ -91,20 +91,20 b' class InlineBackend(InlineBackendConfig):'
 
     print_figure_kwargs = Dict({'bbox_inches' : 'tight'}, config=True,
         help="""Extra kwargs to be passed to fig.canvas.print_figure.
-        
+
         Logical examples include: bbox_inches, quality (for jpeg figures), etc.
         """
     )
     _print_figure_kwargs_changed = _update_figure_formatters
-    
+
     close_figures = Bool(True, config=True,
         help="""Close all figures at the end of each cell.
-        
+
         When True, ensures that each cell starts with no active figures, but it
         also means that one must keep track of references in order to edit or
         redraw figures in subsequent cells. This mode is ideal for the notebook,
         where residual plots from other cells might be surprising.
-        
+
         When False, one must call figure() to create new figures. This means
         that gcf() and getfigs() can reference figures created in other cells,
         and the active figure can continue to be edited with pylab/pyplot
@@ -117,4 +117,3 b' class InlineBackend(InlineBackendConfig):'
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
 
-

ipython_kernel/serialize.py

@@ -17,6 +17,8 b' from IPython.utils.pickleutil import ('
     can, uncan, can_sequence, uncan_sequence, CannedObject,
     istype, sequence_types, PICKLE_PROTOCOL,
 )
+from jupyter_client.session import MAX_ITEMS, MAX_BYTES
+
 
 if PY3:
     buffer = memoryview
@@ -25,9 +27,6 b' if PY3:'
 # Serialization Functions
 #-----------------------------------------------------------------------------
 
-# default values for the thresholds:
-MAX_ITEMS = 64
-MAX_BYTES = 1024
 
 def _extract_buffers(obj, threshold=MAX_BYTES):
     """extract buffers larger than a certain threshold"""
@@ -53,10 +52,10 b' def _restore_buffers(obj, buffers):'
 
 def serialize_object(obj, buffer_threshold=MAX_BYTES, item_threshold=MAX_ITEMS):
     """Serialize an object into a list of sendable buffers.
-    
+
     Parameters
     ----------
-    
+
     obj : object
         The object to be serialized
     buffer_threshold : int
@@ -66,7 +65,7 b' def serialize_object(obj, buffer_threshold=MAX_BYTES, item_threshold=MAX_ITEMS):'
         The maximum number of items over which canning will iterate.
         Containers (lists, dicts) larger than this will be pickled without
         introspection.
-    
+
     Returns
     -------
     [bufs] : list of buffers representing the serialized object.
@@ -91,17 +90,17 b' def serialize_object(obj, buffer_threshold=MAX_BYTES, item_threshold=MAX_ITEMS):'
 
 def deserialize_object(buffers, g=None):
     """reconstruct an object serialized by serialize_object from data buffers.
-    
+
     Parameters
     ----------
-    
+
     bufs : list of buffers/bytes
-    
+
     g : globals to be used when uncanning
-    
+
     Returns
     -------
-    
+
     (newobj, bufs) : unpacked object, and the list of remaining unused buffers.
     """
     bufs = list(buffers)
@@ -120,37 +119,37 b' def deserialize_object(buffers, g=None):'
     else:
         _restore_buffers(canned, bufs)
         newobj = uncan(canned, g)
-    
+
     return newobj, bufs
 
 def pack_apply_message(f, args, kwargs, buffer_threshold=MAX_BYTES, item_threshold=MAX_ITEMS):
     """pack up a function, args, and kwargs to be sent over the wire
-    
+
     Each element of args/kwargs will be canned for special treatment,
     but inspection will not go any deeper than that.
-    
+
     Any object whose data is larger than `threshold`  will not have their data copied
     (only numpy arrays and bytes/buffers support zero-copy)
-    
+
     Message will be a list of bytes/buffers of the format:
-    
+
     [ cf, pinfo, <arg_bufs>, <kwarg_bufs> ]
-    
+
     With length at least two + len(args) + len(kwargs)
     """
-    
+
     arg_bufs = flatten(serialize_object(arg, buffer_threshold, item_threshold) for arg in args)
-    
+
     kw_keys = sorted(kwargs.keys())
     kwarg_bufs = flatten(serialize_object(kwargs[key], buffer_threshold, item_threshold) for key in kw_keys)
-    
+
     info = dict(nargs=len(args), narg_bufs=len(arg_bufs), kw_keys=kw_keys)
-    
+
     msg = [pickle.dumps(can(f), PICKLE_PROTOCOL)]
     msg.append(pickle.dumps(info, PICKLE_PROTOCOL))
     msg.extend(arg_bufs)
     msg.extend(kwarg_bufs)
-    
+
     return msg
 
 def unpack_apply_message(bufs, g=None, copy=True):
@@ -163,19 +162,18 b' def unpack_apply_message(bufs, g=None, copy=True):'
     pinfo = buffer_to_bytes_py2(bufs.pop(0))
     info = pickle.loads(pinfo)
     arg_bufs, kwarg_bufs = bufs[:info['narg_bufs']], bufs[info['narg_bufs']:]
-    
+
     args = []
     for i in range(info['nargs']):
         arg, arg_bufs = deserialize_object(arg_bufs, g)
         args.append(arg)
     args = tuple(args)
     assert not arg_bufs, "Shouldn't be any arg bufs left over"
-    
+
     kwargs = {}
     for key in info['kw_keys']:
         kwarg, kwarg_bufs = deserialize_object(kwarg_bufs, g)
         kwargs[key] = kwarg
     assert not kwarg_bufs, "Shouldn't be any kwarg bufs left over"
-    
-    return f,args,kwargs
 
+    return f,args,kwargs

ipython_kernel/tests/test_embed_kernel.py

@@ -22,7 +22,7 b' from subprocess import Popen, PIPE'
 
 import nose.tools as nt
 
-from IPython.kernel import BlockingKernelClient
+from jupyter_client import BlockingKernelClient
 from IPython.utils import path, py3compat
 from IPython.utils.py3compat import unicode_type
 
@@ -38,7 +38,7 b' def setup():'
     global IPYTHONDIR
     global env
     global save_get_ipython_dir
-    
+
     IPYTHONDIR = tempfile.mkdtemp()
 
     env = os.environ.copy()
@@ -50,7 +50,7 b' def setup():'
 
 def teardown():
     path.get_ipython_dir = save_get_ipython_dir
-    
+
     try:
         shutil.rmtree(IPYTHONDIR)
     except (OSError, IOError):
@@ -61,7 +61,7 b' def teardown():'
 @contextmanager
 def setup_kernel(cmd):
     """start an embedded kernel in a subprocess, and wait for it to be ready
-    
+
     Returns
     -------
     kernel_manager: connected KernelManager instance
@@ -78,22 +78,22 b' def setup_kernel(cmd):'
         and kernel.poll() is None \
         and time.time() < tic + SETUP_TIMEOUT:
         time.sleep(0.1)
-    
+
     if kernel.poll() is not None:
         o,e = kernel.communicate()
         e = py3compat.cast_unicode(e)
         raise IOError("Kernel failed to start:\n%s" % e)
-    
+
     if not os.path.exists(connection_file):
         if kernel.poll() is None:
             kernel.terminate()
         raise IOError("Connection file %r never arrived" % connection_file)
-    
+
     client = BlockingKernelClient(connection_file=connection_file)
     client.load_connection_file()
     client.start_channels()
     client.wait_for_ready()
-    
+
     try:
         yield client
     finally:
@@ -111,14 +111,14 b' def test_embed_kernel_basic():'
         'go()',
         '',
     ])
-    
+
     with setup_kernel(cmd) as client:
         # oinfo a (int)
         msg_id = client.inspect('a')
         msg = client.get_shell_msg(block=True, timeout=TIMEOUT)
         content = msg['content']
         nt.assert_true(content['found'])
-    
+
         msg_id = client.execute("c=a*2")
         msg = client.get_shell_msg(block=True, timeout=TIMEOUT)
         content = msg['content']
@@ -143,7 +143,7 b' def test_embed_kernel_namespace():'
         'go()',
         '',
     ])
-    
+
     with setup_kernel(cmd) as client:
         # oinfo a (int)
         msg_id = client.inspect('a')
@@ -181,7 +181,7 b' def test_embed_kernel_reentrant():'
         '    go()',
         '',
     ])
-    
+
     with setup_kernel(cmd) as client:
         for i in range(5):
             msg_id = client.inspect('count')
@@ -190,10 +190,8 b' def test_embed_kernel_reentrant():'
             nt.assert_true(content['found'])
             text = content['data']['text/plain']
             nt.assert_in(unicode_type(i), text)
-            
+
             # exit from embed_kernel
             client.execute("get_ipython().exit_now = True")
             msg = client.get_shell_msg(block=True, timeout=TIMEOUT)
             time.sleep(0.2)
-
-

ipython_kernel/tests/test_kernel.py

@@ -49,7 +49,7 b' def test_sys_path():'
 
 def test_sys_path_profile_dir():
     """test that sys.path doesn't get messed up when `--profile-dir` is specified"""
-    
+
     with new_kernel(['--profile-dir', locate_profile('default')]) as kc:
         msg_id, content = execute(kc=kc, code="import sys; print (repr(sys.path[0]))")
         stdout, stderr = assemble_output(kc.iopub_channel)
@@ -60,7 +60,7 b' def test_subprocess_print():'
     """printing from forked mp.Process"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
-        
+
         _check_mp_mode(kc, expected=False)
         flush_channels(kc)
         np = 5
@@ -71,11 +71,11 b' def test_subprocess_print():'
             "for p in pool: p.start()",
             "for p in pool: p.join()"
         ])
-        
+
         expected = '\n'.join([
             "hello %s" % i for i in range(np)
         ]) + '\n'
-        
+
         msg_id, content = execute(kc=kc, code=code)
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout.count("hello"), np, stdout)
@@ -90,7 +90,7 b' def test_subprocess_noprint():'
     """mp.Process without print doesn't trigger iostream mp_mode"""
     with kernel() as kc:
         iopub = kc.iopub_channel
-        
+
         np = 5
         code = '\n'.join([
             "import multiprocessing as mp",
@@ -98,7 +98,7 b' def test_subprocess_noprint():'
             "for p in pool: p.start()",
             "for p in pool: p.join()"
         ])
-        
+
         msg_id, content = execute(kc=kc, code=code)
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout, '')
@@ -113,14 +113,14 b' def test_subprocess_error():'
     """error in mp.Process doesn't crash"""
     with new_kernel() as kc:
         iopub = kc.iopub_channel
-        
+
         code = '\n'.join([
             "import multiprocessing as mp",
             "p = mp.Process(target=int, args=('hi',))",
             "p.start()",
             "p.join()",
         ])
-        
+
         msg_id, content = execute(kc=kc, code=code)
         stdout, stderr = assemble_output(iopub)
         nt.assert_equal(stdout, '')
@@ -135,7 +135,7 b' def test_raw_input():'
     """test [raw_]input"""
     with kernel() as kc:
         iopub = kc.iopub_channel
-        
+
         input_f = "input" if py3compat.PY3 else "raw_input"
         theprompt = "prompt> "
         code = 'print({input_f}("{theprompt}"))'.format(**locals())
@@ -157,7 +157,7 b' def test_eval_input():'
     """test input() on Python 2"""
     with kernel() as kc:
         iopub = kc.iopub_channel
-        
+
         input_f = "input" if py3compat.PY3 else "raw_input"
         theprompt = "prompt> "
         code = 'print(input("{theprompt}"))'.format(**locals())
@@ -205,7 +205,7 b' def test_is_complete():'
         kc.is_complete('raise = 2')
         reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
         assert reply['content']['status'] == 'invalid'
-        
+
         kc.is_complete('a = [1,\n2,')
         reply = kc.get_shell_msg(block=True, timeout=TIMEOUT)
         assert reply['content']['status'] == 'incomplete'

ipython_kernel/tests/test_message_spec.py

@@ -64,7 +64,7 b' class Version(Unicode):'
         self.max = kwargs.pop('max', None)
         kwargs['default_value'] = self.min
         super(Version, self).__init__(*args, **kwargs)
-    
+
     def validate(self, obj, value):
         if self.min and V(value) < V(self.min):
             raise TraitError("bad version: %s < %s" % (value, self.min))
@@ -78,7 +78,7 b' class RMessage(Reference):'
     header = Dict()
     parent_header = Dict()
     content = Dict()
-    
+
     def check(self, d):
         super(RMessage, self).check(d)
         RHeader().check(self.header)
@@ -107,7 +107,7 b' class MimeBundle(Reference):'
 class ExecuteReply(Reference):
     execution_count = Integer()
     status = Enum((u'ok', u'error'), default_value=u'ok')
-    
+
     def check(self, d):
         Reference.check(self, d)
         if d['status'] == 'ok':
@@ -158,7 +158,7 b' class KernelInfoReply(Reference):'
     implementation_version = Version(min='2.1')
     language_info = Dict()
     banner = Unicode()
-    
+
     def check(self, d):
         Reference.check(self, d)
         LanguageInfo().check(d['language_info'])
@@ -166,7 +166,7 b' class KernelInfoReply(Reference):'
 
 class IsCompleteReply(Reference):
     status = Enum((u'complete', u'incomplete', u'invalid', u'unknown'), default_value=u'complete')
-    
+
     def check(self, d):
         Reference.check(self, d)
         if d['status'] == 'incomplete':
@@ -224,10 +224,10 b' Specifications of `content` part of the reply messages.'
 
 def validate_message(msg, msg_type=None, parent=None):
     """validate a message
-    
+
     This is a generator, and must be iterated through to actually
     trigger each test.
-    
+
     If msg_type and/or parent are given, the msg_type and/or parent msg_id
     are compared with the given values.
     """
@@ -249,7 +249,7 b' def validate_message(msg, msg_type=None, parent=None):'
 
 def test_execute():
     flush_channels()
-    
+
     msg_id = KC.execute(code='x=1')
     reply = KC.get_shell_msg(timeout=TIMEOUT)
     validate_message(reply, 'execute_reply', msg_id)
@@ -258,7 +258,7 b' def test_execute():'
 def test_execute_silent():
     flush_channels()
     msg_id, reply = execute(code='x=1', silent=True)
-    
+
     # flush status=idle
     status = KC.iopub_channel.get_msg(timeout=TIMEOUT)
     validate_message(status, 'status', msg_id)
@@ -266,14 +266,14 b' def test_execute_silent():'
 
     nt.assert_raises(Empty, KC.iopub_channel.get_msg, timeout=0.1)
     count = reply['execution_count']
-    
+
     msg_id, reply = execute(code='x=2', silent=True)
-    
+
     # flush status=idle
     status = KC.iopub_channel.get_msg(timeout=TIMEOUT)
     validate_message(status, 'status', msg_id)
     nt.assert_equal(status['content']['execution_state'], 'idle')
-    
+
     nt.assert_raises(Empty, KC.iopub_channel.get_msg, timeout=0.1)
     count_2 = reply['execution_count']
     nt.assert_equal(count_2, count)
@@ -281,11 +281,11 b' def test_execute_silent():'
 
 def test_execute_error():
     flush_channels()
-    
+
     msg_id, reply = execute(code='1/0')
     nt.assert_equal(reply['status'], 'error')
     nt.assert_equal(reply['ename'], 'ZeroDivisionError')
-    
+
     error = KC.iopub_channel.get_msg(timeout=TIMEOUT)
     validate_message(error, 'error', msg_id)
 
@@ -296,9 +296,9 b' def test_execute_inc():'
 
     msg_id, reply = execute(code='x=1')
     count = reply['execution_count']
-    
+
     flush_channels()
-    
+
     msg_id, reply = execute(code='x=2')
     count_2 = reply['execution_count']
     nt.assert_equal(count_2, count+1)
@@ -306,7 +306,7 b' def test_execute_inc():'
 def test_execute_stop_on_error():
     """execute request should not abort execution queue with stop_on_error False"""
     flush_channels()
-    
+
     fail = '\n'.join([
         # sleep to ensure subsequent message is waiting in the queue to be aborted
         'import time',
@@ -362,7 +362,7 b' def test_oinfo_found():'
     flush_channels()
 
     msg_id, reply = execute(code='a=5')
-    
+
     msg_id = KC.inspect('a')
     reply = KC.get_shell_msg(timeout=TIMEOUT)
     validate_message(reply, 'inspect_reply', msg_id)
@@ -377,7 +377,7 b' def test_oinfo_detail():'
     flush_channels()
 
     msg_id, reply = execute(code='ip=get_ipython()')
-    
+
     msg_id = KC.inspect('ip.object_inspect', cursor_pos=10, detail_level=1)
     reply = KC.get_shell_msg(timeout=TIMEOUT)
     validate_message(reply, 'inspect_reply', msg_id)
@@ -402,7 +402,7 b' def test_complete():'
     flush_channels()
 
     msg_id, reply = execute(code="alpha = albert = 5")
-    
+
     msg_id = KC.complete('al', 2)
     reply = KC.get_shell_msg(timeout=TIMEOUT)
     validate_message(reply, 'complete_reply', msg_id)
@@ -436,10 +436,10 b' def test_is_complete():'
 
 def test_history_range():
     flush_channels()
-    
+
     msg_id_exec = KC.execute(code='x=1', store_history = True)
     reply_exec = KC.get_shell_msg(timeout=TIMEOUT)
-    
+
     msg_id = KC.history(hist_access_type = 'range', raw = True, output = True, start = 1, stop = 2, session = 0)
     reply = KC.get_shell_msg(timeout=TIMEOUT)
     validate_message(reply, 'history_reply', msg_id)
@@ -448,10 +448,10 b' def test_history_range():'
 
 def test_history_tail():
     flush_channels()
-    
+
     msg_id_exec = KC.execute(code='x=1', store_history = True)
     reply_exec = KC.get_shell_msg(timeout=TIMEOUT)
-    
+
     msg_id = KC.history(hist_access_type = 'tail', raw = True, output = True, n = 1, session = 0)
     reply = KC.get_shell_msg(timeout=TIMEOUT)
     validate_message(reply, 'history_reply', msg_id)
@@ -460,10 +460,10 b' def test_history_tail():'
 
 def test_history_search():
     flush_channels()
-    
+
     msg_id_exec = KC.execute(code='x=1', store_history = True)
     reply_exec = KC.get_shell_msg(timeout=TIMEOUT)
-    
+
     msg_id = KC.history(hist_access_type = 'search', raw = True, output = True, n = 1, pattern = '*', session = 0)
     reply = KC.get_shell_msg(timeout=TIMEOUT)
     validate_message(reply, 'history_reply', msg_id)
@@ -488,9 +488,8 b' def test_display_data():'
     flush_channels()
 
     msg_id, reply = execute("from IPython.core.display import display; display(1)")
-    
+
     display = KC.iopub_channel.get_msg(timeout=TIMEOUT)
     validate_message(display, 'display_data', parent=msg_id)
     data = display['content']['data']
     nt.assert_equal(data['text/plain'], u'1')
-

ipython_kernel/tests/test_serialize.py

@@ -9,7 +9,7 b' from collections import namedtuple'
 import nose.tools as nt
 
 # from unittest import TestCaes
-from IPython.kernel.zmq.serialize import serialize_object, deserialize_object
+from ipython_kernel.serialize import serialize_object, deserialize_object
 from IPython.testing import decorators as dec
 from IPython.utils.pickleutil import CannedArray, CannedClass
 from IPython.utils.py3compat import iteritems
@@ -28,7 +28,7 b' def roundtrip(obj):'
 
 class C(object):
     """dummy class for """
-    
+
     def __init__(self, **kwargs):
         for key,value in iteritems(kwargs):
             setattr(self, key, value)
@@ -98,7 +98,7 b' def test_recarray():'
             [('n', int), ('s', '|S1'), ('u', 'uint32')],
         ]:
             A = new_array(shape, dtype=dtype)
-            
+
             bufs = serialize_object(A)
             B, r = deserialize_object(bufs)
             nt.assert_equal(r, [])
@@ -155,7 +155,7 b' def test_class_oldstyle():'
     @interactive
     class C:
         a=5
-    
+
     bufs = serialize_object(dict(C=C))
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned['C'], CannedClass)
@@ -198,7 +198,7 b' def test_class_inheritance():'
     @interactive
     class D(C):
         b=10
-    
+
     bufs = serialize_object(dict(D=D))
     canned = pickle.loads(bufs[0])
     nt.assert_is_instance(canned['D'], CannedClass)

ipython_kernel/tests/utils.py

@@ -4,6 +4,7 b''
 # Distributed under the terms of the Modified BSD License.
 
 import atexit
+import os
 
 from contextlib import contextmanager
 from subprocess import PIPE, STDOUT
@@ -15,7 +16,7 b' except ImportError:'
 import nose
 import nose.tools as nt
 
-from IPython.kernel import manager
+from jupyter_client import manager
 
 #-------------------------------------------------------------------------------
 # Globals
@@ -32,7 +33,7 b' KC = None'
 #-------------------------------------------------------------------------------
 def start_new_kernel(**kwargs):
     """start a new kernel, and return its Manager and Client
-    
+
     Integrates with our output capturing for tests.
     """
     kwargs.update(dict(stdout=nose.iptest_stdstreams_fileno(), stderr=STDOUT))
@@ -41,7 +42,7 b' def start_new_kernel(**kwargs):'
 def flush_channels(kc=None):
     """flush any messages waiting on the queue"""
     from .test_message_spec import validate_message
-    
+
     if kc is None:
         kc = KC
     for channel in (kc.shell_channel, kc.iopub_channel):
@@ -65,12 +66,12 b" def execute(code='', kc=None, **kwargs):"
     busy = kc.get_iopub_msg(timeout=TIMEOUT)
     validate_message(busy, 'status', msg_id)
     nt.assert_equal(busy['content']['execution_state'], 'busy')
-    
+
     if not kwargs.get('silent'):
         execute_input = kc.get_iopub_msg(timeout=TIMEOUT)
         validate_message(execute_input, 'execute_input', msg_id)
         nt.assert_equal(execute_input['content']['code'], code)
-    
+
     return msg_id, reply['content']
 
 def start_global_kernel():
@@ -86,9 +87,9 b' def start_global_kernel():'
 @contextmanager
 def kernel():
     """Context manager for the global kernel instance
-    
+
     Should be used for most kernel tests
-    
+
     Returns
     -------
     kernel_client: connected KernelClient instance
@@ -116,14 +117,15 b' def stop_global_kernel():'
 
 def new_kernel(argv=None):
     """Context manager for a new kernel in a subprocess
-    
+
     Should only be used for tests where the kernel must not be re-used.
-    
+
     Returns
     -------
     kernel_client: connected KernelClient instance
     """
-    kwargs = dict(stdout=nose.iptest_stdstreams_fileno(), stderr=STDOUT,
+    kwargs = dict(
+        stdout=nose.iptest_stdstreams_fileno(), stderr=STDOUT,
                   startup_timeout=STARTUP_TIMEOUT)
     if argv is not None:
         kwargs['extra_arguments'] = argv

ipython_kernel/zmqshell.py

@@ -34,8 +34,8 b' from IPython.core.magic import magics_class, line_magic, Magics'
 from IPython.core import payloadpage
 from IPython.core.usage import default_gui_banner
 from IPython.display import display, Javascript
-from IPython.kernel.inprocess.socket import SocketABC
-from IPython.kernel import (
+from ipython_kernel.inprocess.socket import SocketABC
+from ipython_kernel import (
     get_connection_file, get_connection_info, connect_qtconsole
 )
 from IPython.testing.skipdoctest import skip_doctest
@@ -46,9 +46,9 b' from IPython.utils import py3compat'
 from IPython.utils.py3compat import unicode_type
 from IPython.utils.traitlets import Instance, Type, Dict, CBool, CBytes, Any
 from IPython.utils.warn import error
-from IPython.kernel.zmq.displayhook import ZMQShellDisplayHook
-from IPython.kernel.zmq.datapub import ZMQDataPublisher
-from IPython.kernel.zmq.session import extract_header
+from ipython_kernel.displayhook import ZMQShellDisplayHook
+from ipython_kernel.datapub import ZMQDataPublisher
+from ipython_kernel.session import extract_header
 from .session import Session
 
 #-----------------------------------------------------------------------------
@@ -66,7 +66,7 b' class ZMQDisplayPublisher(DisplayPublisher):'
     def set_parent(self, parent):
         """Set the parent for outbound messages."""
         self.parent_header = extract_header(parent)
-    
+
     def _flush_streams(self):
         """flush IO Streams prior to display"""
         sys.stdout.flush()
@@ -102,7 +102,7 b' class KernelMagics(Magics):'
     # moved into a separate machinery as well.  For now, at least isolate here
     # the magics which this class needs to implement differently from the base
     # class, or that are unique to it.
-    
+
     _find_edit_target = CodeMagics._find_edit_target
 
     @skip_doctest
@@ -248,19 +248,19 b' class KernelMagics(Magics):'
     @line_magic
     def connect_info(self, arg_s):
         """Print information for connecting other clients to this kernel
-        
+
         It will print the contents of this session's connection file, as well as
         shortcuts for local clients.
-        
+
         In the simplest case, when called from the most recently launched kernel,
         secondary clients can be connected, simply with:
-        
+
         $> ipython <app> --existing
-        
+
         """
-        
+
         from IPython.core.application import BaseIPythonApplication as BaseIPApp
-        
+
         if BaseIPApp.initialized():
             app = BaseIPApp.instance()
             security_dir = app.profile_dir.security_dir
@@ -268,22 +268,22 b' class KernelMagics(Magics):'
         else:
             profile = 'default'
             security_dir = ''
-        
+
         try:
             connection_file = get_connection_file()
             info = get_connection_info(unpack=False)
         except Exception as e:
             error("Could not get connection info: %r" % e)
             return
-        
+
         # add profile flag for non-default profile
         profile_flag = "--profile %s" % profile if profile != 'default' else ""
-        
+
         # if it's in the security dir, truncate to basename
         if security_dir == os.path.dirname(connection_file):
             connection_file = os.path.basename(connection_file)
-        
-        
+
+
         print (info + '\n')
         print ("Paste the above JSON into a file, and connect with:\n"
             "    $> ipython <app> --existing <file>\n"
@@ -299,11 +299,11 b' class KernelMagics(Magics):'
     @line_magic
     def qtconsole(self, arg_s):
         """Open a qtconsole connected to this kernel.
-        
+
         Useful for connecting a qtconsole to running notebooks, for better
         debugging.
         """
-        
+
         # %qtconsole should imply bind_kernel for engines:
         try:
             from IPython.parallel import bind_kernel
@@ -312,29 +312,29 b' class KernelMagics(Magics):'
             pass
         else:
             bind_kernel()
-        
+
         try:
             p = connect_qtconsole(argv=arg_split(arg_s, os.name=='posix'))
         except Exception as e:
             error("Could not start qtconsole: %r" % e)
             return
-    
+
     @line_magic
     def autosave(self, arg_s):
         """Set the autosave interval in the notebook (in seconds).
-        
+
         The default value is 120, or two minutes.
         ``%autosave 0`` will disable autosave.
-        
+
         This magic only has an effect when called from the notebook interface.
         It has no effect when called in a startup file.
         """
-        
+
         try:
             interval = int(arg_s)
         except ValueError:
             raise UsageError("%%autosave requires an integer, got %r" % arg_s)
-        
+
         # javascript wants milliseconds
         milliseconds = 1000 * interval
         display(Javascript("IPython.notebook.set_autosave_interval(%i)" % milliseconds),
@@ -354,7 +354,7 b' class ZMQInteractiveShell(InteractiveShell):'
     data_pub_class = Type(ZMQDataPublisher)
     kernel = Any()
     parent_header = Any()
-    
+
     def _banner1_default(self):
         return default_gui_banner
 
@@ -370,7 +370,7 b' class ZMQInteractiveShell(InteractiveShell):'
     exiter = Instance(ZMQExitAutocall)
     def _exiter_default(self):
         return ZMQExitAutocall(self)
-    
+
     def _exit_now_changed(self, name, old, new):
         """stop eventloop when exit_now fires"""
         if new:
@@ -400,11 +400,11 b' class ZMQInteractiveShell(InteractiveShell):'
         # subprocesses as much as possible.
         env['PAGER'] = 'cat'
         env['GIT_PAGER'] = 'cat'
-    
+
     def init_hooks(self):
         super(ZMQInteractiveShell, self).init_hooks()
         self.set_hook('show_in_pager', page.as_hook(payloadpage.page), 99)
-    
+
     def ask_exit(self):
         """Engage the exit actions."""
         self.exit_now = (not self.keepkernel_on_exit)
@@ -431,7 +431,7 b' class ZMQInteractiveShell(InteractiveShell):'
         topic = None
         if dh.topic:
             topic = dh.topic.replace(b'execute_result', b'error')
-        
+
         exc_msg = dh.session.send(dh.pub_socket, u'error', json_clean(exc_content), dh.parent_header, ident=topic)
 
         # FIXME - Hack: store exception info in shell object.  Right now, the
@@ -454,7 +454,7 b' class ZMQInteractiveShell(InteractiveShell):'
             replace=replace,
         )
         self.payload_manager.write_payload(payload)
-    
+
     def set_parent(self, parent):
         """Set the parent header for associating output with its triggering input"""
         self.parent_header = parent
@@ -469,10 +469,10 b' class ZMQInteractiveShell(InteractiveShell):'
             sys.stderr.set_parent(parent)
         except AttributeError:
             pass
-    
+
     def get_parent(self):
         return self.parent_header
-    
+
     #-------------------------------------------------------------------------
     # Things related to magics
     #-------------------------------------------------------------------------

jupyter_client/blocking/channels.py

@@ -89,4 +89,3 b' class ZMQSocketChannel(object):'
 
     def start(self):
         pass
-

jupyter_client/blocking/client.py

@@ -11,8 +11,8 b' 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):

jupyter_client/ioloop/manager.py

@@ -20,7 +20,7 b' from IPython.utils.traitlets import ('
     Instance
 )
 
-from IPython.kernel.manager import KernelManager
+from jupyter_client.manager import KernelManager
 from .restarter import IOLoopKernelRestarter
 
 #-----------------------------------------------------------------------------
@@ -40,7 +40,7 b' class IOLoopKernelManager(KernelManager):'
     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:

jupyter_client/ioloop/restarter.py

@@ -20,7 +20,7 b' 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,
 )
@@ -51,4 +51,3 b' class IOLoopKernelRestarter(KernelRestarter):'
         if self._pcallback is not None:
             self._pcallback.stop()
             self._pcallback = None
-

jupyter_client/session.py

@@ -53,8 +53,7 b' from IPython.utils.traitlets import (CBytes, Unicode, Bool, Any, Instance, Set,'
                                         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
@@ -78,6 +77,10 b' def squash_unicode(obj):'
 # globals and defaults
 #-----------------------------------------------------------------------------
 
+# default values for the thresholds:
+MAX_ITEMS = 64
+MAX_BYTES = 1024
+
 # ISO8601-ify datetime objects
 # allow unicode
 # disallow nan, because it's not actually valid JSON
@@ -118,7 +121,7 b' session_flags = {'
 
 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.
     """
@@ -148,7 +151,7 b' class SessionFactory(LoggingConfigurable):'
     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')
@@ -310,20 +313,20 b' class Session(Configurable):'
 
     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'.""")
@@ -336,7 +339,7 b' class Session(Configurable):'
         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
@@ -348,11 +351,11 b' class Session(Configurable):'
             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.
         """
     )
@@ -365,9 +368,9 b' class Session(Configurable):'
 
     # 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):
@@ -378,7 +381,7 b' class Session(Configurable):'
         # 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.")
@@ -390,7 +393,7 b' class Session(Configurable):'
         """
     )
 
-    
+
     def __init__(self, **kwargs):
         """create a Session object
 
@@ -625,7 +628,7 b' class Session(Configurable):'
         track : bool
             Whether to track.  Only for use with Sockets, because ZMQStream
             objects cannot track messages.
-            
+
 
         Returns
         -------
@@ -655,7 +658,7 b' class Session(Configurable):'
         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)
@@ -776,15 +779,15 b' class Session(Configurable):'
         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)
@@ -794,7 +797,7 b' class Session(Configurable):'
             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.
 
@@ -855,7 +858,7 b' class Session(Configurable):'
         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.",
@@ -879,4 +882,3 b' def test_msg2obj():'
     am2 = dict(ao)
     assert am['x'] == am2['x']
     assert am['y']['z'] == am2['y']['z']
-

jupyter_client/tests/test_adapter.py

@@ -8,8 +8,8 b' 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():
@@ -26,15 +26,15 b' def test_code_to_line_no_code():'
     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
 
@@ -42,28 +42,28 b' class AdapterTest(TestCase):'
 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'),
@@ -75,7 +75,7 b' class V4toV5TestCase(AdapterTest):'
             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',
@@ -106,7 +106,7 b' class V4toV5TestCase(AdapterTest):'
         self.assertEqual(v5c['payload'], [{'source': 'page',
                                            'data': {'text/plain': 'blah'}}
                                          ])
-    
+
     def test_complete_request(self):
         msg = self.msg("complete_request", {
             'text' : 'a.is',
@@ -121,7 +121,7 b' class V4toV5TestCase(AdapterTest):'
             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',
@@ -134,12 +134,12 b' class V4toV5TestCase(AdapterTest):'
         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',
@@ -152,7 +152,7 b' class V4toV5TestCase(AdapterTest):'
         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',
@@ -168,7 +168,7 b' class V4toV5TestCase(AdapterTest):'
         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',
@@ -188,9 +188,9 b' class V4toV5TestCase(AdapterTest):'
             },
             'banner' : '',
         })
-    
+
     # iopub channel
-    
+
     def test_display_data(self):
         jsondata = dict(a=5)
         msg = self.msg("display_data", {
@@ -206,9 +206,9 b' class V4toV5TestCase(AdapterTest):'
         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)
@@ -219,25 +219,25 b' class V4toV5TestCase(AdapterTest):'
 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'),
@@ -249,7 +249,7 b' class V5toV4TestCase(AdapterTest):'
             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',
@@ -262,7 +262,7 b' class V5toV4TestCase(AdapterTest):'
         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'
@@ -278,7 +278,7 b' class V5toV4TestCase(AdapterTest):'
         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,
@@ -295,7 +295,7 b' class V5toV4TestCase(AdapterTest):'
         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'
@@ -310,7 +310,7 b' class V5toV4TestCase(AdapterTest):'
         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',
@@ -324,7 +324,7 b' class V5toV4TestCase(AdapterTest):'
         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',
@@ -347,9 +347,9 b' class V5toV4TestCase(AdapterTest):'
             '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", {
@@ -365,13 +365,11 b' class V5toV4TestCase(AdapterTest):'
         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

@@ -26,8 +26,8 b' 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
@@ -60,13 +60,13 b' def test_load_connection_file_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'])
 
@@ -78,7 +78,7 b' def test_app_load_connection_file():'
         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
@@ -92,14 +92,14 b' def test_get_connection_file():'
         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)
 
@@ -111,11 +111,11 b' def test_find_connection_file():'
         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*',
@@ -123,7 +123,7 b' def test_find_connection_file():'
             'k*',
             ):
             nt.assert_equal(connect.find_connection_file(query), profile_cf)
-        
+
         BaseIPythonApplication._instance = None
 
 def test_get_connection_info():
@@ -132,12 +132,10 b' def test_get_connection_info():'
         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

@@ -7,7 +7,7 b' 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):
 
@@ -40,7 +40,7 b' class TestKernelManager(TestCase):'
     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()
@@ -51,4 +51,3 b' class TestKernelManager(TestCase):'
             'key', 'signature_scheme',
         ])
         self.assertEqual(keys, expected)
-

jupyter_client/tests/test_kernelspec.py

@@ -5,7 +5,7 b' 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',
@@ -22,7 +22,7 b' class KernelSpecTests(unittest.TestCase):'
             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
@@ -39,18 +39,18 b' class KernelSpecTests(unittest.TestCase):'
         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',

jupyter_client/tests/test_launcher.py

@@ -20,7 +20,7 b' Authors'
 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
@@ -55,4 +55,3 b' def test_swallow_argv():'
             "returned : %r" % stripped,
         ])
         nt.assert_equal(expected, stripped, message)
-

jupyter_client/tests/test_multikernelmanager.py

@@ -8,8 +8,8 b' 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):
 
@@ -61,7 +61,7 b' class TestKernelManager(TestCase):'
     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)
@@ -70,7 +70,7 b' class TestKernelManager(TestCase):'
         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())
@@ -79,9 +79,8 b' class TestKernelManager(TestCase):'
     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,4 +1,4 b''
-"""Test the IPython.kernel public API
+"""Test the jupyter_client public API
 
 Authors
 -------
@@ -14,7 +14,7 b' Authors'
 
 import nose.tools as nt
 
-from IPython.kernel import launcher, connect
+from jupyter_client import launcher, connect
 from IPython import kernel
 
 #-----------------------------------------------------------------------------
@@ -38,4 +38,3 b' def test_launcher():'
 def test_connect():
     for name in connect.__all__:
         nt.assert_in(name, dir(kernel))
-

jupyter_client/tests/test_session.py

@@ -13,7 +13,7 b' 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
@@ -77,7 +77,7 b' class TestSession(SessionTestCase):'
 
         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')
@@ -88,7 +88,7 b' class TestSession(SessionTestCase):'
         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
@@ -107,9 +107,9 b' class TestSession(SessionTestCase):'
         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')
@@ -216,7 +216,7 b' class TestSession(SessionTestCase):'
         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)
@@ -225,7 +225,7 b' class TestSession(SessionTestCase):'
             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)
@@ -234,7 +234,7 b' class TestSession(SessionTestCase):'
             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')
@@ -243,7 +243,7 b' class TestSession(SessionTestCase):'
             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')
@@ -252,11 +252,11 b' class TestSession(SessionTestCase):'
             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())
@@ -274,24 +274,24 b' class TestSession(SessionTestCase):'
         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)
@@ -300,10 +300,10 b' class TestSession(SessionTestCase):'
         B.connect("inproc://test")
 
         msg = self.session.msg('execute', content=dict(a=10))
-        msg_list = [self.session.pack(msg[part]) for part in 
+        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')

setupbase.py

@@ -204,7 +204,7 b' def find_package_data():'
         #     'v3/nbformat.v3.schema.json',
         #     'v4/nbformat.v4.schema.json',
         #     ],
-        'IPython.kernel': ['resources/*.*'],
+        # 'IPython.kernel': ['resources/*.*'],
     }
     
     return package_data