def runsource(self, source, filename='<input>', symbol='single'): if self._is_native: return InteractiveShell.runsource(self, source, filename, symbol) source=source.encode(self.stdin_encoding) if source[:1] in [' ', '\t']: source = 'if 1:\n%s' % source try: code = self.compile(source, filename, symbol) except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError): # Case 1 self.showsyntaxerror(filename) return None if code is None: # Case 2 return True # Case 3 #print "\n Code to translate:\n" + source + "\n" if source.startswith('_ip.'): # This is IPython Magick stuff. Run in native interpreter: return InteractiveShell.runsource(self, source, filename, symbol) # Translate try: jscode, imppy, impjs = self._js_int.translate(source) self.code_to_run = jscode except Exception, e: print_exc() return None
def runsource(self, source, filename="<input>", symbol="single"): """Compile and run some source in the interpreter. Modified version of code.py's runsource(), to handle threading issues. See the original for full docstring details.""" # If Ctrl-C was typed, we reset the flag and return right away if shellglobals.KBINT: shellglobals.KBINT = False return False if self._kill: # can't queue new code if we are being killed return True try: code = self.compile(source, filename, symbol) except (OverflowError, SyntaxError, ValueError): # Case 1 self.showsyntaxerror(filename) return False if code is None: # Case 2 return True # shortcut - if we are in worker thread, or the worker thread is not running, # execute directly (to allow recursion and prevent deadlock if code is run early # in IPython construction) if (not self.reactor_started or (self.worker_ident is None and not self.first_run) or self.worker_ident == thread.get_ident() or shellglobals.run_in_frontend(source)): InteractiveShell.runcode(self,code) return # Case 3 # Store code in queue, so the execution thread can handle it. self.first_run = False completed_ev, received_ev = threading.Event(), threading.Event() self.code_queue.put((code,completed_ev, received_ev)) reactor.callLater(0.0,self.runcode) received_ev.wait(5) if not received_ev.isSet(): # the mainloop is dead, start executing code directly print "Warning: Timeout for mainloop thread exceeded" print "switching to nonthreaded mode (until mainloop wakes up again)" self.worker_ident = None else: completed_ev.wait() return False
def runcode(self): """Execute a code object. Multithreaded wrapper around IPython's runcode().""" global CODE_RUN # Exceptions need to be raised differently depending on which thread is # active CODE_RUN = True # lock thread-protected stuff got_lock = self.thread_ready.acquire(False) if self._kill: print >>Term.cout, 'Closing threads...', Term.cout.flush() for tokill in self.on_kill: tokill() print >>Term.cout, 'Done.' # Install sigint handler. We do it every time to ensure that if user # code modifies it, we restore our own handling. try: signal(SIGINT,sigint_handler) except SystemError: # This happens under Windows, which seems to have all sorts # of problems with signal handling. Oh well... pass # Flush queue of pending code by calling the run methood of the parent # class with all items which may be in the queue. while 1: try: code_to_run = self.code_queue.get_nowait() except Queue.Empty: break if got_lock: self.thread_ready.notify() InteractiveShell.runcode(self,code_to_run) else: break # We're done with thread-protected variables if got_lock: self.thread_ready.release() # We're done... CODE_RUN = False # This MUST return true for gtk threading to work return True
def __init__(self, name, usage=None, rc=Struct(opts=None, args=None), user_ns=None, **kw): user_ns, b2 = self._matplotlib_config(name) InteractiveShell.__init__(self, name, usage, rc, user_ns, banner2=b2, **kw)
def prefilter_PQ(self,line,continuation): """Alternate prefilter for input of PhysicalQuantityInteractive objects. This assumes that the function PhysicalQuantityInteractive() has been imported.""" from re import match from IPython.iplib import InteractiveShell # This regexp is what does the real work unit_split = match(r'\s*(\w+)\s*=\s*(-?\d*\.?\d*[eE]?-?\d*)\s+([a-zA-Z].*)', line) # If special input was ecnountered, process it: if unit_split: var,val,units = unit_split.groups() if var and val and units: units = units.replace('^','**') # Now a valid line needs to be constructed for IPython to process: line = var +" = PhysicalQuantityInteractive(" + val + ", '" + \ units + "')" #print 'New line:',line # dbg # In the end, always call the default IPython _prefilter() function. Note # that self must be passed explicitly, b/c we're calling the unbound class # method (since this method will overwrite the instance prefilter()) return InteractiveShell._prefilter(self,line,continuation)
def prefilter_PQ(self, line, continuation): """Alternate prefilter for input of PhysicalQuantityInteractive objects. This assumes that the function PhysicalQuantityInteractive() has been imported.""" from re import match from IPython.iplib import InteractiveShell # This regexp is what does the real work unit_split = match( r'\s*(\w+)\s*=\s*(-?\d*\.?\d*[eE]?-?\d*)\s+([a-zA-Z].*)', line) # If special input was ecnountered, process it: if unit_split: var, val, units = unit_split.groups() if var and val and units: units = units.replace('^', '**') # Now a valid line needs to be constructed for IPython to process: line = var +" = PhysicalQuantityInteractive(" + val + ", '" + \ units + "')" #print 'New line:',line # dbg # In the end, always call the default IPython _prefilter() function. Note # that self must be passed explicitly, b/c we're calling the unbound class # method (since this method will overwrite the instance prefilter()) return InteractiveShell._prefilter(self, line, continuation)
def prefilter_paste(self, line, continuation): """Alternate prefilter for input of pasted code from an interpreter. """ from re import match from IPython.iplib import InteractiveShell if match(r'^>>> |^\.\.\. ', line): # In the end, always call the default IPython _prefilter() function. # Note that self must be passed explicitly, b/c we're calling the # unbound class method (since this method will overwrite the instance # prefilter()) return InteractiveShell._prefilter(self, line[4:], continuation) elif line.strip() == '...': return InteractiveShell._prefilter(self, '', continuation) else: return InteractiveShell._prefilter(self, line, continuation)
def runcode(self): """Execute a code object. Multithreaded wrapper around IPython's runcode().""" # lock thread-protected stuff got_lock = self.thread_ready.acquire(False) # Install sigint handler try: signal.signal(signal.SIGINT, sigint_handler) except SystemError: # This happens under Windows, which seems to have all sorts # of problems with signal handling. Oh well... pass if self._kill: print >> Term.cout, 'Closing threads...', Term.cout.flush() for tokill in self.on_kill: tokill() print >> Term.cout, 'Done.' # Flush queue of pending code by calling the run methood of the parent # class with all items which may be in the queue. while 1: try: code_to_run = self.code_queue.get_nowait() except Queue.Empty: break if got_lock: self.thread_ready.notify() InteractiveShell.runcode(self, code_to_run) else: break # We're done with thread-protected variables if got_lock: self.thread_ready.release() # This MUST return true for gtk threading to work return True
def __init__(self,name,usage=None,rc=Struct(opts=None,args=None), user_ns=None,user_global_ns=None,banner2='',**kw): """Similar to the normal InteractiveShell, but with threading control""" InteractiveShell.__init__(self,name,usage,rc,user_ns, user_global_ns,banner2) # A queue to hold the code to be executed. self.code_queue = Queue.Queue() # Stuff to do at closing time self._kill = None on_kill = kw.get('on_kill', []) # Check that all things to kill are callable: for t in on_kill: if not callable(t): raise TypeError,'on_kill must be a list of callables' self.on_kill = on_kill # thread identity of the "worker thread" (that may execute code directly) self.worker_ident = None
def __init__(self,name,usage=None,rc=Struct(opts=None,args=None), user_ns=None,user_global_ns=None,banner2='',**kw): """Similar to the normal InteractiveShell, but with threading control""" InteractiveShell.__init__(self,name,usage,rc,user_ns, user_global_ns,banner2) # Locking control variable. self.thread_ready = threading.Condition(threading.RLock()) # A queue to hold the code to be executed. A scalar variable is NOT # enough, because uses like macros cause reentrancy. self.code_queue = Queue.Queue() # Stuff to do at closing time self._kill = False on_kill = kw.get('on_kill') if on_kill is None: on_kill = [] # Check that all things to kill are callable: for t in on_kill: if not callable(t): raise TypeError,'on_kill must be a list of callables' self.on_kill = on_kill
def sage_prefilter(self, block, continuation): """ Sage's prefilter for input. Given a string block (usually a line), return the preparsed version of it. INPUT: - block -- string (usually a single line, but not always) - continuation -- whether or not this line is a continuation. """ try: block2 = '' first = True B = block.split('\n') for i in range(len(B)): L = B[i] M = do_prefilter_paste(L, continuation or (not first)) first = False # The L[:len(L)-len(L.lstrip())] business here preserves # the whitespace at the beginning of L. if block2 != '': block2 += '\n' lstrip = L.lstrip() if lstrip[:5] == 'sage:' or lstrip[:3] == '>>>' or i==0: block2 += M else: block2 += L[:len(L)-len(lstrip)] + M except None: print "WARNING: An error occurred in the Sage parser while" print "parsing the following block:" print block print "Please report this as a bug (include the output of typing '%hist')." block2 = block return InteractiveShell._prefilter(self, block2, continuation)
def sage_prefilter(self, block, continuation): """ Sage's prefilter for input. Given a string block (usually a line), return the preparsed version of it. INPUT: - block -- string (usually a single line, but not always) - continuation -- whether or not this line is a continuation. """ try: block2 = '' first = True B = block.split('\n') for i in range(len(B)): L = B[i] M = do_prefilter_paste(L, continuation or (not first)) first = False # The L[:len(L)-len(L.lstrip())] business here preserves # the whitespace at the beginning of L. if block2 != '': block2 += '\n' lstrip = L.lstrip() if lstrip[:5] == 'sage:' or lstrip[:3] == '>>>' or i == 0: block2 += M else: block2 += L[:len(L) - len(lstrip)] + M except None: print "WARNING: An error occurred in the Sage parser while" print "parsing the following block:" print block print "Please report this as a bug (include the output of typing '%hist')." block2 = block return InteractiveShell._prefilter(self, block2, continuation)
def __init__(self, name, **kw): self.parentclass = InteractiveShell AUTOInteractive.__init__(self, kw["user_ns"], None) InteractiveShell.__init__(self, name, **kw)
def handle_normal(self, line): if line.line.startswith('$'): self.callback.process_message(line.line[1:]) self.callback.check_response_queue() return '' return InteractiveShell.handle_normal(self, line)
def handle_normal(self, line): if line.line.startswith('$'): self.callback.process_message(line.line[1:]) self.callback.check_response_queue() return '' return InteractiveShell.handle_normal(self, line)
def runcode(self): """Execute a code object. Multithreaded wrapper around IPython's runcode().""" global CODE_RUN # we are in worker thread, stash out the id for runsource() self.worker_ident = thread.get_ident() if self._kill: print >>Term.cout, 'Closing threads...', Term.cout.flush() for tokill in self.on_kill: tokill() print >>Term.cout, 'Done.' # allow kill() to return self._kill.set() return True # Install sigint handler. We do it every time to ensure that if user # code modifies it, we restore our own handling. try: signal(SIGINT,sigint_handler) except SystemError: # This happens under Windows, which seems to have all sorts # of problems with signal handling. Oh well... pass # Flush queue of pending code by calling the run methood of the parent # class with all items which may be in the queue. code_to_run = None while 1: try: code_to_run, completed_ev, received_ev = self.code_queue.get_nowait() except Queue.Empty: break received_ev.set() # Exceptions need to be raised differently depending on which # thread is active. This convoluted try/except is only there to # protect against asynchronous exceptions, to ensure that a KBINT # at the wrong time doesn't deadlock everything. The global # CODE_TO_RUN is set to true/false as close as possible to the # runcode() call, so that the KBINT handler is correctly informed. try: try: CODE_RUN = True InteractiveShell.runcode(self,code_to_run) except KeyboardInterrupt: print "Keyboard interrupted in mainloop" while not self.code_queue.empty(): code, ev1,ev2 = self.code_queue.get_nowait() ev1.set() ev2.set() break finally: CODE_RUN = False # allow runsource() return from wait completed_ev.set() # This MUST return true for gtk threading to work return True
def __init__(self,name,usage=None,rc=Struct(opts=None,args=None), user_ns=None,user_global_ns=None,**kw): user_ns,user_global_ns,b2 = self._matplotlib_config(name,user_ns,user_global_ns) InteractiveShell.__init__(self,name,usage,rc,user_ns,user_global_ns, banner2=b2,**kw)
def runcode(self): """Execute a code object. Multithreaded wrapper around IPython's runcode().""" global CODE_RUN # lock thread-protected stuff got_lock = self.thread_ready.acquire() if self._kill: print >>Term.cout, 'Closing threads...', Term.cout.flush() for tokill in self.on_kill: tokill() print >>Term.cout, 'Done.' # Install sigint handler. We do it every time to ensure that if user # code modifies it, we restore our own handling. try: signal(SIGINT,sigint_handler) except SystemError: # This happens under Windows, which seems to have all sorts # of problems with signal handling. Oh well... pass # Flush queue of pending code by calling the run methood of the parent # class with all items which may be in the queue. code_to_run = None while 1: try: code_to_run = self.code_queue.get_nowait() except Queue.Empty: break # Exceptions need to be raised differently depending on which # thread is active. This convoluted try/except is only there to # protect against asynchronous exceptions, to ensure that a KBINT # at the wrong time doesn't deadlock everything. The global # CODE_TO_RUN is set to true/false as close as possible to the # runcode() call, so that the KBINT handler is correctly informed. try: try: CODE_RUN = True InteractiveShell.runcode(self,code_to_run) except KeyboardInterrupt: print "Keyboard interrupted in mainloop" while not self.code_queue.empty(): self.code_queue.get_nowait() break finally: if got_lock: CODE_RUN = False # We're done with thread-protected variables if code_to_run is not None: self.thread_ready.notify() self.thread_ready.release() # We're done... CODE_RUN = False # This MUST return true for gtk threading to work return True
def prefilter(self, line, continue_prompt): if not continue_prompt: line = self.processShorthand(line) line = InteractiveShell.prefilter(self, line, continue_prompt) return line
def runcode(self): """Execute a code object. Multithreaded wrapper around IPython's runcode().""" global CODE_RUN # lock thread-protected stuff got_lock = self.thread_ready.acquire() if self._kill: print >> Term.cout, 'Closing threads...', Term.cout.flush() for tokill in self.on_kill: tokill() print >> Term.cout, 'Done.' # Install sigint handler. We do it every time to ensure that if user # code modifies it, we restore our own handling. try: signal(SIGINT, sigint_handler) except SystemError: # This happens under Windows, which seems to have all sorts # of problems with signal handling. Oh well... pass # Flush queue of pending code by calling the run methood of the parent # class with all items which may be in the queue. code_to_run = None while 1: try: code_to_run = self.code_queue.get_nowait() except Queue.Empty: break # Exceptions need to be raised differently depending on which # thread is active. This convoluted try/except is only there to # protect against asynchronous exceptions, to ensure that a KBINT # at the wrong time doesn't deadlock everything. The global # CODE_TO_RUN is set to true/false as close as possible to the # runcode() call, so that the KBINT handler is correctly informed. try: try: CODE_RUN = True InteractiveShell.runcode(self, code_to_run) except KeyboardInterrupt: print "Keyboard interrupted in mainloop" while not self.code_queue.empty(): self.code_queue.get_nowait() break finally: if got_lock: CODE_RUN = False # We're done with thread-protected variables if code_to_run is not None: self.thread_ready.notify() self.thread_ready.release() # We're done... CODE_RUN = False # This MUST return true for gtk threading to work return True