def __init__(self, workspace=None, thread_id=None):
if workspace is None:
workspace = dict()
self.workspace = workspace
self.compile = CommandCompiler()
self.thread_id = thread_id
def __init__(self,
namespace=None,
io=None,
ps1="Python> ",
ps2="..more> ",
history=None):
self._ns = namespace or globals()
self._io = io or ConsoleIO()
if history:
self.history = os.path.expandvars(os.path.expanduser(history))
else:
self.history = None
readline.set_history_length(1000)
if sys.platform == "darwin":
readline.parse_and_bind("^I rl_complete")
else:
readline.parse_and_bind("tab: complete")
try:
self.saveps1, self.saveps2 = sys.ps1, sys.ps2
except AttributeError:
self.saveps1, self.saveps2 = ">>> ", "... "
sys.ps1, sys.ps2 = ps1, ps2
if self.history:
try:
readline.read_history_file(self.history)
except FileNotFoundError:
pass
self.compiler = CommandCompiler()
self._reset()
def __init__(self, locals=None, encoding=None):
"""Constructor.
The optional 'locals' argument specifies the dictionary in
which code will be executed; it defaults to a newly created
dictionary with key "__name__" set to "__console__" and key
"__doc__" set to None.
We include an argument for the outfile to pass to the formatter for it
to write to.
"""
if locals is None:
locals = {"__name__": "__console__", "__doc__": None}
if encoding is None:
encoding = getpreferredencoding()
ReplInterpreter.__init__(self, locals, encoding)
self.locals = locals
self.compile = CommandCompiler()
# typically changed after being instantiated
# but used when interpreter used corresponding REPL
def write(err_line):
"""Default stderr handler for tracebacks
Accepts FmtStrs so interpreters can output them"""
sys.stderr.write(text_type(err_line))
self.write = write
self.outfile = self
def __init__(self, locals, filename="<console>"):
# Init variables for locals and globals (globals only for debugging)
self.locals = locals
self.globals = None
# Store filename
self._filename = filename
# Store ref of locals that is our main
self._main_locals = locals
# Flag to ignore sys exit, to allow running some scripts
# interactively, even if they call sys.exit.
self.ignore_sys_exit = False
# Information for debugging. If self._dbFrames, we're in debug mode
# _dbFrameIndex starts from 1
self._dbFrames = []
self._dbFrameIndex = 0
self._dbFrameName = ""
# Init datase to store source code that we execute
self._codeCollection = ExecutedSourceCollection()
# Init buffer to deal with multi-line command in the shell
self._buffer = []
# Init sleep time. 0.001 result in 0% CPU usage at my laptop (Windows),
# but 8% CPU usage at my older laptop (on Linux).
self.sleeptime = 0.01 # 100 Hz
# Create compiler
if sys.platform.startswith("java"):
import compiler
self._compile = compiler.compile # or 'exec' does not work
else:
self._compile = CommandCompiler()
# Instantiate magician and tracer
self.magician = Magician()
self.debugger = Debugger()
# To keep track of whether to send a new prompt, and whether more
# code is expected.
self.more = 0
self.newPrompt = True
# Code and script to run on first iteration
self._codeToRunOnStartup = None
self._scriptToRunOnStartup = None
# Remove "THIS" directory from the PYTHONPATH
# to prevent unwanted imports. Same for pyzokernel dir
thisPath = os.getcwd()
for p in [thisPath, os.path.join(thisPath, "pyzokernel")]:
while p in sys.path:
sys.path.remove(p)
def __init__(self,
prompt='>>> ',
continuation='... ',
parent=None):
QTextEdit.__init__(self, parent)
self.shutting_down = False
self.compiler = CommandCompiler()
self.buf = self.old_buf = []
self.history = History([''], dynamic.get('console_history', []))
self.prompt_frame = None
self.allow_output = False
self.prompt_frame_format = QTextFrameFormat()
self.prompt_frame_format.setBorder(1)
self.prompt_frame_format.setBorderStyle(QTextFrameFormat.BorderStyle_Solid)
self.prompt_len = len(prompt)
self.doc.setMaximumBlockCount(int(prefs['scrollback']))
self.lexer = PythonLexer(ensurenl=False)
self.tb_lexer = PythonTracebackLexer()
self.context_menu = cm = QMenu(self) # {{{
cm.theme = ThemeMenu(cm)
# }}}
self.formatter = Formatter(prompt, continuation, style=prefs['theme'])
p = QPalette()
p.setColor(p.Base, QColor(self.formatter.background_color))
p.setColor(p.Text, QColor(self.formatter.color))
self.setPalette(p)
self.key_dispatcher = { # {{{
Qt.Key_Enter : self.enter_pressed,
Qt.Key_Return : self.enter_pressed,
Qt.Key_Up : self.up_pressed,
Qt.Key_Down : self.down_pressed,
Qt.Key_Home : self.home_pressed,
Qt.Key_End : self.end_pressed,
Qt.Key_Left : self.left_pressed,
Qt.Key_Right : self.right_pressed,
Qt.Key_Backspace : self.backspace_pressed,
Qt.Key_Delete : self.delete_pressed,
} # }}}
motd = textwrap.dedent('''\
# Python {0}
# {1} {2}
'''.format(sys.version.splitlines()[0], __appname__,
__version__))
sys.excepthook = self.unhandled_exception
self.controllers = []
QTimer.singleShot(0, self.launch_controller)
with EditBlock(self.cursor):
self.render_block(motd)
def __init__(self, locals=None):
"""Constructor.
The optional 'locals' argument specifies the dictionary in
which code will be executed; it defaults to a newly created
dictionary with key "__name__" set to "__console__" and key
"__doc__" set to None.
"""
if locals is None:
locals = {"__name__": "__console__", "__doc__": None}
self.locals = locals
self.compile = CommandCompiler()
def __init__(self, locals, filename="<console>"):
# Init variables for locals and globals (globals only for debugging)
self.locals = locals
self.globals = None
# Store filename
self._filename = filename
# Store ref of locals that is our main
self._main_locals = locals
# Information for debugging. If self._dbFrames, we're in debug mode
# _dbFrameIndex starts from 1
self._dbFrames = []
self._dbFrameIndex = 0
self._dbFrameName = ''
# Init datase to store source code that we execute
self._codeCollection = ExecutedSourceCollection()
# Init buffer to deal with multi-line command in the shell
self._buffer = []
# Init sleep time. 0.001 result in 0% CPU usage at my laptop (Windows),
# but 8% CPU usage at my older laptop (on Linux).
self.sleeptime = 0.01 # 100 Hz
# Create compiler
self._compile = CommandCompiler()
# Instantiate magician
self.magician = Magician()
# Define prompts
try:
sys.ps1
except AttributeError:
sys.ps1 = ">>> "
try:
sys.ps2
except AttributeError:
sys.ps2 = "... "
# Remove "THIS" directory from the PYTHONPATH
# to prevent unwanted imports. Same for iepkernel dir
thisPath = os.getcwd()
for p in [thisPath, os.path.join(thisPath, 'iepkernel')]:
while p in sys.path:
sys.path.remove(p)
def __init__(self, locals=None, username=None):
"""
The optional 'locals' argument specifies the dictionary in
which code will be executed; it defaults to a newly created
dictionary with key "__name__" set to "__console__" and key
"__doc__" set to None.
"""
if locals is None:
locals = {"__name__": "__console__", "__doc__": None}
self.locals = locals
self.username = username
if username is not None:
self.locals.update(config[username]['symbols'])
#print _("Hello %s ! "% username)
print('')
self.compile = CommandCompiler()
def __init__(self, locals=None):
"""Constructor.
The optional 'locals' argument specifies the dictionary in
which code will be executed; it defaults to a newly created
dictionary with key "__name__" set to "__console__" and key
"__doc__" set to None.
We include an argument for the outfile to pass to the formatter for it to write to.
"""
if locals is None:
locals = {"__name__": "__console__", "__doc__": None}
self.locals = locals
self.compile = CommandCompiler()
# typically changed after being instantiated
self.write = lambda stuff: sys.stderr.write(stuff)
self.outfile = self
def __init__(self, locals=None):
"""Constructor.
The optional 'locals' argument specifies the dictionary in
which code will be executed; it defaults to a newly created
dictionary with key "__name__" set to "__console__" and key
"__doc__" set to None.
"""
tlc = {"__name__": "__py4Nezha__", "__doc__": None}
tlc['__whoami__'] = 'Nezha'
tlc['__myfriend__'] = 'Aobing'
tlc['__myparents__'] = ('Yinshiniang', 'Lijing')
tlc['__father__'] = 'Jiaozi'
if locals is None:
locals = tlc
self.locals = locals
self.compile = CommandCompiler()
def __init__(self, locals=None):
if locals is None:
locals = {'__name__': '__console__', '__doc__': None}
self.locals = locals
self.compile = CommandCompiler()
return
def __init__(self, filename):
self.filename = filename
self.compile = CommandCompiler()
from io import StringIO
from contextlib import contextmanager
from codeop import CommandCompiler
@contextmanager
def stdout_io(stdout=None):
old = sys.stdout
if stdout is None:
stdout = StringIO()
sys.stdout = stdout
yield stdout
sys.stdout = old
_compile = CommandCompiler()
def multiline_input(single_prompt=">>> ", additional_prompt="... "):
header = single_prompt
commands = []
while True:
source = input(header)
commands.append(source)
try:
all_commands = "\n".join(commands)
code = _compile(all_commands, "<dummy>", "single")
except (OverflowError, SyntaxError, ValueError):
def __init__(self,):
CommandCompiler.__init__(self)
self.compiler = MacroCompile()
def __init__(self, locals=None):
if locals is None:
locals = {"__name__": "__console__", "__doc__": None}
self.locals = locals
self.compile = CommandCompiler()
"""Utilities needed to emulate Python's interactive interpreter.
def __init__(self, ):
CommandCompiler.__init__(self)
self.compiler = MacroCompile()
def __init__(self, *args, **kwargs):
CommandCompiler.__init__(self, *args, **kwargs)
self.compiler = PyrCompile()
