def runcode(self, _code):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
org_stdout = sys.stdout
sys.stdout = PseudoFile(self)
try:
exec _code in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
sys.stdout = org_stdout
def runcode(self, _code):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
org_stdout = sys.stdout
sys.stdout = PseudoFile(self)
try:
exec _code in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
sys.stdout = org_stdout
def runcode(self, the_code, source, filename='<input>'):
# code taken from InteractiveInterpreter.runsource in code.py
try:
tree = ast.parse(source)
try:
expr = ast.parse(source, mode='eval')
except:
expr = None
#todo get this to work for multiple expr's, not just 1:
if expr and len(tree.body) == 1:
# _ = expr_value
tree.body[0] = ast_wrap_in_assn('_', tree.body[0])
# print _
underscore = _ast.Name(id="_", ctx=_ast.Load())
print_node = ast_print_node([_ast.Str(s=' ' * 50), underscore])
tree.body.append(print_node)
# play_whatever
#todo doesn't work for generators yet
play_whatever_node = ast_call_node('music.play_whatever',
'_',
show_notes=SHOW_NOTES)
tree.body.append(play_whatever_node)
#print ast.dump(tree)
code_obj = compile(tree, '<input>', 'exec')
exec code_obj in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, codeobj):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
try:
old_display_hook, sys.displayhook = sys.displayhook, self._displayhook
old_stdout, sys.stdout = sys.stdout, self.outputbuffer
old_stdin, sys.stdin = sys.stdin, None
exec codeobj in self.globals, self.locals #pylint: disable-msg=W0122
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(self.outputbuffer, 0):
self.outputbuffer.write("\n")
finally:
sys.displayhook = old_display_hook
sys.stdout = old_stdout
sys.stdin = old_stdin
def runcode(self, the_code, source, filename='<input>'):
# code taken from InteractiveInterpreter.runsource in code.py
try:
tree = ast.parse(source)
try:
expr = ast.parse(source, mode='eval')
except:
expr = None
#todo get this to work for multiple expr's, not just 1:
if expr and len(tree.body) == 1:
# _ = expr_value
tree.body[0] = ast_wrap_in_assn('_', tree.body[0])
# print _
underscore = _ast.Name(id="_", ctx=_ast.Load())
print_node = ast_print_node([_ast.Str(s=' '*50), underscore])
tree.body.append(print_node)
# play_whatever
#todo doesn't work for generators yet
play_whatever_node = ast_call_node('music.play_whatever', '_', show_notes=SHOW_NOTES)
tree.body.append(play_whatever_node)
#print ast.dump(tree)
code_obj = compile(tree, '<input>', 'exec')
exec code_obj in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, code):
try:
exec(code, self.locals)
except SystemExit:
raise
except:
self.showtraceback()
else:
if softspace is not None and softspace(sys.stdout, 0):
print
def runcode(self, co):
try:
self.connection.eval(co, locals=self.locals)
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, codearg):
try:
exec codearg in self.globals, self.locals #modified to add support for globals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, code):
try:
exec(code, self.locals)
except SystemExit:
raise
except:
self.showtraceback()
else:
if softspace is not None and softspace(sys.stdout, 0):
print
def runcode(self, co):
try:
self.connection.eval(co, locals=self.locals)
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, code):
try:
exec code in self.locals
except SystemExit:
raise
except Exception:
print traceback.format_exc()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code):
try:
exec code in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code):
try:
exec code in self.locals
except SystemExit:
raise
except Exception:
print traceback.format_exc()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code_):
# This comes straight from code.py
try:
#exec code in self.locals
exec code_ in self.globals, self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print()
def runcode(self, code_):
# This comes straight from code.py
try:
#exec code in self.locals
exec code_ in self.globals, self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, c):
try:
exec(c, self.locals)
except KeyboardInterrupt:
self.showtraceback()
except SystemExit:
# maybe a self.showtraceback() would be good?
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print()
def runcode(self, c):
try:
exec(c, self.locals)
except KeyboardInterrupt:
self.showtraceback()
except SystemExit:
# maybe a self.showtraceback() would be good?
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print()
def runcode(self, code):
try:
InterpreterKeyController.setEnabled_(True);
exec code in self.locals
except SystemExit:
InterpreterKeyController.setEnabled_(False);
raise
except:
InterpreterKeyController.setEnabled_(False);
self.showtraceback()
else:
InterpreterKeyController.setEnabled_(False);
if softspace(sys.stdout, 0):
print
def runcode(self, _code):
org_stdout = sys.stdout
sys.stdout = PseudoFile(self)
try:
exec _code in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
sys.stdout = org_stdout
def runcode(self, co):
try:
exec co in self.locals # pylint: disable=exec-used
except SystemExit:
self.inferior.Cancel()
raise
except KeyboardInterrupt:
raise
except inferior.PositionError as err:
print 'PositionError: %s' % err.message
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, c):
stdout = sys.stdout
sys.stdout = StringIO()
try:
exec c in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
r = sys.stdout.getvalue()
sys.stdout = stdout
self.write(r)
def runcode(self, co):
try:
exec co in self.locals # pylint: disable=exec-used
except SystemExit:
self.inferior.Cancel()
raise
except KeyboardInterrupt:
raise
except inferior.PositionError as err:
print "PositionError: %s" % err.message
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
def runcode(self, c):
stdout = sys.stdout
sys.stdout = StringIO()
try:
exec c in self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print
r = sys.stdout.getvalue()
sys.stdout = stdout
self.write(r)
def runcode(self, code):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
self._last_type = self._last_traceback = self._last_value = None
try:
exec code in self.locals
except:
# Since the exception info may need to travel across the wire, we
# pack it in right away. Note that we are abusing the exception
# value to store a fully formatted traceback, since the stack can
# not be serialized for network transmission.
et, ev, tb = sys.exc_info()
self._last_type = et
self._last_traceback = tb
tbinfo = self.tbHandler.text(et, ev, tb)
# Construct a meaningful traceback message for shipping over the
# wire.
buf = pprint.pformat(self.buffer)
try:
ename = et.__name__
except:
ename = et
msg = """\
%(ev)s
***************************************************************************
An exception occurred in an IPython engine while executing user code.
Current execution buffer (lines being run):
%(buf)s
A full traceback from the actual engine:
%(tbinfo)s
***************************************************************************
""" % locals()
self._last_value = msg
else:
if softspace(sys.stdout, 0):
print
def my_runcode(self, codeobj, source=None):
"""Mostly copied from code.InteractiveInterpreter, but added better
exception handling.
"""
session.scriptEvent('start', ('', source))
try:
exec_(codeobj, self.globals)
except NicosInteractiveStop:
pass
except KeyboardInterrupt:
# "immediate stop" chosen
session.immediateStop()
except Exception:
session.scriptEvent('exception', sys.exc_info())
if hasattr(code, 'softspace') and code.softspace(sys.stdout, 0):
print()
session.scriptEvent('finish', None)
def runcode_global(self, code):
""" Execute a code object in *only* the global context.
This method makes it possible to run "from xyz import \*" from
the command line. This isn't allowed if a non-dictionary local
namespace is used. Note that this method will not work if
the global dictionary
"""
try:
# Use only the globals namespace for execution.
exec code in self.globals
except SystemExit:
raise
except:
self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runcode_global(self, code):
""" Execute a code object in *only* the global context.
This method makes it possible to run "from xyz import \*" from
the command line. This isn't allowed if a non-dictionary local
namespace is used. Note that this method will not work if
the global dictionary
"""
try:
# Use only the globals namespace for execution.
exec code in self.globals
except SystemExit:
raise
except:
self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code):
"""Execute a code object.
Our extra-special verson of the runcode method. We use this when we
want py_shell_mixin._run_source() to generate real exceptions, and
not just output to stdout, for example when CodeRunner is executed
as part of a network. This runcode() is explicitly called by our local
runsource() method.
"""
try:
exec code in self.locals
except SystemExit:
raise
except:
raise
#self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code):
"""Execute a code object.
Our extra-special verson of the runcode method. We use this when we
want py_shell_mixin._run_source() to generate real exceptions, and
not just output to stdout, for example when CodeRunner is executed
as part of a network. This runcode() is explicitly called by our local
runsource() method.
"""
try:
exec code in self.locals
except SystemExit:
raise
except:
raise
#self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code):
""" Execute a code object in the given context.
This is overloaded from the base class so that we can
execute in both a global and a local context. We are using a
"dictionary-like" object for the locals. The exec statement
requires that the globals is a dict.
The rest of the code is cut/pasted from the base class.
"""
try:
# Use both a global and local context. This is the only change.
exec code in self.globals, self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code):
""" Execute a code object in the given context.
This is overloaded from the base class so that we can
execute in both a global and a local context. We are using a
"dictionary-like" object for the locals. The exec statement
requires that the globals is a dict.
The rest of the code is cut/pasted from the base class.
"""
try:
# Use both a global and local context. This is the only change.
exec code in self.globals, self.locals
except SystemExit:
raise
except:
self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runsource(self, source, filename="<input>", symbol="single"):
if source.strip() == "":
return False
try:
code = self.compile(source, filename, symbol)
except (OverflowError, SyntaxError, ValueError):
self.showsyntaxerror(filename)
return False
if code is None:
return True
# See if it's a valid expression
try:
self.compile(source, filename, "eval")
is_expression = True
except:
is_expression = False
try:
@stm.atomically
def result():
if is_expression:
return eval(source, globals(), self.locals)
else:
exec code in globals(), self.locals
return None
if result is not None:
print result
except SystemExit:
raise
except:
self.showtraceback()
else:
if _code_module.softspace(sys.stdout, 0):
print
return False
def runcode(self, code):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
try:
exec code in self._l_dict, self._g_dict
except SystemExit:
raise
except:
self.showtraceback()
else:
from code import softspace
import sys
if softspace(sys.stdout, 0):
print
def runcode(self, code):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
try:
exec code in self._l_dict, self._g_dict
except SystemExit:
raise
except:
self.showtraceback()
else:
from code import softspace
import sys
if softspace(sys.stdout, 0):
print
def runcode(self, code):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
Copied directly from code.InteractiveInterpreter, except for
EmbeddedConsoleExit exceptions.
"""
try:
exec code in self.locals
except (SystemExit, EmbeddedConsoleExit):
raise
except:
self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def runcode(self, code):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
try:
exec code in self.locals
except SystemExit:
raise
except:
#raise # This was hanging the tests. Need to rethink how we do this.
self.showtraceback()
self._tracebackTuple = sys.exc_info()
else:
if softspace(sys.stdout, 0):
print
def runcode(obj, code_obj):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
try:
exec(code_obj, obj.locals, obj.globals)
except SystemExit:
raise
except:
obj.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print()
pass
pass
return
def runcode(obj, code_obj):
"""Execute a code object.
When an exception occurs, self.showtraceback() is called to
display a traceback. All exceptions are caught except
SystemExit, which is reraised.
A note about KeyboardInterrupt: this exception may occur
elsewhere in this code, and may not always be caught. The
caller should be prepared to deal with it.
"""
try:
exec(code_obj, obj.locals, obj.globals)
except SystemExit:
raise
except:
obj.showtraceback()
else:
if code.softspace(sys.stdout, 0):
print()
pass
pass
return
cloud.join(job)
result = cloud.result(job)
self.locals.update(result)
info = cloud.info(job, ['stderr', 'stdout'])[job]
sys.stdout.write(info['stdout'])
sys.stderr.write(info['stderr'])
except SystemExit:
raise
except KeyboardInterrupt:
raise OperationAborted('Interrupted')
except cloud.CloudException, e:
self.showcloudtraceback(e)
except:
self.showtraceback()
else:
if softspace(sys.stdout, 0):
print
def showcloudtraceback(self, exception):
""" Show a traceback from a cloud exception
"""
tb = exception.parameter.split('\n')
# drop everything up to the execution line
while True:
next = tb.pop(0)
if 'exec code' in next:
break
tb.insert(0, "Traceback (most recent call last):")
tb = '\n'.join(tb)
exception occurs, self.showtraceback() is called to display a
traceback.
"""
try:
res = self.interpreter.run(ast)
if res not in (None, w_Undefined):
try:
print res.GetValue().ToString(self.interpreter.w_Global)
except ThrowException, exc:
print exc.exception.ToString(self.interpreter.w_Global)
except SystemExit:
raise
except ThrowException, exc:
self.showtraceback(exc)
else:
if code.softspace(sys.stdout, 0):
print
def runsource(self, source, filename="<input>"):
"""Parse and run source in the interpreter.
One of these cases can happen:
1) The input is incorrect. Prints a nice syntax error message.
2) The input in incomplete. More input is required. Returns None.
3) The input is complete. Executes the source code.
"""
try:
ast = load_source(source, filename)
except ParseError, exc:
if exc.source_pos.i == len(source):
# Case 2
def _run_code(self, code):
"""
Run the code object in the engine - THIS SHOULD NOT BE CALLED DIRECTLY
USE run_code() which is thread safe.
"""
#check for a console
if self.console is None:
log.warning('No managing console!')
raise Exception('No managing console!')
#set busy flag and send busy messages
self.busy = True
#published message
self.publish_msg( eng_messages.ENGINE_STATE_BUSY+'.'+self.name,
data=(self.debug, self.profile) )
#enable debugger?
if self.debug is True:
trace_func = self.debugger
else:
trace_func = None
#enable profiler?
if self.profile is True:
profile_func = self.profiler
else:
profile_func = None
#run the code
try:
sys.settrace(trace_func)
sys.setprofile(profile_func)
exec code in self._userdict
sys.settrace(None)
sys.setprofile(None)
#system exit - call engine.exit()
except SystemExit:
sys.settrace(None)
sys.setprofile(None)
self.busy = False
log.debug('system exit in runnning code')
self.exit()
return
#keyboard interrupt stopped running code
except KeyboardInterrupt:
sys.settrace(None)
sys.setprofile(None)
self.busy = False
#engine stopped code in order to exit/or disconnect - do not prompt.
if self._stop_quiet:
self._stop_quiet = False
return
#user stopped code
self._stop = False
if self._isreading: #cancel the read prompt.
self.send_msg( self.console, eng_messages.CON_PROMPT_STDIN,
data=(self.prompts[1],None,))
sys.stderr.write('STOP: User forced running code to stop.\n\n')
#other exception - could be an error 1) caused by the engine exiting 2) a different error caused by
#the KeyboardInterrupt (wxpython doesn't play nice!) or 3) a user code error
except:
sys.settrace(None)
sys.setprofile(None)
self.busy = False
#1) engine is exiting/stopping quietly - probably some error
# caused by engine exiting
if self._stop_quiet:
self._stop_quiet = False
log.exception('Exception raised to stop running code? - engine wants to exit.')
return
#2) user stopped code
if self._stop is True:
self._stop = False
if self._isreading: #cancel the read prompt.
self.send_msg( self.console, eng_messages.CON_PROMPT_STDIN,
data=(self.prompts[1], None,))
sys.stderr.write('STOP: User forced running code to stop.\n\n')
#3) error in user code.
self.compiler.show_traceback()
#reset internal state flags
self.busy = False
self._isreading = False
if self.debug is True:
self.debugger.reset()
#softspace makes the print statement work correctly when using final
#comma to supress newlines.
if softspace(sys.stdout, 0):
print
#If exiting skip the rest.
if self._stop_quiet is True:
return
#send an engine done message
self.publish_msg( eng_messages.ENGINE_STATE_DONE+'.'+self.name,
data=(self.debug, self.profile) )
#prompt the console for new command
try:
self.send_msg(self.console, eng_messages.CON_PROMPT,
(self.prompts[0], False,))
except:
log.exception('error ')
pass
res = self.interpreter.run(ast, interactive=True)
if DEBUG:
print self.interpreter._code
if res not in (None, w_Undefined):
try:
if DEBUG:
print repr(res)
print res.ToString(self.interpreter.w_Global)
except ThrowException, exc:
print exc.exception.ToString(self.interpreter.w_Global)
except SystemExit:
raise
except ThrowException, exc:
self.showtraceback(exc)
else:
if code.softspace(sys.stdout, 0):
print
def runsource(self, source, filename="<input>"):
"""Parse and run source in the interpreter.
One of these cases can happen:
1) The input is incorrect. Prints a nice syntax error message.
2) The input in incomplete. More input is required. Returns None.
3) The input is complete. Executes the source code.
"""
try:
ast = load_source(source, filename)
except ParseError, exc:
if exc.source_pos.i == len(source):
# Case 2
