bigsplit: ipython_kernel

IPython/kernel/adapter.py

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

IPython/kernel/channels.py

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

IPython/kernel/channelsabc.py

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

IPython/kernel/client.py

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

IPython/kernel/clientabc.py

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

IPython/kernel/connect.py

@@ -0,0 +1,2 b''
+from ipython_kernel.connect import *
+from jupyter_client.connect import *

IPython/kernel/kernelspec.py

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

IPython/kernel/kernelspecapp.py

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

IPython/kernel/launcher.py

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

IPython/kernel/manager.py

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

IPython/kernel/managerabc.py

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

IPython/kernel/multikernelmanager.py

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

IPython/kernel/restarter.py

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

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/threaded.py

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

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.zmq 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 jupyter_client.kernelapp import IPKernelApp
+        if not IPKernelApp.initialized():
+            raise RuntimeError("app not specified, and not in a running Kernel")
+
+        app = IPKernelApp.instance()
+    return filefind(app.connection_file, ['.', app.profile_dir.security_dir])
+
+
+def find_connection_file(filename='kernel-*.json', profile=None):
+    """find a connection file, and return its absolute path.
+
+    The current working directory and the profile's security
+    directory will be searched for the file if it is not given by
+    absolute path.
+
+    If profile is unspecified, then the current running application's
+    profile will be used, or 'default', if not run from IPython.
+
+    If the argument does not match an existing file, it will be interpreted as a
+    fileglob, and the matching file in the profile's security dir with
+    the latest access time will be used.
+
+    Parameters
+    ----------
+    filename : str
+        The connection file or fileglob to search for.
+    profile : str [optional]
+        The name of the profile to use when searching for the connection file,
+        if different from the current IPython session or 'default'.
+
+    Returns
+    -------
+    str : The absolute path of the connection file.
+    """
+    from IPython.core.application import BaseIPythonApplication as IPApp
+    try:
+        # quick check for absolute path, before going through logic
+        return filefind(filename)
+    except IOError:
+        pass
+
+    if profile is None:
+        # profile unspecified, check if running from an IPython app
+        if IPApp.initialized():
+            app = IPApp.instance()
+            profile_dir = app.profile_dir
+        else:
+            # not running in IPython, use default profile
+            profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), 'default')
+    else:
+        # find profiledir by profile name:
+        profile_dir = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
+    security_dir = profile_dir.security_dir
+
+    try:
+        # first, try explicit name
+        return filefind(filename, ['.', security_dir])
+    except IOError:
+        pass
+
+    # not found by full name
+
+    if '*' in filename:
+        # given as a glob already
+        pat = filename
+    else:
+        # accept any substring match
+        pat = '*%s*' % filename
+    matches = glob.glob( os.path.join(security_dir, pat) )
+    if not matches:
+        raise IOError("Could not find %r in %r" % (filename, security_dir))
+    elif len(matches) == 1:
+        return matches[0]
+    else:
+        # get most recent match, by access time:
+        return sorted(matches, key=lambda f: os.stat(f).st_atime)[-1]
+
+
+def get_connection_info(connection_file=None, unpack=False, profile=None):
+    """Return the connection information for the current Kernel.
+
+    Parameters
+    ----------
+    connection_file : str [optional]
+        The connection file to be used. Can be given by absolute path, or
+        IPython will search in the security directory of a given profile.
+        If run from IPython,
+
+        If unspecified, the connection file for the currently running
+        IPython Kernel will be used, which is only allowed from inside a kernel.
+    unpack : bool [default: False]
+        if True, return the unpacked dict, otherwise just the string contents
+        of the file.
+    profile : str [optional]
+        The name of the profile to use when searching for the connection file,
+        if different from the current IPython session or 'default'.
+
+
+    Returns
+    -------
+    The connection dictionary of the current kernel, as string or dict,
+    depending on `unpack`.
+    """
+    if connection_file is None:
+        # get connection file from current kernel
+        cf = get_connection_file()
+    else:
+        # connection file specified, allow shortnames:
+        cf = find_connection_file(connection_file, profile=profile)
+
+    with open(cf) as f:
+        info = f.read()
+
+    if unpack:
+        info = json.loads(info)
+        # ensure key is bytes:
+        info['key'] = str_to_bytes(info.get('key', ''))
+    return info
+
+
+def connect_qtconsole(connection_file=None, argv=None, profile=None):
+    """Connect a qtconsole to the current kernel.
+
+    This is useful for connecting a second qtconsole to a kernel, or to a
+    local notebook.
+
+    Parameters
+    ----------
+    connection_file : str [optional]
+        The connection file to be used. Can be given by absolute path, or
+        IPython will search in the security directory of a given profile.
+        If run from IPython,
+
+        If unspecified, the connection file for the currently running
+        IPython Kernel will be used, which is only allowed from inside a kernel.
+    argv : list [optional]
+        Any extra args to be passed to the console.
+    profile : str [optional]
+        The name of the profile to use when searching for the connection file,
+        if different from the current IPython session or 'default'.
+
+
+    Returns
+    -------
+    :class:`subprocess.Popen` instance running the qtconsole frontend
+    """
+    argv = [] if argv is None else argv
+
+    if connection_file is None:
+        # get connection file from current kernel
+        cf = get_connection_file()
+    else:
+        cf = find_connection_file(connection_file, profile=profile)
+
+    cmd = ';'.join([
+        "from IPython.qt.console import qtconsoleapp",
+        "qtconsoleapp.main()"
+    ])
+
+    return Popen([sys.executable, '-c', cmd, '--existing', cf] + argv,
+        stdout=PIPE, stderr=PIPE, close_fds=(sys.platform != 'win32'),
+    )
+
+
+def tunnel_to_kernel(connection_info, sshserver, sshkey=None):
+    """tunnel connections to a kernel via ssh
+
+    This will open four SSH tunnels from localhost on this machine to the
+    ports associated with the kernel.  They can be either direct
+    localhost-localhost tunnels, or if an intermediate server is necessary,
+    the kernel must be listening on a public IP.
+
+    Parameters
+    ----------
+    connection_info : dict or str (path)
+        Either a connection dict, or the path to a JSON connection file
+    sshserver : str
+        The ssh sever to use to tunnel to the kernel. Can be a full
+        `user@server:port` string. ssh config aliases are respected.
+    sshkey : str [optional]
+        Path to file containing ssh key to use for authentication.
+        Only necessary if your ssh config does not already associate
+        a keyfile with the host.
+
+    Returns
+    -------
+
+    (shell, iopub, stdin, hb) : ints
+        The four ports on localhost that have been forwarded to the kernel.
+    """
+    from zmq.ssh import tunnel
+    if isinstance(connection_info, string_types):
+        # it's a path, unpack it
+        with open(connection_info) as f:
+            connection_info = json.loads(f.read())
+
+    cf = connection_info
+
+    lports = tunnel.select_random_ports(4)
+    rports = cf['shell_port'], cf['iopub_port'], cf['stdin_port'], cf['hb_port']
+
+    remote_ip = cf['ip']
+
+    if tunnel.try_passwordless_ssh(sshserver, sshkey):
+        password=False
+    else:
+        password = getpass("SSH Password for %s: " % cast_bytes_py2(sshserver))
+
+    for lp,rp in zip(lports, rports):
+        tunnel.ssh_tunnel(lp, rp, sshserver, remote_ip, sshkey, password)
+
+    return tuple(lports)
+
+
+#-----------------------------------------------------------------------------
+# Mixin for classes that work with connection files
+#-----------------------------------------------------------------------------
+
+channel_socket_types = {
+    'hb' : zmq.REQ,
+    'shell' : zmq.DEALER,
+    'iopub' : zmq.SUB,
+    'stdin' : zmq.DEALER,
+    'control': zmq.DEALER,
+}
+
+port_names = [ "%s_port" % channel for channel in ('shell', 'stdin', 'iopub', 'hb', 'control')]
+
+class ConnectionFileMixin(LoggingConfigurable):
+    """Mixin for configurable classes that work with connection files"""
+
+    # The addresses for the communication channels
+    connection_file = Unicode('', config=True,
+    help="""JSON file in which to store connection info [default: kernel-<pid>.json]
+
+    This file will contain the IP, ports, and authentication key needed to connect
+    clients to this kernel. By default, this file will be created in the security dir
+    of the current profile, but can be specified by absolute path.
+    """)
+    _connection_file_written = Bool(False)
+
+    transport = CaselessStrEnum(['tcp', 'ipc'], default_value='tcp', config=True)
+
+    ip = Unicode(config=True,
+        help="""Set the kernel\'s IP address [default localhost].
+        If the IP address is something other than localhost, then
+        Consoles on other machines will be able to connect
+        to the Kernel, so be careful!"""
+    )
+
+    def _ip_default(self):
+        if self.transport == 'ipc':
+            if self.connection_file:
+                return os.path.splitext(self.connection_file)[0] + '-ipc'
+            else:
+                return 'kernel-ipc'
+        else:
+            return localhost()
+
+    def _ip_changed(self, name, old, new):
+        if new == '*':
+            self.ip = '0.0.0.0'
+
+    # protected traits
+
+    hb_port = Integer(0, config=True,
+            help="set the heartbeat port [default: random]")
+    shell_port = Integer(0, config=True,
+            help="set the shell (ROUTER) port [default: random]")
+    iopub_port = Integer(0, config=True,
+            help="set the iopub (PUB) port [default: random]")
+    stdin_port = Integer(0, config=True,
+            help="set the stdin (ROUTER) port [default: random]")
+    control_port = Integer(0, config=True,
+            help="set the control (ROUTER) port [default: random]")
+
+    @property
+    def ports(self):
+        return [ getattr(self, name) for name in port_names ]
+
+    # The Session to use for communication with the kernel.
+    session = Instance('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/zmq/session.py

@@ -0,0 +1,1 b''
+from jupyter_client.session 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/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.zmq.kernelbase import Kernel
 
 from IPython.utils.jsonutil import json_clean
 from IPython.utils.traitlets import Instance, Unicode, Bytes, Bool, Dict, Any
@@ -20,7 +20,7 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.zmq.kernelbase.Kernel')
     def _kernel_default(self):
         if Kernel.initialized():
             return Kernel.instance()
@@ -28,7 +28,7 b' class Comm(LoggingConfigurable):'
     iopub_socket = Any()
     def _iopub_socket_default(self):
         return self.kernel.iopub_socket
-    session = Instance('IPython.kernel.zmq.session.Session')
+    session = Instance('ipython_kernel.zmq.session.Session')
     def _session_default(self):
         if self.kernel is not None:
             return self.kernel.session

ipython_kernel/comm/manager.py

@@ -31,12 +31,12 b' class CommManager(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.zmq.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.zmq.session.Session')
     def _session_default(self):
         return self.kernel.session
     

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.zmq.ipkernel import IPythonKernel
+from ipython_kernel.zmq.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)
     )
 
