Remove some dead code

IPython/kernel/blocking/channels.py

@@ -6,14 +6,13 b' Useful for test suites and blocking terminal interfaces.'
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
-import atexit
-import zmq
-
 try:
     from queue import Queue, Empty  # Py 3
 except ImportError:
     from Queue import Queue, Empty  # Py 2
 
+from IPython.kernel.channelsabc import ShellChannelABC, IOPubChannelABC, \
+    StdInChannelABC
 from IPython.kernel.channels import  HBChannel,\
     make_iopub_socket, make_shell_socket, make_stdin_socket,\
     InvalidPortNumber, major_protocol_version
@@ -368,6 +367,10 b' class BlockingStdInChannel(ZMQSocketChannel):'
         msg = self.session.msg('input_reply', content)
         self._queue_send(msg)
 
+ShellChannelABC.register(BlockingShellChannel)
+IOPubChannelABC.register(BlockingIOPubChannel)
+StdInChannelABC.register(BlockingStdInChannel)
+
 
 class BlockingHBChannel(HBChannel):
 

IPython/kernel/channels.py

@@ -180,326 +180,6 b' class ZMQSocketChannel(Thread):'
         self.call_handlers(msg)
 
 
-
-class ShellChannel(ZMQSocketChannel):
-    """The shell channel for issuing request/replies to the kernel."""
-
-    command_queue = None
-    # flag for whether execute requests should be allowed to call raw_input:
-    allow_stdin = True
-    proxy_methods = [
-        'execute',
-        'complete',
-        'inspect',
-        'history',
-        'kernel_info',
-        'shutdown',
-        'is_complete',
-    ]
-
-    def __init__(self, context, session, address):
-        super(ShellChannel, self).__init__(context, session, address)
-        self.ioloop = ioloop.IOLoop()
-    
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self.socket = self.context.socket(zmq.DEALER)
-        self.socket.linger = 1000
-        self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
-        self.socket.connect(self.address)
-        self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
-        self.stream.on_recv(self._handle_recv)
-        self._run_loop()
-
-    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.
-        """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
-
-    def execute(self, code, silent=False, store_history=True,
-                user_expressions=None, allow_stdin=None):
-        """Execute code in the kernel.
-
-        Parameters
-        ----------
-        code : str
-            A string of Python code.
-
-        silent : bool, optional (default False)
-            If set, the kernel will execute the code as quietly possible, and
-            will force store_history to be False.
-
-        store_history : bool, optional (default True)
-            If set, the kernel will store command history.  This is forced
-            to be False if silent is True.
-
-        user_expressions : dict, optional
-            A dict mapping names to expressions to be evaluated in the user's
-            dict. The expression values are returned as strings formatted using
-            :func:`repr`.
-
-        allow_stdin : bool, optional (default self.allow_stdin)
-            Flag for whether the kernel can send stdin requests to frontends.
-
-            Some frontends (e.g. the Notebook) do not support stdin requests.
-            If raw_input is called from code executed from such a frontend, a
-            StdinNotImplementedError will be raised.
-
-        Returns
-        -------
-        The msg_id of the message sent.
-        """
-        if user_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,
-                       )
-        msg = self.session.msg('execute_request', content)
-        self._queue_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._queue_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._queue_send(msg)
-        return msg['header']['msg_id']
-
-    def history(self, raw=True, output=False, hist_access_type='range', **kwargs):
-        """Get entries from the kernel's history list.
-
-        Parameters
-        ----------
-        raw : bool
-            If True, return the raw input.
-        output : bool
-            If True, then return the output as well.
-        hist_access_type : str
-            'range' (fill in session, start and stop params), 'tail' (fill in n)
-             or 'search' (fill in pattern param).
-
-        session : int
-            For a range request, the session from which to get lines. Session
-            numbers are positive integers; negative ones count back from the
-            current session.
-        start : int
-            The first line number of a history range.
-        stop : int
-            The final (excluded) line number of a history range.
-
-        n : int
-            The number of lines of history to get for a tail request.
-
-        pattern : str
-            The glob-syntax pattern for a search request.
-
-        Returns
-        -------
-        The msg_id of the message sent.
-        """
-        content = dict(raw=raw, output=output, hist_access_type=hist_access_type,
-                                                                    **kwargs)
-        msg = self.session.msg('history_request', content)
-        self._queue_send(msg)
-        return msg['header']['msg_id']
-
-    def kernel_info(self):
-        """Request kernel info."""
-        msg = self.session.msg('kernel_info_request')
-        self._queue_send(msg)
-        return msg['header']['msg_id']
-    
-    def _handle_kernel_info_reply(self, msg):
-        """handle kernel info reply
-        
-        sets protocol adaptation version
-        """
-        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._queue_send(msg)
-        return msg['header']['msg_id']
-
-    def is_complete(self, code):
-        msg = self.session.msg('is_complete_request', {'code': code})
-        self._queue_send(msg)
-        return msg['header']['msg_id']
-
-
-class IOPubChannel(ZMQSocketChannel):
-    """The iopub channel which listens for messages that the kernel publishes.
-
-    This channel is where all output is published to frontends.
-    """
-
-    def __init__(self, context, session, address):
-        super(IOPubChannel, self).__init__(context, session, address)
-        self.ioloop = ioloop.IOLoop()
-
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self.socket = self.context.socket(zmq.SUB)
-        self.socket.linger = 1000
-        self.socket.setsockopt(zmq.SUBSCRIBE,b'')
-        self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
-        self.socket.connect(self.address)
-        self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
-        self.stream.on_recv(self._handle_recv)
-        self._run_loop()
-
-    def call_handlers(self, msg):
-        """This method is called in the ioloop thread when a message arrives.
-
-        Subclasses should override this method to handle incoming messages.
-        It is important to remember that this method is called in the thread
-        so that some logic must be done to ensure that the application leve
-        handlers are called in the application thread.
-        """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
-
-    def flush(self, timeout=1.0):
-        """Immediately processes all pending messages on the iopub channel.
-
-        Callers should use this method to ensure that :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 StdInChannel(ZMQSocketChannel):
-    """The stdin channel to handle raw_input requests that the kernel makes."""
-
-    msg_queue = None
-    proxy_methods = ['input']
-
-    def __init__(self, context, session, address):
-        super(StdInChannel, self).__init__(context, session, address)
-        self.ioloop = ioloop.IOLoop()
-
-    def run(self):
-        """The thread's main activity.  Call start() instead."""
-        self.socket = self.context.socket(zmq.DEALER)
-        self.socket.linger = 1000
-        self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
-        self.socket.connect(self.address)
-        self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
-        self.stream.on_recv(self._handle_recv)
-        self._run_loop()
-
-    def call_handlers(self, msg):
-        """This method is called in the ioloop thread when a message arrives.
-
-        Subclasses should override this method to handle incoming messages.
-        It is important to remember that this method is called in the thread
-        so that some logic must be done to ensure that the application leve
-        handlers are called in the application thread.
-        """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
-
-    def input(self, string):
-        """Send a string of raw input to the kernel."""
-        content = dict(value=string)
-        msg = self.session.msg('input_reply', content)
-        self._queue_send(msg)
-
 def make_shell_socket(context, identity, address):
     socket = context.socket(zmq.DEALER)
     socket.linger = 1000
