def _start_kernel(): """starts the ipython kernel and returns the ipython app""" global _ipython_app, _kernel_running if _ipython_app and _kernel_running: return _ipython_app import IPython from ipykernel.kernelapp import IPKernelApp from zmq.eventloop import ioloop # patch IPKernelApp.start so that it doesn't block def _IPKernelApp_start(self): if self.poller is not None: self.poller.start() self.kernel.start() # set up a timer to periodically poll the zmq ioloop loop = ioloop.IOLoop.instance() def poll_ioloop(timer_id, time): global _kernel_running # if the kernel has been closed then run the event loop until it gets to the # stop event added by IPKernelApp.shutdown_request if self.kernel.shell.exit_now: _log.debug("IPython kernel stopping (%s)" % self.connection_file) timer.kill_timer(timer_id) loop.start() _kernel_running = False return # otherwise call the event loop but stop immediately if there are no pending events loop.add_timeout(0, lambda: loop.add_callback(loop.stop)) loop.start() global _kernel_running _kernel_running = True timer.set_timer(100, poll_ioloop) IPKernelApp.start = _IPKernelApp_start # IPython expects sys.__stdout__ to be set sys.__stdout__ = sys.stdout sys.__stderr__ = sys.stderr # call the API embed function, which will use the monkey-patched method above IPython.embed_kernel() _ipython_app = IPKernelApp.instance() # patch ipapp so anything else trying to get a terminal app (e.g. ipdb) # gets our IPKernalApp. from IPython.terminal.ipapp import TerminalIPythonApp TerminalIPythonApp.instance = lambda: _ipython_app __builtins__["get_ipython"] = lambda: _ipython_app.shell return _ipython_app
def run(self): namespace = { 'config': self.config, 'registry': self.config.registry, 'settings': self.config.registry.settings, } with mock.patch('signal.signal'): IPython.embed_kernel(local_ns=namespace)
def launch_debug_using_ipython(): # run this from a gdb session in order to create a # ipython session one could connect to for gdb_python symbol # symbol support import IPython if not ZMQ: IPython.embed() else: IPython.embed_kernel() """
def _start_kernel(): """starts the ipython kernel and returns the ipython app""" if sys._ipython_app and sys._ipython_kernel_running: return sys._ipython_app import IPython from ipykernel.kernelapp import IPKernelApp from zmq.eventloop import ioloop # patch IPKernelApp.start so that it doesn't block def _IPKernelApp_start(self): if self.poller is not None: self.poller.start() self.kernel.start() # set up a timer to periodically poll the zmq ioloop loop = ioloop.IOLoop.instance() def poll_ioloop(timer_id, time): # if the kernel has been closed then run the event loop until it gets to the # stop event added by IPKernelApp.shutdown_request if self.kernel.shell.exit_now: _log.debug("IPython kernel stopping (%s)" % self.connection_file) timer.kill_timer(timer_id) loop.start() sys._ipython_kernel_running = False return # otherwise call the event loop but stop immediately if there are no pending events loop.add_timeout(0, lambda: loop.add_callback(loop.stop)) loop.start() sys._ipython_kernel_running = True timer.set_timer(100, poll_ioloop) IPKernelApp.start = _IPKernelApp_start # IPython expects sys.__stdout__ to be set sys.__stdout__ = sys.stdout sys.__stderr__ = sys.stderr # call the API embed function, which will use the monkey-patched method above IPython.embed_kernel() sys._ipython_app = IPKernelApp.instance() # patch ipapp so anything else trying to get a terminal app (e.g. ipdb) # gets our IPKernalApp. from IPython.terminal.ipapp import TerminalIPythonApp TerminalIPythonApp.instance = lambda: sys._ipython_app __builtins__["get_ipython"] = lambda: sys._ipython_app.shell return sys._ipython_app
def thread_func(): try: # create a new event loop and schedule setup_ipython loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) loop.call_soon(setup_ipython) # this starts the event loop IPython.embed_kernel() except: event.set() raise
def ipython_embed_kernel(dut): """Start an interactive Python shell.""" yield Timer(0) import IPython print(textwrap.dedent(""" ############################################################################### Running IPython embed_kernel() You can now send this process into the background with "Ctrl-Z bg" and run jupyter console --existing or jupyter qtconsole --existing or jupyter console --existing kernel-{}.json ###############################################################################""".format(os.getpid()))) IPython.embed_kernel()
def _do_start_shell(config): # Import db handle, session and other useful stuff to the shell's scope db = None if isinstance(config, ServiceDaemon): db = config.get_main_store() # so that there is a db session handy in the shell session = db.Session() # these are just useful to have in a dev. shell import IPython, traceback, inspect, sys from pprint import pprint, pformat header = ( "Database handle is: db\n" "There's also an open session: session\n" "Imported packages: traceback, inspect, sys\n" "Imported functions: pprint(), pformat()" ) # start the kind of shell requested by user if config.shell: return IPython.embed(header=header) if config.ikernel: return IPython.embed_kernel()
def keyboard(banner=None): ''' Function that mimics the matlab keyboard command ''' # use exception trick to pick up the current frame try: raise None except: frame = sys.exc_info()[2].tb_frame.f_back print("# Ctrl-D Use quit() to exit :) Happy debugging!") # evaluate commands in current namespace namespace = frame.f_globals.copy() namespace.update(frame.f_locals) try: import IPython IPython.embed_kernel(module=None,local_ns=namespace) except SystemExit: return
def keyboard(banner=None): ''' Function that mimics the matlab keyboard command ''' # use exception trick to pick up the current frame try: raise None except: frame = sys.exc_info()[2].tb_frame.f_back print("# Ctrl-D Use quit() to exit :) Happy debugging!") # evaluate commands in current namespace namespace = frame.f_globals.copy() namespace.update(frame.f_locals) try: import IPython IPython.embed_kernel(module=None, local_ns=namespace) except SystemExit: return
def run(self): """ The function that runs when the "start" function is called. This is what python will do to start the worker thread and the IPython kernel in the background. Users can access the ipython console with ipython console --existing kernel-<pid>.json where pid is the pid above """ import IPython statusString = "Howdy! Starting %d %s" % (self.x, self.name) self.writeStatus(statusString) t1 = threading.Thread(target=self.runScript, args=()) t1.start() self.workerThread = t1 IPython.embed_kernel() return "done"
def test99_ipython(dut): "embed IPython shell for interactive exploration" expecteq_reset() dut.cocotb_testnum = 99 o = RocstarTester(dut) yield o.run_hello() skip = False try: text = open("skip_t99.txt").read().strip().upper() print "skip_t99.txt contents:", text if "Y" in text: skip = True except IOError: print "skip_t99.txt not found" pass if skip: print "skipping T99 IPython() invocation, due to 'skip_t99.txt'" else: import IPython IPython.embed_kernel() expecteq_fail_if_not_ok()
def ipython_kernel_thread(ip="127.0.0.1"): from unittest import mock import IPython from ipykernel.zmqshell import ZMQInteractiveShell from ipykernel import kernelapp kernelapp._ctrl_c_message = "Starting Ipython Kernel" from IPython.core.autocall import ZMQExitAutocall class KeepAlive(ZMQExitAutocall): def __call__(self, keep_alive=True): super().__call__(keep_alive) ZMQInteractiveShell.exiter = KeepAlive() if ip == "0.0.0.0": ip = "*" elif ip == "localhost": ip = "127.0.0.1" with mock.patch('signal.signal'): with mock.patch('ipykernel.kernelbase.signal'): IPython.embed_kernel()
def main(python_exe, throw_on_error=False): clean_up_environment_path() t = threading.Thread(target=runner, args=[python_exe]) t.start() print("Running IPython embeded kernel") try: IPython.embed_kernel( local_ns=sys._getframe(1).f_locals, connection_file=str(connection_file), ) except Exception as exp: print("Unable to embed IPython. Exception occured:") print(exp) if throw_on_error: raise exp finally: if sys.stdout: sys.stdout.flush() t.join()
def do_this(plpy,**kwargs): global DEBUG,EMBED _defaults = {'iter_round':'first','DEBUG':False,'EMBED':False} _defaults.update(kwargs) for k,v in _defaults.iteritems(): if type(v)==str: exec('%s = """%s"""' % (k,v),globals()) else: exec('%s = %s' % (k,v),globals()) if DEBUG and type(DEBUG)==bool: DEBUG = 1 elif DEBUG and type(DEBUG)==int: DEBUG = 3 if DEBUG>=3 else DEBUG else: print 'unknown DEBUG parameter input' import os,re # import sys # sys.path.append('/usr/local/lib/python2.7/dist-packages/pycharm-debug.egg') # import pydevd # pydevd.settrace('10.0.1.53', port=50003, stdoutToServer=True, stderrToServer=True) # import IPython as I # I.embed_kernel() # import ipdb # ipdb.set_trace() if DEBUG>=1: os.system("echo '\\n\\n'`date --utc` >> /tmp/tmpfile") def log_to_file(msg): # plpy.log(msg) _file = '/tmp/tmpfile' with open(_file,'a') as f: f.write(str(msg) + '\n') def run_query(**kwargs): qry_a = """ SELECT UPPER(CONCAT_WS('_', %(concat)s )) a_str, ts_uid a_idx, ts_div_line FROM str_matching %(cond)s ORDER BY uid """ qry_b = """ SELECT DISTINCT UPPER(CONCAT_WS('_', %(concat)s )) b_str, uid b_idx FROM sub_stations %(cond)s ORDER BY uid """ _updated = False ra = plpy.execute( qry_a % {'concat':a_concat,'cond':a_str_idx_cond} ) if not ra: if DEBUG>=1: log_to_file('--- ending run_iter early ---') return _updated,0 # else... for r in ra: # TODO: when string comparisons begin to use only parts of strings, other data should be added # TODO: add conditional for iterating parts of a_str if a_updates.count(r["a_idx"]) \ and exclude_new_matches_from_subsequent_searches: pass else: if DEBUG>=1: log_to_file('----------ts_uid: %(a_idx)s' % r) for k,v in r.iteritems(): # FIRST # check if even number of single-quotes if str(v).count("'") % 2==0: pass # HACK -- replace right-most single-quote with 2 single-quotes else: pt = v.rfind("'") r[k] = v[:pt] + "'" + v[pt:] # SECOND # since r is passed through 2 layers of substitution: # (1) first when creating qry variable, and # (2) within function z_string_matching called by qry # then: # "'" --> "''''" if str(v).count("'"): r[k] = re.sub(r"'{1}","''''",v) _t = { 'f_qry_a':qry_a.replace("'","''") % {'concat':a_concat.replace("'","''").replace('\\','\\\\'), 'cond':a_str_cond.replace("'","''") } % r, 'f_qry_b':qry_b.replace("'","''") % {'concat':b_concat.replace("'","''").replace('\\','\\\\'), 'cond':b_str_cond.replace("'","''") } % r, 'res_cond':result_cond 'params_as_json' : params_as_json } qry = """ WITH qry AS ( SELECT (z).* FROM z_string_matching( E'%(f_qry_a)s'::text, E'%(f_qry_b)s'::text, E'%(params_as_json)s' ) z ) ,str_matching_form as ( select _str.ts_uid,_str.ts_div_line,_str.ts_station ,z.a_str ts_str, z.jaro_score::DOUBLE PRECISION, z.b_str match_str ,_stat.station_name sub_station, div_line sub_div_line, z.b_idx::INTEGER sub_idx ,z.other_matches FROM qry z INNER JOIN str_matching _str ON _str.ts_uid = z.a_idx::INTEGER INNER JOIN sub_stations _stat ON _stat.uid = z.b_idx::INTEGER %(res_cond)s ) ,upd AS ( UPDATE str_matching _str SET ts_str=_res.ts_str, jaro_score=_res.jaro_score, match_str=_res.match_str, sub_station=_res.sub_station, sub_div_line=_res.sub_div_line, sub_idx=_res.sub_idx FROM str_matching_form _res WHERE _res.ts_uid=_str.ts_uid AND _res.jaro_score > _str.jaro_score RETURNING uid ) SELECT * FROM str_matching_form """ % _t q_res = plpy.execute(qry) if q_res: if DEBUG>=1: log_to_file("found") _updated = True if DEBUG>=1: log_to_file(q_res) if DEBUG>=3: log_to_file(qry) # TODO: remove if EMBED: import ipdb ipdb.set_trace() # break return _updated,r def mark_unmatched(r): qry = """ WITH upd AS ( SELECT uid FROM str_matching WHERE ts_uid=%(a_idx)s AND jaro_score=0 ) UPDATE str_matching s SET jaro_score=-1 FROM upd u WHERE s.uid=u.uid; """ % r if DEBUG>=2: log_to_file('marking') log_to_file(r) plpy.execute(qry) def run_iter(): # ITERATIONS: # all permutations between a_str, b_str, and: # station name, # first half of station name split by "-", # second half of station name split by "-", # TODO: fix below a_str_concat=['%s ts_station %s' % (a_prefix,a_suffix)] a_str_concat_partial=[ "%s REGEXP_REPLACE(ts_station,E'^([^-/]*)(-|/)(.*)$',E'\\1',E'g') %s" % (a_prefix,a_suffix), "%s REGEXP_REPLACE(ts_station,E'^([^-/]*)(-|/)(.*)$',E'\\3',E'g') %s" % (a_prefix,a_suffix), ] if iter_a_str_parts: a_str_concat.extend(a_str_concat_partial) b_str_concat=['%s station_name %s' % (b_prefix,b_suffix)] b_str_concat_partial=[ "%s REGEXP_REPLACE(station_name,E'^([^-/]*)(-|/)(.*)$',E'\\1',E'g') %s" % (b_prefix,b_suffix), "%s REGEXP_REPLACE(station_name,E'^([^-/]*)(-|/)(.*)$',E'\\3',E'g') %s" % (b_prefix,b_suffix), ] if iter_b_str_parts: b_str_concat.extend(b_str_concat_partial) # Note re: "\" # each substitution interprets "\\" as "\" # final log print of query before execution needs "\\\\" to read "\\" global a_concat,b_concat,a_updates a_updates,updated,end = [],False,False for i in range(len(a_str_concat)): a_concat = a_str_concat[i].replace('\\','\\\\') for j in range(len(b_str_concat)): b_concat = b_str_concat[j].replace('\\','\\\\') if DEBUG>=2: log_to_file('Iterating str_concat (i,j) = (%s,%s)'%(i,j)) res,r = run_query(a_concat=a_concat,b_concat=b_concat) if res: updated = True a_updates.append(r['a_idx']) elif not r: end = True break elif (not updated and i==len(a_str_concat)-1 and j==len(b_str_concat)-1): a_updates.append(r['a_idx']) if DEBUG>=2: log_to_file('MARKING UNMATCHED') mark_unmatched(r) if end: break if end: break a=0 # First, all iterations are run where: # (1) "a" queries limited to case where jaro_score = 0, # (2) a_str and b_str are limited to station names # (3) only b_str compared have same div_line as a_str ("strict_div_line"), and # (4) only results with jaro_scores 0.95 and above are applied to str_matching # Second, similar to first except: # no-emphasis on "division", and # no limit on what results update str_matchingn # Third, all iteration run again, except where: # (1) no strict matching for div_line # (2) a_str and b_str now includes div_line # (3) "a" queries limited to where jaro_score < 0.95 # (4) all results with higher scores replace in str_matching (default: 0.0) # TODO: Z.JARO_SCORE==SAME AND NEW RESULT HAS NUMBER global params_as_json global exclude_new_matches_from_subsequent_searches global iter_a_str_parts,iter_b_str_parts global iter_a_str_perms,iter_b_str_perms if iter_round=='first': a_prefix,a_suffix = '','' b_prefix,b_suffix = '','' iter_a_str_parts = False iter_b_str_parts = False iter_a_str_perms = False iter_b_str_perms = False a_str_idx_cond = ' WHERE jaro_score=0' # this relates to first_iter matching single 'a' results a_str_cond =' WHERE ts_uid=%(a_idx)s AND jaro_score>=0' exclude_new_matches_from_subsequent_searches = True b_str_cond =" WHERE div_line='%(ts_div_line)s'" result_cond = 'WHERE NOT z.jaro_score::DOUBLE PRECISION < 0.95' run_iter() elif iter_round=='second': res = plpy.execute("""WITH old AS (SELECT uid FROM str_matching WHERE jaro_score=-1) UPDATE str_matching s SET jaro_score=0 FROM old o WHERE o.uid = s.uid;""") a_prefix,a_suffix = '','' b_prefix,b_suffix = '','' iter_a_str_parts = False iter_b_str_parts = False iter_a_str_perms = False iter_b_str_perms = False a_str_idx_cond = ' WHERE jaro_score>=0 AND jaro_score<0.95' exclude_new_matches_from_subsequent_searches = False #TODO: remove a_str_idx_cond = ' WHERE jaro_score>=0 AND jaro_score<0.95 and ts_uid=47' a_str_cond = ' WHERE ts_uid=%(a_idx)s AND jaro_score>=0' # jaro_score --> -1 when no matches in round 2 _t = {'name' : "station_name ~* '%(a_str)s'", 'div' : "split_part(div_line,'_',1)=SPLIT_PART('%(ts_div_line)s','_',1)", 'line' : "SPLIT_PART(div_line,'_',2)~*SPLIT_PART('%(ts_div_line)s','_',2)", } b_str_conditions = [ # ' AND '.join([_t['name'],_t['div'],_t['line']]), # ' AND '.join([_t['name'],_t['div']]), # ' AND '.join([_t['name'],_t['line']]), # order important for jaro-winkler score # ' AND '.join([_t['div'],_t['line'],_t['name']]), # ' AND '.join([_t['line'],_t['name']]), # ' AND '.join([_t['div'],_t['name']]), '' # ' AND '.join([_t['div'],_t['line']]), # _t['line'], ] result_cond = ' WHERE z.jaro_score::DOUBLE PRECISION >= _str.jaro_score' for it in b_str_conditions: if DEBUG>=1: log_to_file('cond #: %s' % b_str_conditions.index(it)) if it: b_str_cond = ' WHERE ' + it else: b_str_cond = '' if EMBED: import IPython as I I.embed_kernel() run_iter() # result_cond = ' WHERE z.jaro_score::DOUBLE PRECISION > _str.jaro_score::DOUBLE PRECISION' # # for it in b_str_conditions: # log_to_file('cond #: %s' % b_str_conditions.index(it)) # b_str_cond = ' WHERE ' + it # if EMBED: # import IPython as I # I.embed_kernel() # run_iter() elif iter_round=='third': a_prefix,a_suffix = '',',ts_div_line' b_prefix,b_suffix = '',',div_line' a_str_idx_cond = ' WHERE jaro_score >= 0 AND jaro_score < 0.95' a_str_cond = ' WHERE ts_uid=%(a_idx)s AND jaro_score>=0' b_str_cond = " " result_cond = ' ' run_iter() if DEBUG>=1: os.system("echo `date --utc`'\\nDONE' >> /tmp/tmpfile")
import IPython IPython.embed_kernel(connection_file='kernel-emacs.json')
import IPython a = 10 IPython.embed_kernel() # then run: ipython console --existing kernel-XXXXX.json
def _block_on_repl(sig, frame): IPython.embed_kernel()
def _start_kernel(): """starts the ipython kernel and returns the ipython app""" if sys._ipython_app and sys._ipython_kernel_running: return sys._ipython_app import IPython from ipykernel.kernelapp import IPKernelApp from zmq.eventloop import ioloop # patch IPKernelApp.start so that it doesn't block def _IPKernelApp_start(self): if self.poller is not None: self.poller.start() self.kernel.start() # set up a timer to periodically poll the zmq ioloop loop = ioloop.IOLoop.instance() def poll_ioloop(timer_id, time): # if the kernel has been closed then run the event loop until it gets to the # stop event added by IPKernelApp.shutdown_request if self.kernel.shell.exit_now: _log.debug("IPython kernel stopping (%s)" % self.connection_file) timer.kill_timer(timer_id) loop.start() sys._ipython_kernel_running = False return # otherwise call the event loop but stop immediately if there are no pending events loop.add_timeout(0, lambda: loop.add_callback(loop.stop)) loop.start() sys._ipython_kernel_running = True timer.set_timer(100, poll_ioloop) IPKernelApp.start = _IPKernelApp_start # IPython expects sys.__stdout__ to be set sys.__stdout__ = sys.stdout sys.__stderr__ = sys.stderr # call the API embed function, which will use the monkey-patched method above IPython.embed_kernel() ipy = IPKernelApp.instance() # Keep a reference to the kernel even if this module is reloaded sys._ipython_app = ipy # patch user_global_ns so that it always references the user_ns dict setattr(ipy.shell.__class__, 'user_global_ns', property(lambda self: self.user_ns)) # patch ipapp so anything else trying to get a terminal app (e.g. ipdb) gets our IPKernalApp. from IPython.terminal.ipapp import TerminalIPythonApp TerminalIPythonApp.instance = lambda: ipy __builtins__["get_ipython"] = lambda: ipy.shell.__class__ # Use the inline matplotlib backend mpl = ipy.shell.find_magic("matplotlib") if mpl: mpl("inline") return ipy
def run(self): IPython.embed_kernel(module=daemon_tools, local_ns=daemon_tools.__dict__)
def run(self): try: IPython.embed_kernel(module=daemon_tools, local_ns=daemon_tools.__dict__) except: print("Unable to Start IPython kernel")
def show_or_exit(key): global off_screen global last_key global show global do_cmd # clear out old messages txt = '' # set the progress bar visibility, so info can set it just once pbh = K.pbh pbh.send(show) displayed_columns = K.displayed_columns cols = K.cols if isinstance(K.loop.widget, urwid.Overlay): K.loop.widget = K.loop.widget[0] # pop off the overlay if key != '.': last_key = key else: key = last_key if key in k_quit: raise urwid.ExitMainLoop() elif key in k_help: display_help() return True elif key in k_version: #display_version() display_help() return True elif key in k_prev_one: #off_screen.append(cols.contents.pop()) if off_screen: new_first = off_screen.pop() cols.contents.insert(0, new_first) cols.focus_position=0 elif key in k_prev: #off_screen.append(cols.contents.pop()) for x in range(displayed_columns): if off_screen: new_first = off_screen.pop() cols.contents.insert(0, new_first) cols.focus_position=0 elif key in k_top: # take it from the top cols.contents = off_screen + cols.contents off_screen = [] cols.focus_position=0 elif key in k_end: # this is the end, my friends, the end, the end. off_screen.extend(cols.contents) # backfill here properly - fill the hole screen (add back as many columns as can be displayed) cols.contents = [off_screen.pop() for x in range(displayed_columns) ][::-1] txt = '(END)' elif key in k_next_one: if len(cols.contents) > displayed_columns: off_screen.append(cols.contents.pop(0)) if len(cols.contents) == displayed_columns: txt = '(END)' elif key in k_next: for x in range(displayed_columns): if len(cols.contents) > displayed_columns: off_screen.append(cols.contents.pop(0)) if len(cols.contents) == displayed_columns: txt = '(END)' elif key in k_search: #cmd_line_text.focus() K.all.set_focus('footer') txt = '/' #do_cmd = lambda x: rehighlight(K.txts, x) do_cmd = get_search_or_search_next(k_next_search) K.cmd_line_text.set_edit_text('') elif key in k_search_bw: #cmd_line_text.focus() K.all.set_focus('footer') txt = '?' do_cmd = get_search_or_search_next(k_prev_search) K.cmd_line_text.set_edit_text('') elif key in k_command: #txt = ':' c(':') K.all.set_focus('footer') #cmd_line_text.set_edit_text('') do_cmd = colon return elif key in k_submit: if K.all.get_focus() == 'footer': input = K.cmd_line_text.get_edit_text() K.cmd_line_text.set_edit_text(''); K.all.set_focus('body') if do_cmd(input): # colon_dispatch methods return true if the rest of the method # should be skipped (because colon_dispatch method also calls # it, for example) return elif key in k_escape: if K.all.get_focus() == 'footer': txt = '' K.all.set_focus('body') elif key in k_next_search: # focus pane with a next result only if found # pseudocode: # if current pane contains a matched element: # go to the next pane that contains an element (or highlight the # next match?) # c("next search functionality not implemented yet") return True pass elif key in k_prev_search: # focus last result only if found c("prev search functionality not implemented yet") return True pass elif key in k_diff: rehighlight(K.txts, '', search=search_diff) elif key in k_diff_off: rehighlight(K.txts, '', search=search_noop) elif key in k_info: txt = K.fname if K.kanten_options['filetype']: txt += " (ft=" + K.kanten_options['filetype'] + ")" txt += " (%d / %d)" % (K.total_cols-len(cols.contents) + displayed_columns , K.total_cols) if len(cols.contents) == displayed_columns: txt += ' (END)' pbh.send(True) elif key in k_toggle_pbar: show = not show pbh.send(show) elif key in k_editor: editor = K.kanten_options['editor'] os.spawnvp(os.P_WAIT, editor, [editor, K.fname]) elif isinstance(key, tuple) and key[0] == "mouse press": if key[1] in m_scroll_up: show_or_exit(k_next[0]) elif key[1] in m_scroll_down: show_or_exit(k_prev[0]) elif key[1] in m_click: column = xpos_to_col(key[-2]) txt = "click in column %d, line %d" % (column, key[-1]) elif key[1] in m_paste: txt = "we would paste X11 clipboard contents here" else: txt = "unhandled key " + str(key) elif key in k_debug: if DEBUG: IPython.embed_kernel() elif isinstance(key, tuple): txt = "unhandled key " + str(key) else: txt = "unhandled key " + str(key) if DEBUG: txt = "key = " + str(key) K.cmd_line_text.set_caption(txt) #cmd_line_text.set_edit_text(txt) K.pbar.set_completion(len(off_screen)+displayed_columns) K.cmd_line_text.set_edit_text('')