@@ -121,18 +121,18 b' class InProcessKernel(IPythonKernel):'
         return logging.getLogger(__name__)
 
     def _session_default(self):
-        from IPython.kernel.zmq.session import Session
+        from ipython_kernel.zmq.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.zmq.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.zmq.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.zmq.eventloops import enable_gui
         if not gui:
             gui = self.kernel.gui
         return enable_gui(gui, kernel=self.kernel)

ipython_kernel/inprocess/manager.py

@@ -4,26 +4,26 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
@@ -34,7 +34,7 b' class InProcessKernelManager(KernelManager):'
     #--------------------------------------------------------------------------
 
     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/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/tests/test_message_spec.py

@@ -493,4 +493,3 b' def test_display_data():'
     validate_message(display, 'display_data', parent=msg_id)
     data = display['content']['data']
     nt.assert_equal(data['text/plain'], u'1')
-

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
@@ -123,7 +124,8 b' def new_kernel(argv=None):'
     -------
     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/zmq/__init__.py

@@ -5,7 +5,7 b''
 
 from IPython.utils.zmqrelated import check_for_zmq
 
-check_for_zmq('13', 'IPython.kernel.zmq')
-
-from .session import Session
+check_for_zmq('13', 'ipython_kernel.zmq')
 
+from jupyter_client import session
+Session = session.Session