@@ -655,11 +335,4 b' class HBChannel(ZMQSocketChannel):'
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
 
-#---------------------------------------------------------------------#-----------------------------------------------------------------------------
-# ABC Registration
-#-----------------------------------------------------------------------------
-
-ShellChannelABC.register(ShellChannel)
-IOPubChannelABC.register(IOPubChannel)
 HBChannelABC.register(HBChannel)
-StdInChannelABC.register(StdInChannel)

IPython/kernel/client.py

@@ -11,10 +11,8 b' from IPython.utils.traitlets import ('
     Any, Instance, Type,
 )
 
-from .zmq.session import Session
-from .channels import (
-    ShellChannel, IOPubChannel,
-    HBChannel, StdInChannel,
+from .channelsabc import (
+    ShellChannelABC, IOPubChannelABC, HBChannelABC, StdInChannelABC
 )
 from .clientabc import KernelClientABC
 from .connect import ConnectionFileMixin
@@ -42,10 +40,10 b' class KernelClient(ConnectionFileMixin):'
         return zmq.Context.instance()
 
     # The classes to use for the various channels
-    shell_channel_class = Type(ShellChannel)
-    iopub_channel_class = Type(IOPubChannel)
-    stdin_channel_class = Type(StdInChannel)
-    hb_channel_class = Type(HBChannel)
+    shell_channel_class = Type(ShellChannelABC)
+    iopub_channel_class = Type(IOPubChannelABC)
+    stdin_channel_class = Type(StdInChannelABC)
+    hb_channel_class = Type(HBChannelABC)
 
     # Protected traits
     _shell_channel = Any