def __init__(self, **kwargs): super(Kernel, self).__init__(**kwargs) self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types msg_types = [ 'execute_request', 'complete_request', 'object_info_request', 'shutdown_request' ] self.handlers = {} for msg_type in msg_types: self.handlers[msg_type] = getattr(self, msg_type)
def __init__(self, session, reply_socket, pub_socket): self.session = session self.reply_socket = reply_socket self.pub_socket = pub_socket self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types self.handlers = {} for msg_type in ['execute_request', 'complete_request']: self.handlers[msg_type] = getattr(self, msg_type)
def __init__(self, **kwargs): super(Kernel, self).__init__(**kwargs) self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types msg_types = ["execute_request", "complete_request", "object_info_request", "shutdown_request"] self.handlers = {} for msg_type in msg_types: self.handlers[msg_type] = getattr(self, msg_type)
def __init__(self, session, reply_socket, pub_socket): self.session = session self.reply_socket = reply_socket self.pub_socket = pub_socket self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types self.handlers = {} for msg_type in ["execute_request", "complete_request"]: self.handlers[msg_type] = getattr(self, msg_type)
class Kernel(HasTraits): # Private interface # Time to sleep after flushing the stdout/err buffers in each execute # cycle. While this introduces a hard limit on the minimal latency of the # execute cycle, it helps prevent output synchronization problems for # clients. # Units are in seconds. The minimum zmq latency on local host is probably # ~150 microseconds, set this to 500us for now. We may need to increase it # a little if it's not enough after more interactive testing. _execute_sleep = Float(0.0005, config=True) # This is a dict of port number that the kernel is listening on. It is set # by record_ports and used by connect_request. _recorded_ports = Dict() #--------------------------------------------------------------------------- # Kernel interface #--------------------------------------------------------------------------- session = Instance(Session) shell_socket = Instance('zmq.Socket') iopub_socket = Instance('zmq.Socket') stdin_socket = Instance('zmq.Socket') log = Instance('logging.Logger') def __init__(self, **kwargs): super(Kernel, self).__init__(**kwargs) self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types msg_types = [ 'execute_request', 'complete_request', 'object_info_request', 'shutdown_request' ] self.handlers = {} for msg_type in msg_types: self.handlers[msg_type] = getattr(self, msg_type) def start(self): """ Start the kernel main loop. """ while True: ident, msg = self.session.recv(self.shell_socket, 0) assert ident is not None, "Missing message part." omsg = Message(msg) self.log.debug(str(omsg)) handler = self.handlers.get(omsg.msg_type, None) if handler is None: self.log.error("UNKNOWN MESSAGE TYPE: %s" % omsg) else: handler(ident, omsg) def record_ports(self, ports): """Record the ports that this kernel is using. The creator of the Kernel instance must call this methods if they want the :meth:`connect_request` method to return the port numbers. """ self._recorded_ports = ports #--------------------------------------------------------------------------- # Kernel request handlers #--------------------------------------------------------------------------- def execute_request(self, ident, parent): try: code = parent[u'content'][u'code'] except: self.log.error("Got bad msg: %s" % Message(parent)) return pyin_msg = self.session.send(self.iopub_socket, u'pyin', {u'code': code}, parent=parent) try: comp_code = self.compiler(code, '<zmq-kernel>') # Replace raw_input. Note that is not sufficient to replace # raw_input in the user namespace. raw_input = lambda prompt='': self._raw_input( prompt, ident, parent) __builtin__.raw_input = raw_input # Set the parent message of the display hook and out streams. sys.displayhook.set_parent(parent) sys.stdout.set_parent(parent) sys.stderr.set_parent(parent) exec comp_code in self.user_ns, self.user_ns except: etype, evalue, tb = sys.exc_info() tb = traceback.format_exception(etype, evalue, tb) exc_content = { u'status': u'error', u'traceback': tb, u'ename': unicode(etype.__name__), u'evalue': unicode(evalue) } exc_msg = self.session.send(self.iopub_socket, u'pyerr', exc_content, parent) reply_content = exc_content else: reply_content = {'status': 'ok', 'payload': {}} # Flush output before sending the reply. sys.stderr.flush() sys.stdout.flush() # FIXME: on rare occasions, the flush doesn't seem to make it to the # clients... This seems to mitigate the problem, but we definitely need # to better understand what's going on. if self._execute_sleep: time.sleep(self._execute_sleep) # Send the reply. reply_msg = self.session.send(self.shell_socket, u'execute_reply', reply_content, parent, ident=ident) self.log.debug(Message(reply_msg)) if reply_msg['content']['status'] == u'error': self._abort_queue() def complete_request(self, ident, parent): matches = {'matches': self._complete(parent), 'status': 'ok'} completion_msg = self.session.send(self.shell_socket, 'complete_reply', matches, parent, ident) self.log.debug(completion_msg) def object_info_request(self, ident, parent): context = parent['content']['oname'].split('.') object_info = self._object_info(context) msg = self.session.send(self.shell_socket, 'object_info_reply', object_info, parent, ident) self.log.debug(msg) def shutdown_request(self, ident, parent): content = dict(parent['content']) msg = self.session.send(self.shell_socket, 'shutdown_reply', content, parent, ident) msg = self.session.send(self.iopub_socket, 'shutdown_reply', content, parent, ident) self.log.debug(msg) time.sleep(0.1) sys.exit(0) #--------------------------------------------------------------------------- # Protected interface #--------------------------------------------------------------------------- def _abort_queue(self): while True: ident, msg = self.session.recv(self.shell_socket, zmq.NOBLOCK) if msg is None: # msg=None on EAGAIN break else: assert ident is not None, "Missing message part." self.log.debug("Aborting: %s" % Message(msg)) msg_type = msg['msg_type'] reply_type = msg_type.split('_')[0] + '_reply' reply_msg = self.session.send(self.shell_socket, reply_type, {'status': 'aborted'}, msg, ident=ident) self.log.debug(Message(reply_msg)) # We need to wait a bit for requests to come in. This can probably # be set shorter for true asynchronous clients. time.sleep(0.1) def _raw_input(self, prompt, ident, parent): # Flush output before making the request. sys.stderr.flush() sys.stdout.flush() # Send the input request. content = dict(prompt=prompt) msg = self.session.send(self.stdin_socket, u'input_request', content, parent) # Await a response. ident, reply = self.session.recv(self.stdin_socket, 0) try: value = reply['content']['value'] except: self.log.error("Got bad raw_input reply: %s" % Message(parent)) value = '' return value def _complete(self, msg): return self.completer.complete(msg.content.line, msg.content.text) def _object_info(self, context): symbol, leftover = self._symbol_from_context(context) if symbol is not None and not leftover: doc = getattr(symbol, '__doc__', '') else: doc = '' object_info = dict(docstring=doc) return object_info def _symbol_from_context(self, context): if not context: return None, context base_symbol_string = context[0] symbol = self.user_ns.get(base_symbol_string, None) if symbol is None: symbol = __builtin__.__dict__.get(base_symbol_string, None) if symbol is None: return None, context context = context[1:] for i, name in enumerate(context): new_symbol = getattr(symbol, name, None) if new_symbol is None: return symbol, context[i:] else: symbol = new_symbol return symbol, []
class Kernel(HasTraits): # Private interface # Time to sleep after flushing the stdout/err buffers in each execute # cycle. While this introduces a hard limit on the minimal latency of the # execute cycle, it helps prevent output synchronization problems for # clients. # Units are in seconds. The minimum zmq latency on local host is probably # ~150 microseconds, set this to 500us for now. We may need to increase it # a little if it's not enough after more interactive testing. _execute_sleep = Float(0.0005, config=True) # This is a dict of port number that the kernel is listening on. It is set # by record_ports and used by connect_request. _recorded_ports = Dict() #--------------------------------------------------------------------------- # Kernel interface #--------------------------------------------------------------------------- session = Instance(Session) shell_socket = Instance('zmq.Socket') iopub_socket = Instance('zmq.Socket') stdin_socket = Instance('zmq.Socket') log = Instance('logging.Logger') def __init__(self, **kwargs): super(Kernel, self).__init__(**kwargs) self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types msg_types = [ 'execute_request', 'complete_request', 'object_info_request', 'shutdown_request' ] self.handlers = {} for msg_type in msg_types: self.handlers[msg_type] = getattr(self, msg_type) def start(self): """ Start the kernel main loop. """ while True: ident,msg = self.session.recv(self.shell_socket,0) assert ident is not None, "Missing message part." omsg = Message(msg) self.log.debug(str(omsg)) handler = self.handlers.get(omsg.msg_type, None) if handler is None: self.log.error("UNKNOWN MESSAGE TYPE: %s"%omsg) else: handler(ident, omsg) def record_ports(self, ports): """Record the ports that this kernel is using. The creator of the Kernel instance must call this methods if they want the :meth:`connect_request` method to return the port numbers. """ self._recorded_ports = ports #--------------------------------------------------------------------------- # Kernel request handlers #--------------------------------------------------------------------------- def execute_request(self, ident, parent): try: code = parent[u'content'][u'code'] except: self.log.error("Got bad msg: %s"%Message(parent)) return pyin_msg = self.session.send(self.iopub_socket, u'pyin',{u'code':code}, parent=parent) try: comp_code = self.compiler(code, '<zmq-kernel>') # Replace raw_input. Note that is not sufficient to replace # raw_input in the user namespace. raw_input = lambda prompt='': self._raw_input(prompt, ident, parent) __builtin__.raw_input = raw_input # Set the parent message of the display hook and out streams. sys.displayhook.set_parent(parent) sys.stdout.set_parent(parent) sys.stderr.set_parent(parent) exec comp_code in self.user_ns, self.user_ns except: etype, evalue, tb = sys.exc_info() tb = traceback.format_exception(etype, evalue, tb) exc_content = { u'status' : u'error', u'traceback' : tb, u'ename' : unicode(etype.__name__), u'evalue' : unicode(evalue) } exc_msg = self.session.send(self.iopub_socket, u'pyerr', exc_content, parent) reply_content = exc_content else: reply_content = { 'status' : 'ok', 'payload' : {} } # Flush output before sending the reply. sys.stderr.flush() sys.stdout.flush() # FIXME: on rare occasions, the flush doesn't seem to make it to the # clients... This seems to mitigate the problem, but we definitely need # to better understand what's going on. if self._execute_sleep: time.sleep(self._execute_sleep) # Send the reply. reply_msg = self.session.send(self.shell_socket, u'execute_reply', reply_content, parent, ident=ident) self.log.debug(Message(reply_msg)) if reply_msg['content']['status'] == u'error': self._abort_queue() def complete_request(self, ident, parent): matches = {'matches' : self._complete(parent), 'status' : 'ok'} completion_msg = self.session.send(self.shell_socket, 'complete_reply', matches, parent, ident) self.log.debug(completion_msg) def object_info_request(self, ident, parent): context = parent['content']['oname'].split('.') object_info = self._object_info(context) msg = self.session.send(self.shell_socket, 'object_info_reply', object_info, parent, ident) self.log.debug(msg) def shutdown_request(self, ident, parent): content = dict(parent['content']) msg = self.session.send(self.shell_socket, 'shutdown_reply', content, parent, ident) msg = self.session.send(self.iopub_socket, 'shutdown_reply', content, parent, ident) self.log.debug(msg) time.sleep(0.1) sys.exit(0) #--------------------------------------------------------------------------- # Protected interface #--------------------------------------------------------------------------- def _abort_queue(self): while True: ident,msg = self.session.recv(self.shell_socket, zmq.NOBLOCK) if msg is None: # msg=None on EAGAIN break else: assert ident is not None, "Missing message part." self.log.debug("Aborting: %s"%Message(msg)) msg_type = msg['header']['msg_type'] reply_type = msg_type.split('_')[0] + '_reply' reply_msg = self.session.send(self.shell_socket, reply_type, {'status':'aborted'}, msg, ident=ident) self.log.debug(Message(reply_msg)) # We need to wait a bit for requests to come in. This can probably # be set shorter for true asynchronous clients. time.sleep(0.1) def _raw_input(self, prompt, ident, parent): # Flush output before making the request. sys.stderr.flush() sys.stdout.flush() # Send the input request. content = dict(prompt=prompt) msg = self.session.send(self.stdin_socket, u'input_request', content, parent) # Await a response. ident,reply = self.session.recv(self.stdin_socket, 0) try: value = reply['content']['value'] except: self.log.error("Got bad raw_input reply: %s"%Message(parent)) value = '' return value def _complete(self, msg): return self.completer.complete(msg.content.line, msg.content.text) def _object_info(self, context): symbol, leftover = self._symbol_from_context(context) if symbol is not None and not leftover: doc = getattr(symbol, '__doc__', '') else: doc = '' object_info = dict(docstring = doc) return object_info def _symbol_from_context(self, context): if not context: return None, context base_symbol_string = context[0] symbol = self.user_ns.get(base_symbol_string, None) if symbol is None: symbol = __builtin__.__dict__.get(base_symbol_string, None) if symbol is None: return None, context context = context[1:] for i, name in enumerate(context): new_symbol = getattr(symbol, name, None) if new_symbol is None: return symbol, context[i:] else: symbol = new_symbol return symbol, []
class Kernel(object): def __init__(self, session, reply_socket, pub_socket): self.session = session self.reply_socket = reply_socket self.pub_socket = pub_socket self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types self.handlers = {} for msg_type in ['execute_request', 'complete_request']: self.handlers[msg_type] = getattr(self, msg_type) def abort_queue(self): while True: try: ident = self.reply_socket.recv(zmq.NOBLOCK) except zmq.ZMQError as e: if e.errno == zmq.EAGAIN: break else: assert self.reply_socket.rcvmore(), "Unexpected missing message part." msg = self.reply_socket.recv_json() print("Aborting:", file=sys.__stdout__) print(Message(msg), file=sys.__stdout__) msg_type = msg['msg_type'] reply_type = msg_type.split('_')[0] + '_reply' reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg) print(Message(reply_msg),file=sys.__stdout__) self.reply_socket.send(ident,zmq.SNDMORE) self.reply_socket.send_json(reply_msg) # We need to wait a bit for requests to come in. This can probably # be set shorter for true asynchronous clients. time.sleep(0.1) def execute_request(self, ident, parent): try: code = parent[u'content'][u'code'] except: print("Got bad msg: ", file=sys.__stderr__) print(Message(parent), file=sys.__stderr__) return pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent) self.pub_socket.send_json(pyin_msg) try: # comp_code = self.compiler(code, '<zmq-kernel>') sys.displayhook.set_parent(parent) exec (code, self.user_ns) # FIXME except: result = u'error' etype, evalue, tb = sys.exc_info() tb = traceback.format_exception(etype, evalue, tb) exc_content = { u'status' : u'error', u'traceback' : tb, u'etype' : str(etype), u'evalue' : str(evalue) } exc_msg = self.session.msg(u'pyerr', exc_content, parent) self.pub_socket.send_json(exc_msg) reply_content = exc_content else: reply_content = {'status' : 'ok'} reply_msg = self.session.msg(u'execute_reply', reply_content, parent) print(Message(reply_msg),file=sys.__stdout__) self.reply_socket.send(ident, zmq.SNDMORE) self.reply_socket.send_json(reply_msg) if reply_msg['content']['status'] == u'error': self.abort_queue() def complete_request(self, ident, parent): matches = {'matches' : self.complete(parent), 'status' : 'ok'} completion_msg = self.session.send(self.reply_socket, 'complete_reply', matches, parent, ident) print (completion_msg, file=sys.__stdout__) def complete(self, msg): return self.completer.complete(msg.content.line, msg.content.text) def start(self): while True: ident = self.reply_socket.recv() assert self.reply_socket.rcvmore, "Unexpected missing message part." msg = self.reply_socket.recv_json() omsg = Message(msg) print(omsg, file=sys.__stdout__) handler = self.handlers.get(omsg.msg_type, None) if handler is None: print ("UNKNOWN MESSAGE TYPE:" + omsg, file=sys.__stderr__) else: handler(ident, omsg)
class Kernel(HasTraits): # Private interface # This is a dict of port number that the kernel is listening on. It is set # by record_ports and used by connect_request. _recorded_ports = None #--------------------------------------------------------------------------- # Kernel interface #--------------------------------------------------------------------------- session = Instance(Session) reply_socket = Instance('zmq.Socket') pub_socket = Instance('zmq.Socket') req_socket = Instance('zmq.Socket') def __init__(self, **kwargs): super(Kernel, self).__init__(**kwargs) self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types msg_types = [ 'execute_request', 'complete_request', 'object_info_request', 'shutdown_request' ] self.handlers = {} for msg_type in msg_types: self.handlers[msg_type] = getattr(self, msg_type) def start(self): """ Start the kernel main loop. """ while True: ident,msg = self.session.recv(self.reply_socket,0) assert ident is not None, "Missing message part." omsg = Message(msg) print>>sys.__stdout__ print>>sys.__stdout__, omsg handler = self.handlers.get(omsg.msg_type, None) if handler is None: print >> sys.__stderr__, "UNKNOWN MESSAGE TYPE:", omsg else: handler(ident, omsg) def record_ports(self, xrep_port, pub_port, req_port, hb_port): """Record the ports that this kernel is using. The creator of the Kernel instance must call this methods if they want the :meth:`connect_request` method to return the port numbers. """ self._recorded_ports = { 'xrep_port' : xrep_port, 'pub_port' : pub_port, 'req_port' : req_port, 'hb_port' : hb_port } #--------------------------------------------------------------------------- # Kernel request handlers #--------------------------------------------------------------------------- def execute_request(self, ident, parent): try: code = parent[u'content'][u'code'] except: print>>sys.__stderr__, "Got bad msg: " print>>sys.__stderr__, Message(parent) return pyin_msg = self.session.send(self.pub_socket, u'pyin',{u'code':code}, parent=parent) try: comp_code = self.compiler(code, '<zmq-kernel>') # Replace raw_input. Note that is not sufficient to replace # raw_input in the user namespace. raw_input = lambda prompt='': self._raw_input(prompt, ident, parent) __builtin__.raw_input = raw_input # Set the parent message of the display hook and out streams. sys.displayhook.set_parent(parent) sys.stdout.set_parent(parent) sys.stderr.set_parent(parent) exec comp_code in self.user_ns, self.user_ns except: etype, evalue, tb = sys.exc_info() tb = traceback.format_exception(etype, evalue, tb) exc_content = { u'status' : u'error', u'traceback' : tb, u'ename' : unicode(etype.__name__), u'evalue' : unicode(evalue) } exc_msg = self.session.send(self.pub_socket, u'pyerr', exc_content, parent) reply_content = exc_content else: reply_content = { 'status' : 'ok', 'payload' : {} } # Flush output before sending the reply. sys.stderr.flush() sys.stdout.flush() # Send the reply. reply_msg = self.session.send(self.reply_socket, u'execute_reply', reply_content, parent, ident=ident) print>>sys.__stdout__, Message(reply_msg) if reply_msg['content']['status'] == u'error': self._abort_queue() def complete_request(self, ident, parent): matches = {'matches' : self._complete(parent), 'status' : 'ok'} completion_msg = self.session.send(self.reply_socket, 'complete_reply', matches, parent, ident) print >> sys.__stdout__, completion_msg def object_info_request(self, ident, parent): context = parent['content']['oname'].split('.') object_info = self._object_info(context) msg = self.session.send(self.reply_socket, 'object_info_reply', object_info, parent, ident) print >> sys.__stdout__, msg def shutdown_request(self, ident, parent): content = dict(parent['content']) msg = self.session.send(self.reply_socket, 'shutdown_reply', content, parent, ident) msg = self.session.send(self.pub_socket, 'shutdown_reply', content, parent, ident) print >> sys.__stdout__, msg time.sleep(0.1) sys.exit(0) #--------------------------------------------------------------------------- # Protected interface #--------------------------------------------------------------------------- def _abort_queue(self): while True: ident,msg = self.session.recv(self.reply_socket, zmq.NOBLOCK) if msg is None: break else: assert ident is not None, "Unexpected missing message part." print>>sys.__stdout__, "Aborting:" print>>sys.__stdout__, Message(msg) msg_type = msg['msg_type'] reply_type = msg_type.split('_')[0] + '_reply' reply_msg = self.session.send(self.reply_socket, reply_type, {'status':'aborted'}, msg, ident=ident) print>>sys.__stdout__, Message(reply_msg) # We need to wait a bit for requests to come in. This can probably # be set shorter for true asynchronous clients. time.sleep(0.1) def _raw_input(self, prompt, ident, parent): # Flush output before making the request. sys.stderr.flush() sys.stdout.flush() # Send the input request. content = dict(prompt=prompt) msg = self.session.send(self.req_socket, u'input_request', content, parent) # Await a response. ident,reply = self.session.recv(self.req_socket, 0) try: value = reply['content']['value'] except: print>>sys.__stderr__, "Got bad raw_input reply: " print>>sys.__stderr__, Message(parent) value = '' return value def _complete(self, msg): return self.completer.complete(msg.content.line, msg.content.text) def _object_info(self, context): symbol, leftover = self._symbol_from_context(context) if symbol is not None and not leftover: doc = getattr(symbol, '__doc__', '') else: doc = '' object_info = dict(docstring = doc) return object_info def _symbol_from_context(self, context): if not context: return None, context base_symbol_string = context[0] symbol = self.user_ns.get(base_symbol_string, None) if symbol is None: symbol = __builtin__.__dict__.get(base_symbol_string, None) if symbol is None: return None, context context = context[1:] for i, name in enumerate(context): new_symbol = getattr(symbol, name, None) if new_symbol is None: return symbol, context[i:] else: symbol = new_symbol return symbol, []
class Kernel(object): def __init__(self, session, reply_socket, pub_socket): self.session = session self.reply_socket = reply_socket self.pub_socket = pub_socket self.user_ns = {} self.history = [] self.compiler = CommandCompiler() self.completer = KernelCompleter(self.user_ns) # Build dict of handlers for message types self.handlers = {} for msg_type in ["execute_request", "complete_request"]: self.handlers[msg_type] = getattr(self, msg_type) def abort_queue(self): while True: ident_msg = self.reply_socket.recv_json(zmq.NOBLOCK, ident=True) if ident_msg is None: break ident, msg = ident_msg print >>sys.__stdout__, "Aborting:" print >>sys.__stdout__, Message(msg) msg_type = msg["msg_type"] reply_type = msg_type.split("_")[0] + "_reply" reply_msg = self.session.msg(reply_type, {"status": "aborted"}, msg) print >>sys.__stdout__, Message(reply_msg) self.reply_socket.send_json(reply_msg, ident=ident) # We need to wait a bit for requests to come in. This can probably # be set shorter for true asynchronous clients. time.sleep(0.1) def execute_request(self, ident, parent): try: code = parent[u"content"][u"code"] except: print >>sys.__stderr__, "Got bad msg: " print >>sys.__stderr__, Message(parent) return pyin_msg = self.session.msg(u"pyin", {u"code": code}, parent=parent) self.pub_socket.send_json(pyin_msg) try: comp_code = self.compiler(code, "<zmq-kernel>") sys.displayhook.set_parent(parent) exec comp_code in self.user_ns, self.user_ns except: result = u"error" etype, evalue, tb = sys.exc_info() tb = traceback.format_exception(etype, evalue, tb) exc_content = {u"status": u"error", u"traceback": tb, u"etype": unicode(etype), u"evalue": unicode(evalue)} exc_msg = self.session.msg(u"pyerr", exc_content, parent) self.pub_socket.send_json(exc_msg) reply_content = exc_content else: reply_content = {"status": "ok"} reply_msg = self.session.msg(u"execute_reply", reply_content, parent) print >>sys.__stdout__, Message(reply_msg) self.reply_socket.send_json(reply_msg, ident=ident) if reply_msg["content"]["status"] == u"error": self.abort_queue() def complete_request(self, ident, parent): matches = {"matches": self.complete(parent), "status": "ok"} completion_msg = self.session.send(self.reply_socket, "complete_reply", matches, parent, ident) print >>sys.__stdout__, completion_msg def complete(self, msg): return self.completer.complete(msg.content.line, msg.content.text) def start(self): while True: ident, msg = self.reply_socket.recv_json(ident=True) omsg = Message(msg) print >>sys.__stdout__, omsg handler = self.handlers.get(omsg.msg_type, None) if handler is None: print >>sys.__stderr__, "UNKNOWN MESSAGE TYPE:", omsg else: handler(ident, omsg)