ipython_kernel/zmq/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.zmq.serialize import serialize_object
+from ipython_kernel.zmq.session import Session, extract_header
 
 #-----------------------------------------------------------------------------
 # Code
@@ -66,5 +66,5 b' def publish_data(data):'
     data : dict
         The data to be published. Think of it as a namespace.
     """
-    from IPython.kernel.zmq.zmqshell import ZMQInteractiveShell
+    from ipython_kernel.zmq.zmqshell import ZMQInteractiveShell
     ZMQInteractiveShell.instance().data_pub.publish_data(data)

ipython_kernel/zmq/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/zmq/eventloops.py

@@ -49,7 +49,7 b' def register_integration(*toolkitnames):'
     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.zmq.eventloops` provides and registers such functions
     for a few common event loops.
     """
     def decorator(func):

ipython_kernel/zmq/ipkernel.py

@@ -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.zmq.ipkernel.IPythonKernel',
                       DeprecationWarning)
         super(Kernel, self).__init__(*args, **kwargs)

ipython_kernel/zmq/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,8 +99,8 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.zmq.ipkernel.IPythonKernel', config=True,
+                        klass='ipython_kernel.zmq.kernelbase.Kernel',
     help="""The Kernel subclass to be used.
     
     This should allow easy re-use of the IPKernelApp entry point
@@ -124,9 +124,9 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp,'
     # 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.zmq.iostream.OutStream',
         config=True, help="The importstring for the OutStream factory")
-    displayhook_class = DottedObjectName('IPython.kernel.zmq.displayhook.ZMQDisplayHook',
+    displayhook_class = DottedObjectName('ipython_kernel.zmq.displayhook.ZMQDisplayHook',
         config=True, help="The importstring for the DisplayHook factory")
 
     # polling

ipython_kernel/zmq/kernelbase.py

@@ -324,7 +324,7 b' class Kernel(SingletonConfigurable):'
              buffers=None, track=False, header=None, metadata=None):
         """Send a response to the message we're currently processing.
         
