From d99901f3bccde108b53b6888143fea047ab3be08 2014-12-05 01:48:48 From: Thomas Kluyver Date: 2014-12-05 01:48:48 Subject: [PATCH] Remove some dead code --- diff --git a/IPython/kernel/blocking/channels.py b/IPython/kernel/blocking/channels.py index 805f465..d32d4d1 100644 --- a/IPython/kernel/blocking/channels.py +++ b/IPython/kernel/blocking/channels.py @@ -6,14 +6,13 @@ 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 @@ 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): diff --git a/IPython/kernel/channels.py b/IPython/kernel/channels.py index e6df05d..efa58ba 100644 --- a/IPython/kernel/channels.py +++ b/IPython/kernel/channels.py @@ -180,326 +180,6 @@ 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 @@ 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) diff --git a/IPython/kernel/client.py b/IPython/kernel/client.py index e7f47cc..c607c40 100644 --- a/IPython/kernel/client.py +++ b/IPython/kernel/client.py @@ -11,10 +11,8 @@ 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 @@ 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