def __init__(self, parent, ID, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0,
locals=None, properties=None, banner=None):
stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
InteractiveInterpreter.__init__(self, locals)
self.lastPromptPos = 0
# the line cache is used to cycle through previous commands
self.lines = []
self.lastUsedLine = self.curLine = 0
# set defaults and then deal with any user defined properties
self.props = {}
self.props.update(_default_properties)
if properties:
self.props.update(properties)
self.UpdateProperties()
# copyright/banner message
if banner is None:
self.write("Python %s on %s\n" % #%s\n(%s)\n" %
(sys.version, sys.platform,
#sys.copyright, self.__class__.__name__
))
else:
self.write("%s\n" % banner)
# write the initial prompt
self.Prompt()
# Event handlers
self.Bind(wx.EVT_KEY_DOWN, self.OnKey)
self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI, id=ID)
def __init__(self, locals=None, rawin=None, \
stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
"""Create an interactive interpreter object."""
InteractiveInterpreter.__init__(self, locals=locals)
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
if rawin:
import __builtin__
__builtin__.raw_input = rawin
del __builtin__
copyright = \
'Type "copyright", "credits" or "license" for more information.'
self.introText = 'Python %s on %s%s%s' % \
(sys.version, sys.platform, os.linesep, copyright)
try:
sys.ps1
except AttributeError:
sys.ps1 = '>>> '
try:
sys.ps2
except AttributeError:
sys.ps2 = '... '
self.more = 0
# List of lists to support recursive push().
self.commandBuffer = []
self.startupScript = os.environ.get('PYTHONSTARTUP')
def showtraceback(self):
self._outputBrush = QtGui.QBrush(QtGui.QColor('#ff0000'))
try:
InteractiveInterpreter.showtraceback(self)
finally:
self._outputBrush = None
def __init__(self, tkconsole):
self.tkconsole = tkconsole
locals = sys.modules['__main__'].__dict__
InteractiveInterpreter.__init__(self, locals=locals)
self.save_warnings_filters = None
self.restarting = False
self.subprocess_arglist = self.build_subprocess_arglist()
def __init__(
self, locals=None, rawin=None, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr, showInterpIntro=True
):
"""Create an interactive interpreter object."""
InteractiveInterpreter.__init__(self, locals=locals)
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
if rawin:
import __builtin__
__builtin__.raw_input = rawin
del __builtin__
if showInterpIntro:
copyright = 'Type "help", "copyright", "credits" or "license"'
copyright += " for more information."
self.introText = "Python %s on %s%s%s" % (sys.version, sys.platform, os.linesep, copyright)
try:
sys.ps1
except AttributeError:
sys.ps1 = ">>> "
try:
sys.ps2
except AttributeError:
sys.ps2 = "... "
self.more = 0
# List of lists to support recursive push().
self.commandBuffer = []
self.startupScript = None
def showtraceback(self):
"Extend base class method to reset output properly"
self.tkconsole.resetoutput()
self.checklinecache()
InteractiveInterpreter.showtraceback(self)
if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
self.tkconsole.open_stack_viewer()
def __init__(self, localAndGlobalDict):
self.stdin = None
self.buf = ""
InteractiveInterpreter.__init__(self, localAndGlobalDict)
sys.ps1 = ""
sys.ps2 = ""
self.more = False
def __init__(self,
locals=None,
rawin=None,
stdin=sys.stdin,
stdout=sys.stdout,
stderr=sys.stderr,
showInterpIntro=True):
"""Create an interactive interpreter object."""
InteractiveInterpreter.__init__(self, locals=locals)
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
if rawin:
from six.moves import builtins
builtins.raw_input = rawin
del builtins
if showInterpIntro:
copyright = 'Type "help", "copyright", "credits" or "license"'
copyright += ' for more information.'
self.introText = 'Python %s on %s%s%s' % \
(sys.version, sys.platform, os.linesep, copyright)
try:
sys.ps1
except AttributeError:
sys.ps1 = '>>> '
try:
sys.ps2
except AttributeError:
sys.ps2 = '... '
self.more = 0
# List of lists to support recursive push().
self.commandBuffer = []
self.startupScript = None
def showsyntaxerror(self, filename = None):
self._outputBrush = QtGui.QBrush(QtGui.QColor('#ffcc63'))
try:
InteractiveInterpreter.showsyntaxerror(self, filename)
finally:
self._outputBrush = None
def showtraceback(self):
self._outputBrush = QtGui.QBrush(QtGui.QColor('#ff0000'))
try:
InteractiveInterpreter.showtraceback(self)
finally:
self._outputBrush = None
def showsyntaxerror(self, filename=None):
"""Extend base class method: Add Colorizing
Color the offending position instead of printing it and pointing at it
with a caret.
"""
text = self.tkconsole.text
stuff = self.unpackerror()
if stuff:
msg, lineno, offset, line = stuff
if lineno == 1:
pos = "iomark + %d chars" % (offset - 1)
else:
pos = "iomark linestart + %d lines + %d chars" % (lineno - 1, offset - 1)
text.tag_add("ERROR", pos)
text.see(pos)
char = text.get(pos)
if char and char in IDENTCHARS:
text.tag_add("ERROR", pos + " wordstart", pos)
self.tkconsole.resetoutput()
self.write("SyntaxError: %s\n" % str(msg))
else:
self.tkconsole.resetoutput()
InteractiveInterpreter.showsyntaxerror(self, filename)
self.tkconsole.showprompt()
def showsyntaxerror(self, filename=None):
self._outputBrush = QtGui.QBrush(QtGui.QColor('#ffcc63'))
try:
InteractiveInterpreter.showsyntaxerror(self, filename)
finally:
self._outputBrush = None
def __init__(self, localAndGlobalDict):
self.stdin = None
self.buf = ""
InteractiveInterpreter.__init__(self, localAndGlobalDict)
sys.ps1 = ""
sys.ps2 = ""
self.more = False
def __init__(self,
locals=None,
rawin=None,
stdin=sys.stdin,
stdout=sys.stdout,
stderr=sys.stderr):
"""Create an interactive interpreter object."""
InteractiveInterpreter.__init__(self, locals=locals)
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
if rawin:
import __builtin__
__builtin__.raw_input = rawin
del __builtin__
#seb copyright = 'Type "help", "copyright", "credits" or "license"'
#seb copyright += ' for more information.'
#seb self.introText = 'Python %s on %s%s%s' % \
#seb (sys.version, sys.platform, os.linesep, copyright)
try:
sys.ps1
except AttributeError:
sys.ps1 = '>>> '
try:
sys.ps2
except AttributeError:
sys.ps2 = '... '
self.more = 0
# List of lists to support recursive push().
self.commandBuffer = []
self.startupScript = os.environ.get('PYTHONSTARTUP')
def __init__(self, locals=None, rawin=None,
stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr,
showInterpIntro=True):
"""Create an interactive interpreter object."""
if not locals:
locals = {}
locals['connect'] = self.connect
InteractiveInterpreter.__init__(self, locals=locals)
self.lua_locals = {}
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
if rawin:
import __builtin__
__builtin__.raw_input = rawin
del __builtin__
if showInterpIntro:
self.introText = 'Inspect the ejoy2dx client'
try:
sys.ps1
except AttributeError:
sys.ps1 = '>>> '
try:
sys.ps2
except AttributeError:
sys.ps2 = '... '
self.more = 0
# List of lists to support recursive push().
self.commandBuffer = []
self.startupScript = None
self.socket = None
def toString(self, structure):
filename='<input>'
symbol='single'
localVars = {"self" : structure, "RETURN" : ""}
inter = InteractiveInterpreter(localVars)
#if isinstance(source, types.UnicodeType):
# import IOBinding
# try:
# source = source.encode(IOBinding.encoding)
# except UnicodeError:
console = InteractiveConsole(localVars, filename)
try:
code_object = compile(self.data.encode('ascii','ignore'), '<string>', 'exec')
exec code_object in localVars
except Exception as e :
print ("- ERR --Kind:%s---------------------------------------" % (self.template.kind) )
InteractiveInterpreter.showsyntaxerror(console, filename)
frames = inspect.trace()
lineNumber = frames[1][2]
print ("At line %s" % lineNumber)
print ("- /ERR -----------------------------------------")
print ("- CODE -----------------------------------------")
lines = self.data.split('\n')
for i in range(0,lineNumber):
print lines[i]
print "^"*20
print ("- /CODE -----------------------------------------")
print ("")
return localVars["RETURN"]
class PyConsoleTextEdit(ConsoleTextEdit):
_color_stdin = Qt.darkGreen
_multi_line_char = ':'
_multi_line_indent = ' '
_prompt = ('>>> ', '... ') # prompt for single and multi line
exit = Signal()
def __init__(self, parent=None):
super(PyConsoleTextEdit, self).__init__(parent)
self._interpreter_locals = {}
self._interpreter = InteractiveInterpreter(self._interpreter_locals)
self._comment_writer.write('Python %s on %s\n' % (sys.version.replace('\n', ''), sys.platform))
self._comment_writer.write('Qt bindings: %s version %s\n' % (QT_BINDING, QT_BINDING_VERSION))
self._add_prompt()
def update_interpreter_locals(self, newLocals):
self._interpreter_locals.update(newLocals)
def _exec_code(self, code):
try:
self._interpreter.runsource(code)
except SystemExit: # catch sys.exit() calls, so they don't close the whole gui
self.exit.emit()
def __init__(self, args):
global Charm4PyError
from .charm import Charm4PyError
# restore original tty stdin and stdout (else readline won't work correctly)
os.dup2(charm.origStdinFd, 0)
os.dup2(charm.origStoutFd, 1)
charm.dynamic_register['future'] = future_
charm.dynamic_register['self'] = self
InteractiveInterpreter.__init__(self, locals=charm.dynamic_register)
self.filename = '<console>'
self.resetbuffer()
# regexp to detect when user defines a new chare type
self.regexpChareDefine = re.compile(
'class\s*(\S+)\s*\(.*Chare.*\)\s*:')
# regexps to detect import statements
self.regexpImport1 = re.compile('\s*from\s*(\S+) import')
self.regexpImport2 = re.compile('import\s*(\S+)')
self.options = charm.options.interactive
try:
import readline
import rlcompleter
readline.parse_and_bind('tab: complete')
except:
pass
try:
sys.ps1
except AttributeError:
sys.ps1 = '>>> '
try:
sys.ps2
except AttributeError:
sys.ps2 = '... '
self.thisProxy.start()
def __init__(self):
self.stdout = sys.stdout
self.stderr = sys.stderr
self.out_cache = FileCacher()
self.err_cache = FileCacher()
InteractiveInterpreter.__init__(self)
return
def showtraceback(self):
"Extend base class method to reset output properly"
self.tkconsole.resetoutput()
self.checklinecache()
InteractiveInterpreter.showtraceback(self)
if self.tkconsole.getvar("<<toggle-jit-stack-viewer>>"):
self.tkconsole.open_stack_viewer()
def __init__(self, parent=None):
super(PythonWidget, self).__init__(parent)
# PythonWidget attributes.
self.locals = dict(__name__='__console__', __doc__=None)
self.interpreter = InteractiveInterpreter(self.locals)
# PythonWidget protected attributes.
self._buffer = StringIO()
self._bracket_matcher = BracketMatcher(self._control)
self._call_tip_widget = CallTipWidget(self._control)
self._completion_lexer = CompletionLexer(PythonLexer())
self._hidden = False
self._highlighter = PythonWidgetHighlighter(self)
self._last_refresh_time = 0
# file-like object attributes.
self.encoding = sys.stdin.encoding
# Configure the ConsoleWidget.
self.tab_width = 4
self._set_continuation_prompt('... ')
# Configure the CallTipWidget.
self._call_tip_widget.setFont(self.font)
self.font_changed.connect(self._call_tip_widget.setFont)
# Connect signal handlers.
document = self._control.document()
document.contentsChange.connect(self._document_contents_change)
# Display the banner and initial prompt.
self.reset()
def __init__(self, tkconsole):
self.tkconsole = tkconsole
locals = sys.modules['__main__'].__dict__
InteractiveInterpreter.__init__(self, locals=locals)
self.save_warnings_filters = None
self.restarting = False
self.subprocess_arglist = self.build_subprocess_arglist()
def showsyntaxerror(self, filename=None):
"""Extend base class method: Add Colorizing
Color the offending position instead of printing it and pointing at it
with a caret.
"""
text = self.tkconsole.text
stuff = self.unpackerror()
if stuff:
msg, lineno, offset, line = stuff
if lineno == 1:
pos = "iomark + %d chars" % (offset - 1)
else:
pos = "iomark linestart + %d lines + %d chars" % \
(lineno-1, offset-1)
text.tag_add("ERROR", pos)
text.see(pos)
char = text.get(pos)
if char and char in IDENTCHARS:
text.tag_add("ERROR", pos + " wordstart", pos)
self.tkconsole.resetoutput()
self.write("SyntaxError: %s\n" % str(msg))
else:
self.tkconsole.resetoutput()
InteractiveInterpreter.showsyntaxerror(self, filename)
self.tkconsole.showprompt()
def command(self, text):
if not self.hidden:
self.cscroll = None
self.command = ''
self.entry.set('')
self.entry['focus'] = True
self.writeOut(self.otext['text'] + ' ' + text + '\n', False)
if text != '' and (len(self.commands) == 0 or self.commands[-1] != text):
self.commands.append(text)
# Insert plugins into the local namespace
locals = __main__.__dict__
#locals['manager'] = self.manager
#for plugin in self.manager.named.keys():
# locals[plugin] = self.manager.named[plugin]
locals['panda3d'] = panda3d
# Run it and print the output.
if not self.initialized:
InteractiveInterpreter.__init__(self, locals = locals)
self.initialized = True
try:
if self.runsource(self.block + '\n' + text) and text != '':
self.otext['text'] = '.'
self.block += '\n' + text
else:
self.otext['text'] = ':'
self.block = ''
except Exception: # Not just "except", it will also catch SystemExit
# Whoops! Print out a traceback.
self.writeErr(traceback.format_exc())
def __init__(self, parent, ID, pos=wx.DefaultPosition,
size=wx.DefaultSize, style=0,
locals=None, properties=None, banner=None):
stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
InteractiveInterpreter.__init__(self, locals)
self.lastPromptPos = 0
# the line cache is used to cycle through previous commands
self.lines = []
self.lastUsedLine = self.curLine = 0
# set defaults and then deal with any user defined properties
self.props = {}
self.props.update(_default_properties)
if properties:
self.props.update(properties)
self.UpdateProperties()
# copyright/banner message
if banner is None:
self.write("Python %s on %s\n" % #%s\n(%s)\n" %
(sys.version, sys.platform,
#sys.copyright, self.__class__.__name__
))
else:
self.write("%s\n" % banner)
# write the initial prompt
self.Prompt()
# Event handlers
self.Bind(wx.EVT_KEY_DOWN, self.OnKey)
self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdateUI, id=ID)
def __init__(self, locals=None, rawin=None, \
stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr):
"""Create an interactive interpreter object."""
InteractiveInterpreter.__init__(self, locals=locals)
self.stdin = stdin
self.stdout = stdout
self.stderr = stderr
if rawin:
import __builtin__
__builtin__.raw_input = rawin
del __builtin__
self.introText = 'SunShell %s %s\n' % (VERSION, COPYRIGHT)
self.introText += 'Use "it.connect()" to establish a connection.\n'
try:
sys.ps1
except AttributeError:
sys.ps1 = '>>> '
try:
sys.ps2
except AttributeError:
sys.ps2 = '... '
self.more = 0
# List of lists to support recursive push().
self.commandBuffer = []
self.startupScript = os.environ.get('PYTHONSTARTUP')
class PyConsoleTextEdit(ConsoleTextEdit):
_color_stdin = Qt.darkGreen
_multi_line_char = ':'
_multi_line_indent = ' '
_prompt = ('>>> ', '... ') # prompt for single and multi line
exit = Signal()
def __init__(self, parent=None):
super(PyConsoleTextEdit, self).__init__(parent)
self._interpreter_locals = {}
self._interpreter = InteractiveInterpreter(self._interpreter_locals)
self._comment_writer.write('Python %s on %s\n' % (sys.version.replace('\n', ''), sys.platform))
self._comment_writer.write('Qt bindings: %s version %s\n' % (QT_BINDING, QT_BINDING_VERSION))
self._add_prompt()
def update_interpreter_locals(self, newLocals):
self._interpreter_locals.update(newLocals)
def _exec_code(self, code):
try:
self._interpreter.runsource(code)
except SystemExit: # catch sys.exit() calls, so they don't close the whole gui
self.exit.emit()
def __init__(self, stdin, stdout, locals=None):
QObject.__init__(self)
InteractiveInterpreter.__init__(self, locals)
self.locals['exit'] = Exit()
self.stdin = stdin
self.stdout = stdout
self._executing = False
self.compile = partial(compile_multi, self.compile)
def showtraceback(self):
type_, value, tb = sys.exc_info()
self.stdout.write('\n')
if type_ == KeyboardInterrupt:
self.stdout.write('KeyboardInterrupt\n')
else:
InteractiveInterpreter.showtraceback(self)
def execute(interpreter: InteractiveInterpreter, code):
errors = ""
old_stdout, old_stderr = sys.stdout, sys.stderr
redirected_output = sys.stdout = StringIO()
redirected_error = sys.stderr = StringIO()
interpreter.runcode(code)
sys.stdout, sys.stderr = old_stdout, old_stdout
return {'output': redirected_output.getvalue(), 'error': redirected_error.getvalue()}
def __init__(self, parent=None):
super(MyWindow, self).__init__(parent=parent)
self.newshell = True
self.stmt = True
self.construct = False
self.initUI()
self.index = 0
self.interpreter = InteractiveInterpreter()
def __init__(self, tkconsole):
self.tkconsole = tkconsole
locals = sys.modules['__main__'].__dict__
InteractiveInterpreter.__init__(self, locals=locals)
self.save_warnings_filters = None
self.restarting = False
self.subprocess_arglist = None
self.original_compiler_flags = self.compile.compiler.flags
def __init__(self, app):
InteractiveInterpreter.__init__(
self,
vdict({
"app": app,
"plot": plot.plot
},
setitem=self.setitem,
delitem=self.delitem))
self.frame = tk.Frame(app,
padx=16,
pady=8,
background=Color.DARK_BLACK)
Text.__init__(self,
self.frame,
readonly=True,
background=Color.DARK_BLACK,
font=FONT,
padx=0,
pady=0,
wrap="word",
cursor="arrow",
insertbackground=Color.DARK_BLACK)
sys.displayhook = self.write
sys.excepthook = self.showtraceback
__builtins__["print"] = self.write
__builtins__["help"] = Help(app)
__builtins__["clear"] = Clear(self)
__builtins__[
"copyright"] = "Copyright (c) 2018-2021 Matt Calhoun.\nAll Rights Reserved."
__builtins__[
"credits"] = "Created by Matt Calhoun.\nSee https://mathinspector.com for more information."
__builtins__["license"] = License()
self.app = app
self.prompt = Prompt(self, self.frame)
self.parse = CodeParser(app)
self.buffer = []
self.prevent_module_import = False
self.bind("<Key>", self._on_key_log)
self.bind("<Configure>", self.prompt.on_configure_log)
self.bind("<ButtonRelease-1>", self.on_click_log)
self.pack(fill="both", expand=True)
for i in ["error_file"]:
self.tag_bind(i,
"<Motion>",
lambda event, key=i: self._motion(event, key))
self.tag_bind(i,
"<Leave>",
lambda event, key=i: self._leave(event, key))
self.tag_bind(i,
"<Button-1>",
lambda event, key=i: self._click(event, key))
def __init__(self, element):
InteractiveInterpreter.__init__(self)
self.element = element
self.buffer = ''
self.stream = DOMInterpreter.Stream(self)
self.source = []
self.write('pyglet interpreter\n')
self.write('>>> ')
def __init__(self, queue: list, id):
super().__init__()
self.id = id
self.queue = queue
self.result = []
variables = globals().copy()
variables.update(locals())
self.interpreter = InteractiveInterpreter(variables)
self.stop = False
def __init__(self, queue, local={}):
if '__name__' not in local:
local['__name__'] = '__console__'
if '__doc__' not in local:
local['__doc__'] = None
self.out_queue = queue
sys.stdout = DummyFile('stdout', queue)
sys.stderr = DummyFile('sdterr', queue)
InteractiveInterpreter.__init__(self, locals=local)
def __init__(self, element):
InteractiveInterpreter.__init__(self)
self.element = element
self.buffer = ''
self.stream = DOMInterpreter.Stream(self)
self.source = []
self.write('pyglet interpreter\n')
self.write('>>> ')
def __init__(self, namespace=None):
if namespace is not None:
namespace = namespace()
InteractiveInterpreter.__init__(self, namespace)
self.output_trap = OutputTrap()
self.completer = Completer(self.locals)
self.input_count = 0
self.interrupted = False
def __init__(self, queue, local={}):
if '__name__' not in local:
local['__name__'] = '__console__'
if '__doc__' not in local:
local['__doc__'] = None
self.out_queue = queue
sys.stdout = DummyFile('stdout', queue)
sys.stderr = DummyFile('sdterr', queue)
InteractiveInterpreter.__init__(self, locals=local)
def __init__(self, namespace=None):
if namespace is not None:
namespace = namespace()
InteractiveInterpreter.__init__(self, namespace)
self.output_trap = OutputTrap()
self.completer = Completer(self.locals)
self.input_count = 0
self.interrupted = False
def __init__(self, tkconsole):
self.tkconsole = tkconsole
locals = sys.modules['__main__'].__dict__
InteractiveInterpreter.__init__(self, locals=locals)
self.save_warnings_filters = None
self.restarting = False
self.subprocess_arglist = None
self.port = PORT
self.original_compiler_flags = self.compile.compiler.flags
def __init__(self, parent=None):
super(PyConsoleTextEdit, self).__init__(parent)
self._interpreter_locals = {}
self._interpreter = InteractiveInterpreter(self._interpreter_locals)
self._comment_writer.write('Python %s on %s\n' % (sys.version.replace('\n', ''), sys.platform))
self._comment_writer.write('Qt bindings: %s version %s\n' % (QT_BINDING, QT_BINDING_VERSION))
self._add_prompt()
class ConsoleWindow(QtGui.QMainWindow, Ui_ConsoleWindow):
def __init__(self, parent=None):
super(ConsoleWindow, self).__init__(parent)
self.setupUi(self)
self.interp = InteractiveInterpreter({
'__name__': "__console__",
'__doc__': None,
'retwin': parent,
'retapp': parent.application,
'conwin': self,
'sys': sys,
})
outFormat = QtGui.QTextCharFormat()
outFormat.setForeground(QtGui.QBrush(QtGui.QColor(0, 128, 0)))
outFormat.setFontWeight(QtGui.QFont.Normal)
errFormat = QtGui.QTextCharFormat()
errFormat.setForeground(QtGui.QBrush(QtGui.QColor(255, 0, 0)))
entryFormat = QtGui.QTextCharFormat()
entryFormat.setFontWeight(QtGui.QFont.Bold)
self.stdout = ConsoleOutputWriter(
self.consoleOutput, "<stdout>", outFormat)
self.stderr = ConsoleOutputWriter(
self.consoleOutput, "<stderr>", errFormat)
self.entry = ConsoleOutputWriter(
self.consoleOutput, "<stdin>", entryFormat)
self.consoleEntry.evaluate = self.evaluate
return
def evaluate(self, text):
# Redirect stdout, stderr while executing the command
try:
saved_stdout, saved_stderr = sys.stdout, sys.stderr
sys.stdout, sys.stderr = self.stdout, self.stderr
try:
compiled = compile_command(text, "<console>")
if compiled is None:
return False
self.entry.write(">>> " + text.replace("\n", "\n... ") + "\n")
self.interp.runcode(compiled)
except Exception as e:
print_exc()
finally:
sys.stdout, sys.stderr = saved_stdout, saved_stderr
return True
def execfile(self, filename, source=None):
# Execute an existing file
if source is None:
source = open(filename, "r").read()
try:
code = compile(source, filename, "exec")
except (OverflowError, SyntaxError):
self.tkconsole.resetoutput()
InteractiveInterpreter.showsyntaxerror(self, filename)
else:
self.runcode(code)
def execfile(self, filename, source=None):
# Execute an existing file
if source is None:
source = open(filename, "r").read()
try:
code = compile(source, filename, "exec")
except (OverflowError, SyntaxError):
self.tkconsole.resetoutput()
InteractiveInterpreter.showsyntaxerror(self, filename)
else:
self.runcode(code)
class MyWindow(QtGui.QWidget):
def __init__(self, parent=None):
super(MyWindow, self).__init__(parent=parent)
self.newshell = True
self.stmt = True
self.construct = False
self.initUI()
self.index = 0
self.interpreter = InteractiveInterpreter()
def initUI(self):
self.sh = QtGui.QTextEdit(
'''
Python 2.7.6 on linux2
** DO NOT DELETE SHELL PROMPT! **
>>> ''', self)
self.sh.textChanged.connect(self.shellop)
self.sh.setReadOnly(True)
self.sh.setReadOnly(False)
def shellop(self):
self.index += 1
if self.sh.toPlainText()[self.index] == "\n" and self.sh.toPlainText()[
self.index - 1] == ":":
self.stmt = False
self.construct = True
elif self.sh.toPlainText()[self.index] == "\n" and not self.construct:
self.stmt = not self.stmt
class stdoutProxy:
def write(self, s):
self.sh.insertPlainText(s)
stdout = sys.stdout
sys.stdout = stdoutProxy()
self.interpreter.runsource(self.sh.toPlainText())
self.sh.insertPlainText("\n")
self.index += 1
while self.interpreter.showtraceback():
print self.interpreter.showtraceback()
sys.stdout = stdout
if self.sh.toPlainText()[
self.index] == "\n" and not self.construct and not self.stmt:
self.stmt = not self.stmt
self.sh.insertPlainText(">>> ")
self.index += 4
if self.construct and self.sh.toPlainText(
)[self.index] == "\n" and self.sh.toPlainText()[self.index - 1] == " ":
self.construct = False
self.sh.insertPlainText(">>> ")
self.index += 4
if self.construct:
self.sh.insertPlainText("... ")
index += 4
def console_run(self, local_dict=None):
self.run(backend=True)
from code import InteractiveInterpreter
i = InteractiveInterpreter(local_dict)
while True:
prompt = ">>>"
try:
line = raw_input(prompt)
except EOFError:
print("closing..")
return
i.runcode(line)
def __init__(self, local={}):
self.stdout = sys.stdout
self.stdout_cache = FileCacher()
self.stderr = sys.stderr
self.stderr_cache = FileCacher()
# Define minimum local variables to sub shell.
if '__name__' not in local: local['__name__'] = '__kaap__'
if '__doc__' not in local: local['__doc__'] = None
InteractiveInterpreter.__init__(self, local)
return
def execute_or_eval(self, mode, locals):
""" Run the code """
basic_interpreter = InteractiveInterpreter(locals=locals)
with tempfile.TemporaryFile(mode='w+', prefix='interpreter_error') as error_output:
original_error = sys.stderr
sys.stderr = error_output
try:
if mode == 'exec':
code = compile(self.source, self.filename, 'exec')
else:
code = compile(self.expr, '<string>', 'eval')
except:
InteractiveInterpreter.showsyntaxerror(self.filename)
sys.stderr.seek(0)
result = sys.stderr.read()
self.report.add_compilation_error('error', err_type='SyntaxError', details=result)
return False
else: # No compilation errors here
if mode == 'exec':
result = basic_interpreter.runcode(code)
sys.stderr.seek(0)
result = sys.stderr.read()
if result:
self.report.add_compilation_error('error', err_type='SyntaxError', details=result)
return False
else:
sys.stdout.seek(0)
result = sys.stdout.read()
self.report.set_result(result)
return True
else: # mode eval
try:
result = eval(code, locals, locals)
except Exception as err:
a, b, tb = sys.exc_info() # Get the traceback object
# Extract the information for the traceback corresponding to the error
# inside the source code : [0] refers to the result = exec(code)
# traceback, [1] refers to the last error inside code
filename, lineno, file_type, line = traceback.extract_tb(tb)[1]
print(traceback.format_exception(a, b, tb))
tb_str = "".join(traceback.format_exception_only(a, b))
self.report.add_execution_error('error', a.__name__, details=str(err))
return False
self.report.set_result(result)
return True
finally:
sys.stderr = original_error
def __init__(self, Interpreter=None, Parent=None, OldInstance=None):
# Variables
self.Parent = Parent
self.HistoryCount = 0
self.state = None
self.BackState = None
if OldInstance != None:
self.Submodels = OldInstance.Submodels
else:
self.Submodels = []
for i in range(ButtonBehaviour_MDL.StateNum):
self.Submodels.append(None)
self.history = []
for i in range(ButtonBehaviour_MDL.StateNum):
self.history.append(None)
# Constructor
for i in range(ButtonBehaviour_MDL.StateNum):
self.history[i] = History()
self.history[i].States = []
self.history[i].Times = []
for j in range(ButtonBehaviour_MDL.StateNum):
self.history[i].States.append(-1)
self.history[i].Times.append(-1)
self.TimedTransitions = [] # used only when --ext is set
for i in range(ButtonBehaviour_MDL.StateNum):
self.TimedTransitions.append(None)
self.clearEnteredStates()
self.HasInteractor = 0
# Interpreter of action code
if self.Parent == None: # Top-level model
if Interpreter:
self.DefaultInterpreter = Interpreter
else:
self.DefaultInterpreter = InteractiveInterpreter()
self.setupInterpreter()
##self.EventsCond=threading.Condition()
##self.SchedulerCond=threading.Condition()
self.Schedules = []
self.PendingEvents = None
self.PendingEventsTail = None
else:
self.DefaultInterpreter = Interpreter
self.Started = 0
self.Stopped = 0
self.description = ButtonBehaviour_MDL.Description
def __init__(self, parent=None, log=''):
QTextEdit.__init__(self, parent)
InteractiveInterpreter.__init__(self, None)
self.setupUi(self)
self.name = self.windowTitle()
self.log = log or ''
self.__canwrite = True
if parent is None:
self.eofKey = Qt.Key_D
else:
self.eofKey = None
self.line = QString()
self.lines = []
self.point = 0
self.more = 0
self.reading = 0
self.history = []
self.pointer = 0
self.cursor_pos = 0
self.fgcolor = QColor("white")
self.selcolor = QColor("green")
self.strcolor = QColor("red")
self.redirect = RedirectIO()
self.sig = "IIputtext(QString)"
self.connect(self, SIGNAL(self.sig),
self.sputtext) #, Qt.QueuedConnection)
self.connect(self, SIGNAL("Iputtext(QString)"), self.puttext)
self.redirect.addparent(
self,
["dff.ui.gui.widget.interpreter", "code", "__console__", "pydoc"])
self.ps1 = ">>> "
self.ps2 = "... "
self.writePrompt()
api_imports = [
"from dff.api.types.libtypes import Variant, VList, VMap, DateTime, typeId, Argument, Parameter, ConfigManager, Constant, Config, Path",
"from dff.api.vfs.vfs import vfs",
"from dff.api.vfs.libvfs import VFS, FileMapping, ABSOLUTE_ATTR_NAME, RELATIVE_ATTR_NAME",
"from dff.api.filters.libfilters import Filter",
"from dff.api.search.libsearch import Search",
"from dff.api.events.libevents import EventHandler, event",
"from dff.api.datatype.libdatatype import DataTypeManager, DataTypeHandler",
"from dff.api.loader.loader import loader",
"from dff.api.module.module import Module, Script",
"from dff.api.taskmanager.taskmanager import TaskManager"
]
for api_import in api_imports:
self.more = self.runsource(api_import)
def __init__(self, console_widget, locals = {}):
self.__console_widget = console_widget
self.__ps1 = ">>> "
self.__ps2 = "... "
self.__ps = self.__ps1
self.__partial_source = ""
# se encarga de ejecutar los comandos
self.__command_procesor = ItemProcesorPipeline(1)
self.__locals = self.__init_locals(locals)
InteractiveInterpreter.__init__(self, locals)
def execfile(self, filename, source=None):
"Execute an existing file"
if source is None:
source = open(filename, "r").read()
try:
code = compile(source, filename, "exec")
except (OverflowError, SyntaxError):
#self.tkconsole.resetoutput()
tkerr = sys.stderr
print>>tkerr, '*** Error in script or command!\n'
print>>tkerr, 'Traceback (most recent call last):'
InteractiveInterpreter.showsyntaxerror(self, filename)
else:
self.runcode(code)
def __init__(self, **kwargs):
self.service = client.connect(**kwargs)
self.delete = self.service.delete
self.get = self.service.get
self.post = self.service.post
locals = {
'service': self.service,
'connect': client.connect,
'delete': self.delete,
'get': self.get,
'post': self.post,
'load': self.load,
}
InteractiveInterpreter.__init__(self, locals)
def __init__(self, tkconsole):
self.tkconsole = tkconsole # Required by later rpc registrations.
self.active_seq = None
self.port = 8833
self.rpcclt = None
self.rpcpid = None
locals = sys.modules['__main__'].__dict__
InteractiveInterpreter.__init__(self, locals=locals)
self.save_warnings_filters = None
self.restarting = False
self.subprocess_arglist = self.build_subprocess_arglist()
def runcodes(self):
"""Exécute les codes en attente."""
codes = list(self.codes)
self.codes.clear()
# Rétablit sus.stdout et sys.stderr
stdout = sys.stdout
stderr = sys.stderr
sys.stdout = sys.__stdout__
sys.stderr = sys.__stderr__
for code in codes:
InteractiveInterpreter.runcode(self, code)
sys.stdout = stdout
sys.stderr = stderr
class MyWindow(QtGui.QWidget):
def __init__(self, parent=None):
super(MyWindow, self).__init__(parent=parent)
self.newshell = True
self.stmt = True
self.construct = False
self.initUI()
self.index = 0
self.interpreter = InteractiveInterpreter()
def initUI(self):
self.sh = QtGui.QTextEdit('''
Python 2.7.6 on linux2
** DO NOT DELETE SHELL PROMPT! **
>>> ''', self)
self.sh.textChanged.connect(self.shellop)
self.sh.setReadOnly(True)
self.sh.setReadOnly(False)
def shellop(self):
self.index += 1
if self.sh.toPlainText()[self.index] == "\n" and self.sh.toPlainText()[self.index-1] == ":":
self.stmt = False
self.construct = True
elif self.sh.toPlainText()[self.index] == "\n" and not self.construct:
self.stmt = not self.stmt
class stdoutProxy:
def write(self, s):
self.sh.insertPlainText(s)
stdout = sys.stdout
sys.stdout = stdoutProxy()
self.interpreter.runsource(self.sh.toPlainText())
self.sh.insertPlainText("\n")
self.index += 1
while self.interpreter.showtraceback():
print self.interpreter.showtraceback()
sys.stdout = stdout
if self.sh.toPlainText()[self.index] == "\n" and not self.construct and not self.stmt:
self.stmt = not self.stmt
self.sh.insertPlainText(">>> ")
self.index += 4
if self.construct and self.sh.toPlainText()[self.index] == "\n" and self.sh.toPlainText()[self.index-1] == " ":
self.construct = False
self.sh.insertPlainText(">>> ")
self.index += 4
if self.construct:
self.sh.insertPlainText("... ")
index += 4
def __init__(self, parent=None, log=""):
QTextEdit.__init__(self, parent)
InteractiveInterpreter.__init__(self, None)
self.setupUi(self)
self.name = self.windowTitle()
self.log = log or ""
self.__canwrite = True
if parent is None:
self.eofKey = Qt.Key_D
else:
self.eofKey = None
self.line = QString()
self.lines = []
self.point = 0
self.more = 0
self.reading = 0
self.history = []
self.pointer = 0
self.cursor_pos = 0
self.fgcolor = QColor("white")
self.selcolor = QColor("green")
self.strcolor = QColor("red")
self.redirect = RedirectIO()
self.sig = "Iputtext"
self.connect(self, SIGNAL(self.sig), self.puttext)
self.redirect.addparent(self, ["ui.gui.widget.interpreter", "code", "__console__", "pydoc"])
self.ps1 = ">>> "
self.ps2 = "... "
self.writePrompt()
api_imports = [
"from api.types.libtypes import Variant, VList, VMap, vtime, typeId, Argument, Parameter, ConfigManager, Constant, Config, Path",
"from api.vfs.vfs import vfs",
"from api.vfs.libvfs import VFS, FileMapping, ABSOLUTE_ATTR_NAME, RELATIVE_ATTR_NAME",
"from api.filters.libfilters import Filter",
"from api.search.libsearch import Search",
"from api.events.libevents import EventHandler, event",
"from api.datatype.libdatatype import DataTypeManager, DataTypeHandler",
"from api.loader.loader import loader",
"from api.module.module import Module, Script",
"from api.magic.libmagichandler import MagicType, MimeType",
"from api.taskmanager.taskmanager import TaskManager",
]
for api_import in api_imports:
self.more = self.runsource(api_import)
def __init__(self, parent=None):
super(PythonWidget, self).__init__(parent)
# PythonWidget attributes.
self.locals = dict(__name__='__console__', __doc__=None)
self.interpreter = InteractiveInterpreter(self.locals)
# PythonWidget protected attributes.
self._buffer = StringIO()
self._bracket_matcher = BracketMatcher(self._control)
self._call_tip_widget = CallTipWidget(self._control)
self._completion_lexer = CompletionLexer(PythonLexer())
self._hidden = False
self._highlighter = PythonWidgetHighlighter(self)
self._last_refresh_time = 0
# file-like object attributes.
self.encoding = sys.stdin.encoding
# Configure the ConsoleWidget.
self.tab_width = 4
self._set_continuation_prompt('... ')
# Configure the CallTipWidget.
self._call_tip_widget.setFont(self.font)
self.font_changed.connect(self._call_tip_widget.setFont)
# Connect signal handlers.
document = self._control.document()
document.contentsChange.connect(self._document_contents_change)
# Display the banner and initial prompt.
self.reset()