-        This accepts all the parameters of :meth:`IPython.kernel.zmq.session.Session.send`
+        This accepts all the parameters of :meth:`ipython_kernel.zmq.session.Session.send`
         except ``parent``.
         
         This relies on :meth:`set_parent` having been called for the current

ipython_kernel/zmq/log.py

@@ -18,4 +18,3 b' class EnginePUBHandler(PUBHandler):'
             return "engine.%i"%self.engine.id
         else:
             return "engine"
-    

ipython_kernel/zmq/pylab/backend_inline.py

@@ -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/zmq/pylab/config.py

@@ -117,4 +117,3 b' class InlineBackend(InlineBackendConfig):'
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                      allow_none=True)
 
-

ipython_kernel/zmq/serialize.py

@@ -17,7 +17,7 b' from IPython.utils.pickleutil import ('
     can, uncan, can_sequence, uncan_sequence, CannedObject,
     istype, sequence_types, PICKLE_PROTOCOL,
 )
-from .session import MAX_ITEMS, MAX_BYTES
+from jupyter_client.session import MAX_ITEMS, MAX_BYTES
 
 
 if PY3:
@@ -177,4 +177,3 b' def unpack_apply_message(bufs, g=None, copy=True):'
     assert not kwarg_bufs, "Shouldn't be any kwarg bufs left over"
     
     return f,args,kwargs
-

ipython_kernel/zmq/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
 
@@ -195,5 +195,3 b' def test_embed_kernel_reentrant():'
             client.execute("get_ipython().exit_now = True")
             msg = client.get_shell_msg(block=True, timeout=TIMEOUT)
             time.sleep(0.2)
-
-

ipython_kernel/zmq/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.zmq.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

ipython_kernel/zmq/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.zmq.displayhook import ZMQShellDisplayHook
+from ipython_kernel.zmq.datapub import ZMQDataPublisher
+from ipython_kernel.zmq.session import extract_header
 from .session import Session
 
 #-----------------------------------------------------------------------------