class CommandCompleter(object):
def __init__(self, local_vars):
super(CommandCompleter, self).__init__()
self._locals = local_vars
self._make_completer()
self._n = 0
self._text = ''
def _make_completer(self):
l = {}
l.update(builtins.__dict__)
l.update(locals())
l.update(self._locals)
self._completer = Completer(l)
def complete_start(self, text):
self._make_completer()
self._text = text
self._n = -1
return self.complete()
def complete(self):
self._n += 1
suggest = self._completer.complete(self._text, self._n)
return suggest
def complete_back(self):
self._n -= 1
if self._n < 0:
self._n = 0
return None
suggest = self._completer.complete(self._text, self._n)
return suggest
def interact(workspace=None, banner=None, exitmsg=None, completer='standard'):
if workspace is None:
frame = sys._getframe(1)
globs = frame.f_globals
locs = frame.f_locals
workspace = globs
workspace.update(locs)
try:
import readline
if completer == 'standard':
from rlcompleter import Completer
readline.set_completer(Completer(workspace).complete)
elif completer == 'key':
from .completer import Completer
readline.set_completer_delims(' \t\n\\`@$><=;|&{(')
readline.set_completer(Completer(workspace).complete)
else:
raise AttributeError(f'Invalid completer {completer}')
readline.parse_and_bind('tab:complete')
except:
print('Could not start auto complete!')
shell = code.InteractiveConsole(workspace)
shell.interact(banner=banner, exitmsg=exitmsg)
def handle_TAB(self):
"""
Trap the TAB keystroke.
"""
necessarypart = "".join(self.lineBuffer).split(" ")[-1]
completer = Completer(globals())
if completer.complete(necessarypart, 0):
matches = list(set(completer.matches)) # has multiples
if len(matches) == 1:
length = len(necessarypart)
self.lineBuffer = self.lineBuffer[:-length]
self.lineBuffer.extend(matches[0])
self.lineBufferIndex = len(self.lineBuffer)
else:
matches.sort()
commons = self.find_common(matches)
if commons:
length = len(necessarypart)
self.lineBuffer = self.lineBuffer[:-length]
self.lineBuffer.extend(commons)
self.lineBufferIndex = len(self.lineBuffer)
self.terminal.nextLine()
while matches:
matches, part = matches[4:], matches[:4]
for item in part:
self.terminal.write("%s" % item.ljust(30))
self.terminal.write("\n")
self.terminal.nextLine()
self.terminal.eraseLine()
self.terminal.cursorBackward(self.lineBufferIndex + 5)
self.terminal.write("%s %s" % (self.ps[self.pn], "".join(self.lineBuffer)))
def __init__(self):
if hasattr(Completer, '__init__'):
Completer.__init__(self)
self.completionChar = None
self.taskpat = re.compile(r"(\?|(?:\w+))[ \t]+(?=$|[\w.<>|/~'" +r'"])')
# executive commands dictionary (must be set by user)
self.executiveDict = minmatch.MinMatchDict()
def handle_TAB(self):
necessarypart = "".join(self.lineBuffer).split(' ')[-1]
completer = Completer(globals())
if completer.complete(necessarypart, 0):
matches = list(set(completer.matches)) # has multiples
if len(matches) == 1:
length = len(necessarypart)
self.lineBuffer = self.lineBuffer[:-length]
self.lineBuffer.extend(matches[0])
self.lineBufferIndex = len(self.lineBuffer)
else:
matches.sort()
commons = self.find_common(matches)
if commons:
length = len(necessarypart)
self.lineBuffer = self.lineBuffer[:-length]
self.lineBuffer.extend(commons)
self.lineBufferIndex = len(self.lineBuffer)
self.terminal.nextLine()
while matches:
matches, part = matches[4:], matches[:4]
for item in part:
self.terminal.write('%s' % item.ljust(30))
self.terminal.write('\n')
self.terminal.nextLine()
self.terminal.eraseLine()
self.terminal.cursorBackward(self.lineBufferIndex + 5)
self.terminal.write("%s %s" %
(self.ps[self.pn], "".join(self.lineBuffer)))
def __init__(self, tabcomplete=True, spaces=True, tabwidth=2,
font=defaultFont(), bgcolor=Qt.black, textcolor=Qt.white,
startup="", silentStartup=False,
parent=None, *, catchstd=False, closeAction):
super(QPlainTextEdit, self).__init__(parent)
self.setLineWrapMode(QPlainTextEdit.NoWrap)
self.setWindowTitle(self._tr("pyTSon Console"))
self.tabcomplete = tabcomplete
self.spaces = spaces
self.tabwidth = tabwidth
self.setFont(font)
self.setContextMenuPolicy(Qt.PreventContextMenu)
p = self.palette
p.setColor(QPalette.Base, bgcolor)
p.setColor(QPalette.Text, textcolor)
self.palette = p
self.history = []
self.curhistory = -1
self.lastinp = ""
self.locked = False
self.globals = {}
self.inmulti = False
self.multi = ""
self.incmd = False
self.comp = Completer(self.globals)
self.selformat = self.currentCharFormat()
self.selformat.setBackground(Qt.white)
self.selformat.setForeground(Qt.black)
self.norformat = self.currentCharFormat()
self.closeAction = closeAction
# we have to make sure, that this runs in the same context as
# commands run from the console
self.clearlocals = list(eval("dir()", self.globals))
self.connect("destroyed()", self._resetdir)
if catchstd:
self.redirector = StdRedirector(self.appendLine)
self.stdout = sys.stdout
sys.stdout = self.redirector
self.connect("destroyed()", self._resetStdout)
else:
self.redirector = None
if os.path.isfile(startup):
with open(startup, "r") as f:
self.runCommand(f.read(), silentStartup)
self.writePrompt(self.plainText != "")
def keyPressEvent(self, event):
qt = QtCore.Qt
if event.key() == qt.Key_Tab:
line = str(self.document().lastBlock().text())[4:]
completer = Completer(self.interpreter.locals)
suggestion = completer.complete(line, 0)
if suggestion is not None:
self.insertPlainText(suggestion[len(line):])
return None
if event.key() == qt.Key_Down:
if self.historyIndex == len(self.history):
self.historyIndex -= 1
try:
if self.historyIndex > -1:
self.historyIndex -= 1
self.recallHistory()
else:
self.clearCurrentBlock()
except Exception:
pass
return None
if event.key() == qt.Key_Up:
try:
if len(self.history) - 1 > self.historyIndex:
self.historyIndex += 1
self.recallHistory()
else:
self.historyIndex = len(self.history)
except Exception:
pass
return None
if event.key() == qt.Key_Home:
# set cursor to position 4 in current block. 4 because that's where
# the marker stops
blockLength = len(self.document().lastBlock().text()[4:])
lineLength = len(self.document().toPlainText())
position = lineLength - blockLength
textCursor = self.textCursor()
textCursor.setPosition(position)
self.setTextCursor(textCursor)
return None
if event.key() in [qt.Key_Left, qt.Key_Backspace]:
# don't allow deletion of marker
if self.textCursor().positionInBlock() == 4:
return None
if event.key() in [qt.Key_Return, qt.Key_Enter]:
self.doEnter(event)
return None
# allow all other key events
super(PyInterp, self).keyPressEvent(event)
def keyPressEvent(self, event):
qt = QtCore.Qt
if event.key() == qt.Key_Tab:
line = str(self.document().lastBlock().text())[4:]
completer = Completer(self.interpreter.locals)
suggestion = completer.complete(line, 0)
if suggestion is not None:
self.insertPlainText(suggestion[len(line):])
return None
if event.key() == qt.Key_Down:
if self.historyIndex == len(self.history):
self.historyIndex -= 1
try:
if self.historyIndex > -1:
self.historyIndex -= 1
self.recallHistory()
else:
self.clearCurrentBlock()
except Exception:
pass
return None
if event.key() == qt.Key_Up:
try:
if len(self.history) - 1 > self.historyIndex:
self.historyIndex += 1
self.recallHistory()
else:
self.historyIndex = len(self.history)
except Exception:
pass
return None
if event.key() == qt.Key_Home:
# set cursor to position 4 in current block. 4 because that's where
# the marker stops
blockLength = len(self.document().lastBlock().text()[4:])
lineLength = len(self.document().toPlainText())
position = lineLength - blockLength
textCursor = self.textCursor()
textCursor.setPosition(position)
self.setTextCursor(textCursor)
return None
if event.key() in [qt.Key_Left, qt.Key_Backspace]:
# don't allow deletion of marker
if self.textCursor().positionInBlock() == 4:
return None
if event.key() in [qt.Key_Return, qt.Key_Enter]:
self.doEnter(event)
return None
# allow all other key events
super(PyInterp, self).keyPressEvent(event)
class DefaultMatcher(AbstractMatcher):
"""Default matcher: delegate to standard's `rlcompleter.Completer`` class
"""
def __init__(self, local_ctx):
self.completer = Completer(local_ctx)
def possible_matches(self, text):
if "." in text:
return self.completer.attr_matches(text)
else:
return self.completer.global_matches(text)
def __init__(self):
global completer
completer = self
if hasattr(Completer, '__init__'):
Completer.__init__(self)
self.completionChar = None
self.taskpat = re.compile(r"(\?|(?:\w+))[ \t]+(?=$|[\w.<>|/~'" +
r'"])')
# executive commands dictionary (must be set by user)
self.executiveDict = minmatch.MinMatchDict()
def loop(editor):
try:
editor.stop_async_io()
global name_space
if name_space is None:
print('\tuse :eval in a python source file to use its name_space.')
name_space = {}
else:
print()
print('\tBuffer correctly evaluated.')
print()
console = Console(locals=name_space) #, editor=editor)
try:
with local_completer:
readline.set_completer(Completer(name_space).complete)
console.interact()
except SystemExit:
pass
name_space = None
#console.save_history()
return 'normal'
finally:
editor.start_async_io()
def handle_TAB(self):
text = "".join(self.lineBuffer).split(' ')[-1]
if len(text) == 0:
# Bell character
self.terminal.write("\a")
return
completer = Completer(self.namespace)
if completer.complete(text, 0):
allMatches = list(set(completer.matches))
# Get rid of a bunch of cruft
builtins = __builtin__.keys()
matches = [
x for x in allMatches
if x.strip('(') not in builtins and "__" not in x
]
matches.sort()
# If there are no matches, ring the terminal bell
# If there's only one match, autocomplete it
# If there's more than one match, print a list of matches
if len(matches) == 0:
self.terminal.write("\a")
return
elif len(matches) == 1:
length = len(text)
self.lineBuffer = self.lineBuffer[:-length]
self.lineBuffer.extend(matches[0])
self.lineBufferIndex = len(self.lineBuffer)
else:
# Remove text before the last dot, for brevity
if "." in matches[0]:
matches = [x[x.rfind(".") + 1:] for x in matches]
self.terminal.nextLine()
self.terminal.write(repr(matches))
self.terminal.nextLine()
self.terminal.write("%s%s" % (self.ps[self.pn], ""))
self.terminal.eraseLine()
self.terminal.cursorBackward(self.lineBufferIndex + 5)
self.terminal.write("%s%s" %
(self.ps[self.pn], "".join(self.lineBuffer)))
else:
self.terminal.write("\a")
def tabComplete(self):
try:
from rlcompleter import Completer
c = Completer(self.namespace)
cmd = self.getCommand()
if "." in cmd:
matches = c.attr_matches(cmd)
else:
matches = c.global_matches(cmd)
if len(matches) == 1:
cmd = matches[0]
else:
self.appendPlainText("\t".join(matches))
self.newPrompt()
self.setCommand(cmd)
except ImportError, e:
log.error(e)
def tab_complete(self):
try:
from rlcompleter import Completer
c = Completer(self.namespace)
cmd = self.getCommand()
if "." in cmd:
matches = c.attr_matches(cmd)
else:
matches = c.global_matches(cmd)
if len(matches) == 1:
cmd = matches[0]
else:
self.appendPlainText("\t".join(matches))
self.newPrompt()
self.setCommand(cmd)
except ImportError, e:
log(e)
def _complete(text, globals_):
"""
Gets the completions for text from the exec globals. Returns a sorted
list.
"""
from rlcompleter import Completer
ctr = Completer(globals_)
i = 0
comps = []
while 1:
c = ctr.complete(text, i)
if c is None:
break
comps.append(c)
i += 1
comps = tuple(sorted(frozenset(comps)))
return comps
def complete(self,text,state):
if text.endswith(".__doc__"):
new_text = text.replace(".__doc__","")
help(eval(new_text))
readline.redisplay()
readline.insert_text(new_text)
else:
value = Completer.complete(self,text,state)
return value
def complete(self, text, state):
# Don't show all objects if we're typing in code
if self.current_prompt == sys.ps2:
if state == 0:
if text == '':
return ' '
else:
return None
return Completer.complete(self, text, state)
def attr_matches(self, text):
"""Compute matches when text contains a dot."""
line = self.get_line_buffer()
if line == text:
# at start of line, special handling for iraf.xxx and
# taskname.xxx
fields = text.split(".")
if fields[0] == "":
# line starts with dot, look in executive commands
return self.executive_matches(text)
elif fields[0] == "iraf":
return self.taskdot_matches(fields)
elif iraf.getTask(fields[0], found=1):
# include both eval results and task. matches
fields.insert(0, 'iraf')
matches = self.taskdot_matches(fields)
try:
matches.extend(Completer.attr_matches(self, text))
except KeyboardInterrupt:
raise
except:
pass
return matches
else:
return Completer.attr_matches(self, text)
else:
# Check first character following initial alphabetic string
# If next char is alphabetic (or null) use filename matches
# Otherwise use matches from Python dictionaries
# XXX need to make this consistent with the other places
# XXX where same tests are done
m = self.taskpat.match(line)
if m is None or keyword.iskeyword(m.group(1)):
fields = text.split(".")
if fields[0] == "iraf":
return self.taskdot_matches(fields)
else:
return Completer.attr_matches(self, text)
else:
# XXX Could try to match pset.param keywords too?
lt = len(line) - len(text)
return self.filename_matches(text, line[:lt])
def attr_matches(self, text):
"""Compute matches when text contains a dot."""
line = self.get_line_buffer()
if line == text:
# at start of line, special handling for iraf.xxx and
# taskname.xxx
fields = string.split(text,".")
if fields[0] == "":
# line starts with dot, look in executive commands
return self.executive_matches(text)
elif fields[0] == "iraf":
return self.taskdot_matches(fields)
elif iraf.getTask(fields[0], found=1):
# include both eval results and task. matches
fields.insert(0, 'iraf')
matches = self.taskdot_matches(fields)
try:
matches.extend(Completer.attr_matches(self,text))
except KeyboardInterrupt:
raise
except:
pass
return matches
else:
return Completer.attr_matches(self,text)
else:
# Check first character following initial alphabetic string
# If next char is alphabetic (or null) use filename matches
# Otherwise use matches from Python dictionaries
#XXX need to make this consistent with the other places
#XXX where same tests are done
m = self.taskpat.match(line)
if m is None or keyword.iskeyword(m.group(1)):
fields = string.split(text,".")
if fields[0] == "iraf":
return self.taskdot_matches(fields)
else:
return Completer.attr_matches(self,text)
else:
#XXX Could try to match pset.param keywords too?
lt = len(line)-len(text)
return self.filename_matches(text, line[:lt])
def getSuggestions(self, line):
from rlcompleter import Completer
def _inRange(i):
if MAX_COMPLETIONS <= 0:
# No limit
return True
else:
return i <= MAX_COMPLETIONS
result = []
completer = Completer(self.globals)
i = 0
suggestion = True
while suggestion and _inRange(i):
suggestion = completer.complete(line, i)
if suggestion:
if i == MAX_COMPLETIONS and MAX_COMPLETIONS != 0:
result.append('...')
else:
if suggestion not in result:
result.append(suggestion)
i += 1
return result
def initialize_completer():
global ip_completer, p_completer
try:
__IPYTHON__
from IPython.core.completer import IPCompleter
ip = get_ipython()
ip_completer = IPCompleter(ip, global_namespace=global_dict)
except NameError:
try:
from rlcompleter import Completer
p_completer = Completer(namespace=global_dict)
except:
pass
def getSuggestions(self, line):
from rlcompleter import Completer
def _inRange(i):
if MAX_COMPLETIONS <= 0:
# No limit
return True
else:
return i <= MAX_COMPLETIONS
result = []
completer = Completer(self.globals)
i = 0
suggestion = True
while suggestion and _inRange(i):
suggestion = completer.complete(line, i)
if suggestion:
if i == MAX_COMPLETIONS and MAX_COMPLETIONS != 0:
result.append('...')
else:
if suggestion not in result:
result.append(suggestion)
i += 1
return result
class CommandCompleter(object):
def __init__(self, local_vars):
super(CommandCompleter, self).__init__()
self._locals = local_vars
self._make_completer()
self._n = 0
self._text = ''
def _make_completer(self):
l = {}
l.update(builtins.__dict__)
l.update(locals())
l.update(self._locals)
self._completer = Completer(l)
def complete_start(self, text):
self._make_completer()
self._text = text
self._n = -1
return self.complete()
def complete(self):
self._n += 1
suggest = self._completer.complete(self._text, self._n)
return suggest
def complete_back(self):
self._n -= 1
if self._n < 0:
self._n = 0
return None
suggest = self._completer.complete(self._text, self._n)
return suggest
def shell():
"""
Run an interactive Python shell in the context of a given
navycut application. The application will populate the default
namespace of this shell according to its configuration.
This is useful for executing small snippets of management code
without having to manually configure the application.
"""
import code
from flask.globals import _app_ctx_stack
_app: t.Type["Navycut"] = _app_ctx_stack.top.app
banner = (f"Python {sys.version} on {sys.platform}\n"
f"Project: {_app.config.get('PROJECT_NAME')} \n"
f"Debug mode: {'on' if _app.debug else 'off'}\n"
f"Instance: {_app.instance_path}\n"
"(InteractiveConsole)")
ctx: dict = dict()
# Support the regular Python interpreter startup script if someone
# is using it.
startup = environ.get("PYTHONSTARTUP")
if startup and path.isfile(startup):
with open(startup) as f:
eval(compile(f.read(), startup, "exec"), ctx)
ctx.update(app.make_shell_context())
# Site, customize, or startup script can set a hook to call when
# entering interactive mode. The default one sets up readline with
# tab and history completion.
interactive_hook = getattr(sys, "__interactivehook__", None)
if interactive_hook is not None:
try:
import readline
from rlcompleter import Completer
except ImportError:
pass
else:
# rlcompleter uses __main__.__dict__ by default, which is
# flask.__main__. Use the shell context instead.
readline.set_completer(Completer(ctx).complete)
interactive_hook()
code.interact(banner=banner, local=ctx)
def __init__(self, workspace=None):
self.wsdict = dict() if workspace is None else workspace
self.ws = DictStruct(self.wsdict)
Shell.instance = self
self.wsdict['shell'] = self
self.wsdict['gui'] = gui
self.wsdict['use'] = use
self.wsdict['__name__'] = '__main__'
self.redirect_stdout()
self.redirect_input()
self.comp = Completer(self.wsdict)
self.interpreters = dict()
self.logdir = LogDir(config['path_log'])
self.bootpath = Path('.').resolve()
class InteractiveConsole(BaseInteractiveConsole):
def __init__(self, ls):
BaseInteractiveConsole.__init__(self, ls)
self.stdout = sys.stdout = sys.stderr = Stdout()
self.completer = Completer(dict(self.locals))
def push(self, line):
result = BaseInteractiveConsole.push(self, line)
return (result, self.stdout.get_buffer())
def complete(self, text):
state = 0
comps = []
while True:
self.completer.namespace = dict(self.locals)
result = self.completer.complete(text, state)
if result is None:
break
comps.append(result)
state += 1
return comps
def dbshell(args):
from app.models import User # noqa
if args.ipython:
try:
from IPython import embed
embed()
except ImportError:
print("You need to install IPython")
sys.exit(1)
else:
import readline
from rlcompleter import Completer
readline.parse_and_bind("tab: complete")
import code
variables = globals().copy()
variables.update(locals())
readline.set_completer(Completer(variables).complete)
shell = code.InteractiveConsole(variables)
shell.interact()
def main(args):
if args.filter:
pkt_filter = ' '.join(args.filter)
else:
pkt_filter = None
pkts = sniff(iface=args.iface,
filter=pkt_filter,
count=args.count,
prn=pkt_callback)
if args.interact:
vars = globals()
vars.update(locals())
set_completer(Completer(vars).complete)
parse_and_bind("tab: complete")
InteractiveConsole(vars).interact()
def complete(self, text, state):
if text == '':
# you could replace ' ' to \t if you indent via tab
return [' ', None][state]
elif text.count("'") == 1:
if not state:
self.file_matches(text, "'")
try:
return self.matches[state]
except IndexError:
return None
elif text.count('"') == 1:
if not state:
self.file_matches(text, '"')
try:
return self.matches[state]
except IndexError:
return None
else:
return Completer.complete(self, text, state)
def complete(self, text, state):
if text == '':
# you could replace ' ' to \t if you indent via tab
return [' ', None][state]
elif text.count("'") == 1:
if not state:
self.file_matches(text, "'")
try:
return self.matches[state]
except IndexError:
return None
elif text.count('"') == 1:
if not state:
self.file_matches(text, '"')
try:
return self.matches[state]
except IndexError:
return None
else:
return Completer.complete(self, text, state)
def secondary_matches(self, text, line):
"""Compute matches for tokens when not at start of line"""
# Check first character following initial alphabetic string.
# If next char is alphabetic (or null) use filename matches.
# Also use filename matches if line starts with '!'.
# Otherwise use matches from Python dictionaries.
lt = len(line) - len(text)
if line[:1] == "!":
# Matching filename for OS escapes
# Ideally would use tcsh-style matching of commands
# as first argument, but that looks unreasonably hard
return self.filename_matches(text, line[:lt])
m = self.taskpat.match(line)
if m is None or keyword.iskeyword(m.group(1)):
if line[lt - 1:lt] in ['"', "'"]:
# use filename matches for quoted strings
return self.filename_matches(text, line[:lt])
else:
if not hasattr(self, "namespace"):
self.namespace = {}
return Completer.global_matches(self, text)
else:
taskname = m.group(1)
# check for pipe/redirection using last non-blank character
mpipe = re.search(r"[|><][ \t]*$", line[:lt])
if mpipe:
s = mpipe.group(0)
if s[0] == "|":
# pipe -- use task matches
return iraf.getAllMatches(text)
else:
# redirection -- just match filenames
return self.filename_matches(text, line[:lt])
elif taskname in taskArgDict:
# task takes task names as arguments
return iraf.getAllTasks(text)
elif taskname in pkgArgDict:
# task takes package names as arguments
return iraf.getAllPkgs(text)
else:
return self.argument_matches(text, taskname, line)
def attr_matches(self, text):
"""
Compute matches when text contains a dot.
"""
matches = []
for name in Completer.attr_matches(self, text):
if name.endswith("__roles__"):
continue
component = name.split('.')[-1]
if component in self.ignored_names:
continue
ignore = False
for prefix in self.ignored_prefixes:
if component.startswith(prefix):
ignore = True
break
if not ignore:
matches.append(name)
return matches
def secondary_matches(self, text, line):
"""Compute matches for tokens when not at start of line"""
# Check first character following initial alphabetic string.
# If next char is alphabetic (or null) use filename matches.
# Also use filename matches if line starts with '!'.
# Otherwise use matches from Python dictionaries.
lt = len(line)-len(text)
if line[:1] == "!":
# Matching filename for OS escapes
# Ideally would use tcsh-style matching of commands
# as first argument, but that looks unreasonably hard
return self.filename_matches(text, line[:lt])
m = self.taskpat.match(line)
if m is None or keyword.iskeyword(m.group(1)):
if line[lt-1:lt] in ['"', "'"]:
# use filename matches for quoted strings
return self.filename_matches(text, line[:lt])
else:
return Completer.global_matches(self,text)
else:
taskname = m.group(1)
# check for pipe/redirection using last non-blank character
mpipe = re.search(r"[|><][ \t]*$", line[:lt])
if mpipe:
s = mpipe.group(0)
if s[0] == "|":
# pipe -- use task matches
return iraf.getAllMatches(text)
else:
# redirection -- just match filenames
return self.filename_matches(text, line[:lt])
elif taskArgDict.has_key(taskname):
# task takes task names as arguments
return iraf.getAllTasks(text)
elif pkgArgDict.has_key(taskname):
# task takes package names as arguments
return iraf.getAllPkgs(text)
else:
return self.argument_matches(text, taskname, line)
def keyboard_on_key_down(self, window, keycode, text, modifiers):
'''Override of _keyboard_on_key_down.
'''
if keycode[0] == 9 and Completer:
# tab, add autocomplete suggestion
txt = self.text[self._cursor_pos:]
if txt.strip():
suggestion = Completer(self.sh.locals).complete(txt, 0)
if suggestion:
self.select_text(self._cursor_pos,
self._cursor_pos + len(txt))
self.delete_selection()
Clock.schedule_once(partial(self.insert_text, suggestion))
return False
elif keycode[0] == 13:
# For enter
self.last_line = self.text[self._cursor_pos:]
self.dispatch('on_ready_to_input')
return super(InteractiveShellInput,
self).keyboard_on_key_down(window, keycode, text,
modifiers)
def __init__(self, locals: Dict[str, object], banner=banner):
Gtk.ScrolledWindow.__init__(self)
self.locals = locals
locals["help"] = Help()
self.set_min_content_width(640)
self.set_min_content_height(480)
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.text = Gtk.TextView()
self.text.set_wrap_mode(True)
self.text.set_monospace(True)
self.text.set_border_width(4)
self.interpreter = code.InteractiveInterpreter(locals)
self.completer = Completer(locals)
self.buffer: List[str] = []
self.history: List[str] = []
self.banner = banner
self.ps1 = ">>> "
self.ps2 = "... "
self.text.add_events(Gdk.EventMask.KEY_PRESS_MASK)
self.text.connect("key_press_event", self.key_pressed)
self.current_history = -1
self.mark = self.text.get_buffer().create_mark(
"End", self.text.get_buffer().get_end_iter(), False
)
# setup colors
self.style_banner = Gtk.TextTag.new("banner")
self.style_banner.set_property("foreground", "saddle brown")
self.style_ps1 = Gtk.TextTag.new("ps1")
self.style_ps1.set_property("foreground", "DarkOrchid4")
self.style_ps1.set_property("editable", False)
self.style_ps2 = Gtk.TextTag.new("ps2")
self.style_ps2.set_property("foreground", "DarkOliveGreen")
self.style_ps2.set_property("editable", False)
self.style_out = Gtk.TextTag.new("stdout")
self.style_out.set_property("foreground", "midnight blue")
self.style_out.set_property("editable", False)
self.style_err = Gtk.TextTag.new("stderr")
self.style_err.set_property("style", Pango.Style.ITALIC)
self.style_err.set_property("foreground", "red")
self.style_err.set_property("editable", False)
self.text.get_buffer().get_tag_table().add(self.style_banner)
self.text.get_buffer().get_tag_table().add(self.style_ps1)
self.text.get_buffer().get_tag_table().add(self.style_ps2)
self.text.get_buffer().get_tag_table().add(self.style_out)
self.text.get_buffer().get_tag_table().add(self.style_err)
self.stdout = TextViewWriter("stdout", self.text, self.style_out)
self.stderr = TextViewWriter("stderr", self.text, self.style_err)
self.current_prompt = lambda: ""
self.add(self.text)
self.text.show()
self.write_line(self.banner, self.style_banner)
self.prompt_ps1()
class GTKInterpreterConsole(Gtk.ScrolledWindow):
"""
An InteractiveConsole for GTK. It's an actual widget,
so it can be dropped in just about anywhere.
"""
__gtype_name__ = "GTKInterpreterConsole"
def __init__(self, locals: Dict[str, object], banner=banner):
Gtk.ScrolledWindow.__init__(self)
self.locals = locals
locals["help"] = Help()
self.set_min_content_width(640)
self.set_min_content_height(480)
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.text = Gtk.TextView()
self.text.set_wrap_mode(True)
self.text.set_monospace(True)
self.text.set_border_width(4)
self.interpreter = code.InteractiveInterpreter(locals)
self.completer = Completer(locals)
self.buffer: List[str] = []
self.history: List[str] = []
self.banner = banner
self.ps1 = ">>> "
self.ps2 = "... "
self.text.add_events(Gdk.EventMask.KEY_PRESS_MASK)
self.text.connect("key_press_event", self.key_pressed)
self.current_history = -1
self.mark = self.text.get_buffer().create_mark(
"End", self.text.get_buffer().get_end_iter(), False
)
# setup colors
self.style_banner = Gtk.TextTag.new("banner")
self.style_banner.set_property("foreground", "saddle brown")
self.style_ps1 = Gtk.TextTag.new("ps1")
self.style_ps1.set_property("foreground", "DarkOrchid4")
self.style_ps1.set_property("editable", False)
self.style_ps2 = Gtk.TextTag.new("ps2")
self.style_ps2.set_property("foreground", "DarkOliveGreen")
self.style_ps2.set_property("editable", False)
self.style_out = Gtk.TextTag.new("stdout")
self.style_out.set_property("foreground", "midnight blue")
self.style_out.set_property("editable", False)
self.style_err = Gtk.TextTag.new("stderr")
self.style_err.set_property("style", Pango.Style.ITALIC)
self.style_err.set_property("foreground", "red")
self.style_err.set_property("editable", False)
self.text.get_buffer().get_tag_table().add(self.style_banner)
self.text.get_buffer().get_tag_table().add(self.style_ps1)
self.text.get_buffer().get_tag_table().add(self.style_ps2)
self.text.get_buffer().get_tag_table().add(self.style_out)
self.text.get_buffer().get_tag_table().add(self.style_err)
self.stdout = TextViewWriter("stdout", self.text, self.style_out)
self.stderr = TextViewWriter("stderr", self.text, self.style_err)
self.current_prompt = lambda: ""
self.add(self.text)
self.text.show()
self.write_line(self.banner, self.style_banner)
self.prompt_ps1()
def reset_history(self):
self.history = []
def reset_buffer(self):
self.buffer = []
def prompt_ps1(self):
self.current_prompt = self.prompt_ps1
self.write_line(self.ps1, self.style_ps1)
def prompt_ps2(self):
self.current_prompt = self.prompt_ps2
self.write_line(self.ps2, self.style_ps2)
def write_line(self, text, style=None):
start, end = self.text.get_buffer().get_bounds()
if style:
self.text.get_buffer().insert_with_tags(end, text, style)
else:
self.text.get_buffer().insert(end, text)
self.text.scroll_to_mark(self.mark, 0, True, 1, 1)
def push(self, line):
self.buffer.append(line)
if len(line) > 0:
self.history.append(line)
source = "\n".join(self.buffer)
with self.stdout, self.stderr:
more = self.interpreter.runsource(source, "<<console>>")
if not more:
self.reset_buffer()
return more
def key_pressed(self, widget, event):
if event.keyval == Gdk.keyval_from_name("Return"):
return self.execute_line()
if event.keyval == Gdk.keyval_from_name("Tab"):
return self.complete_line()
if event.keyval == Gdk.keyval_from_name("Up"):
self.current_history = self.current_history - 1
if self.current_history < -len(self.history):
self.current_history = -len(self.history)
return self.show_history()
if event.keyval == Gdk.keyval_from_name("Down"):
self.current_history = self.current_history + 1
if self.current_history > 0:
self.current_history = 0
return self.show_history()
ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
if (event.keyval == Gdk.keyval_from_name("Home")) or (
ctrl and event.keyval == Gdk.KEY_a
):
line_count = self.text.get_buffer().get_line_count() - 1
start = self.text.get_buffer().get_iter_at_line_offset(line_count, 4)
self.text.get_buffer().place_cursor(start)
return True
if ctrl and event.keyval == Gdk.KEY_e:
end = self.text.get_buffer().get_end_iter()
self.text.get_buffer().place_cursor(end)
return True
return False
def show_history(self):
if self.current_history != 0:
self.replace_line(self.history[self.current_history])
return True
def current_line(self):
start, end = self.current_line_bounds()
return self.text.get_buffer().get_text(start, end, True)
def current_line_bounds(self):
txt_buffer = self.text.get_buffer()
line_count = txt_buffer.get_line_count() - 1
start = txt_buffer.get_iter_at_line(line_count)
if start.get_chars_in_line() >= 4:
start.forward_chars(4)
end = txt_buffer.get_end_iter()
return start, end
def replace_line(self, txt):
start, end = self.current_line_bounds()
self.text.get_buffer().delete(start, end)
self.write_line(txt)
def execute_line(self):
line = self.current_line()
self.write_line("\n")
more = self.push(line)
self.text.get_buffer().place_cursor(self.text.get_buffer().get_end_iter())
if more:
self.prompt_ps2()
else:
self.prompt_ps1()
self.current_history = 0
return True
def complete_line(self):
line = self.current_line()
tokens = line.split()
if tokens:
token = tokens[-1]
completions: List[str] = []
p = self.completer.complete(token, len(completions))
while p:
assert p
completions.append(p)
p = self.completer.complete(token, len(completions))
else:
completions = list(self.locals.keys())
if len(completions) > 1:
max_len = max(map(len, completions)) + 2
per_line = 80 // max_len
for i, c in enumerate(completions):
if i % per_line == 0:
self.write_line("\n")
self.write_line(c, self.style_ps1)
self.write_line(" " * (max_len - len(c)), self.style_ps1)
self.write_line("\n")
self.current_prompt()
self.write_line(line)
elif len(completions) == 1:
i = line.rfind(token)
line = line[0:i] + completions[0]
self.replace_line(line)
return True
def handle_TAB1(self):
head_line, tail_line = self.currentLineBuffer()
search_line = head_line
completer = Completer(self.namespace)
def find_term(line):
chrs = []
attr = False
for c in reversed(line):
if c == '.':
attr = True
if not c.isalnum() and c not in ('_', '.'):
break
chrs.insert(0, c)
return ''.join(chrs), attr
search_term, attrQ = find_term(search_line)
if not search_term:
return manhole.Manhole.handle_TAB(self)
if attrQ:
matches = completer.attr_matches(search_term)
matches = list(set(matches))
matches.sort()
else:
matches = completer.global_matches(search_term)
def same(*args):
if len(set(args)) == 1:
return args[0]
return False
def progress(rem):
letters = []
while True:
letter = same(*[elm.pop(0) for elm in rem if elm])
if letter:
letters.append(letter)
else:
return letters
if matches is not None:
rem = [list(s.partition(search_term)[2]) for s in matches]
more_letters = progress(rem)
# print 'LEN MATCHES', len(matches), more_letters
# if len(matches) == 1:
# length = len(search_line)
# self.lineBuffer = self.lineBuffer[:-length]
# self.lineBuffer.extend([matches[0]]+more_letters)
# self.lineBufferIndex = len(self.lineBuffer)
if len(matches) > 1:
match_str = "%s \t\t" * len(matches) % tuple(matches)
match_rows = text.greedyWrap(match_str)
# line = self.lineBuffer
self.terminal.nextLine()
self.terminal.saveCursor()
for row in match_rows:
self.addOutput(row, True)
if tail_line:
self.terminal.cursorBackward(len(tail_line))
self.lineBufferIndex -= len(tail_line)
# self.addOutput("".join(more_letters), True)
self._deliverBuffer(more_letters)
def init_completer(selfi, locals):
completer = Completer(locals)
readline.set_completer(completer.complete)
readline.parse_and_bind("tab: complete")
def _make_completer(self):
l = {}
l.update(builtins.__dict__)
l.update(locals())
l.update(self._locals)
self._completer = Completer(l)
def __init__(self,
tabcomplete=True,
spaces=True,
tabwidth=2,
font=defaultFont(),
bgcolor=Qt.black,
textcolor=Qt.white,
width=800,
height=600,
startup="",
silentStartup=False,
parent=None,
*,
catchstd=False):
super(QPlainTextEdit, self).__init__(parent)
self.setLineWrapMode(QPlainTextEdit.NoWrap)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle(self._tr("pyTSon Console"))
self.tabcomplete = tabcomplete
self.spaces = spaces
self.tabwidth = tabwidth
self.setFont(font)
self.resize(width, height)
self.setContextMenuPolicy(Qt.PreventContextMenu)
p = self.palette
p.setColor(QPalette.Base, bgcolor)
p.setColor(QPalette.Text, textcolor)
self.palette = p
self.history = []
self.curhistory = -1
self.lastinp = ""
self.locked = False
self.globals = {}
self.inmulti = False
self.multi = ""
self.incmd = False
self.comp = Completer(self.globals)
self.selformat = self.currentCharFormat()
self.selformat.setBackground(Qt.white)
self.selformat.setForeground(Qt.black)
self.norformat = self.currentCharFormat()
if catchstd:
self.redirector = StdRedirector(self.appendLine)
self.stdout = sys.stdout
sys.stdout = self.redirector
self.connect("destroyed()", self._resetStdout)
else:
self.redirector = None
if os.path.isfile(startup):
with open(startup, "r") as f:
self.runCommand(f.read(), silentStartup)
self.writePrompt(self.plainText != "")
class GTKInterpreterConsole(Gtk.ScrolledWindow):
"""
An InteractiveConsole for GTK. It's an actual widget,
so it can be dropped in just about anywhere.
"""
__gtype_name__ = "GTKInterpreterConsole"
def __init__(self, locals=None, banner=banner):
Gtk.ScrolledWindow.__init__(self)
self.set_min_content_width(640)
self.set_min_content_height(480)
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.text = Gtk.TextView()
self.text.set_wrap_mode(True)
self.text.set_monospace(True)
self.text.set_border_width(4)
self.interpreter = code.InteractiveInterpreter(locals)
self.interpreter.locals["help"] = Help()
self.completer = Completer(self.interpreter.locals)
self.buffer = []
self.history = []
self.banner = banner
self.ps1 = ">>> "
self.ps2 = "... "
self.text.add_events(Gdk.EventMask.KEY_PRESS_MASK)
self.text.connect("key_press_event", self.key_pressed)
self.current_history = -1
self.mark = self.text.get_buffer().create_mark(
"End", self.text.get_buffer().get_end_iter(), False
)
# setup colors
self.style_banner = Gtk.TextTag.new("banner")
self.style_banner.set_property("foreground", "saddle brown")
self.style_ps1 = Gtk.TextTag.new("ps1")
self.style_ps1.set_property("foreground", "DarkOrchid4")
self.style_ps1.set_property("editable", False)
self.style_ps2 = Gtk.TextTag.new("ps2")
self.style_ps2.set_property("foreground", "DarkOliveGreen")
self.style_ps2.set_property("editable", False)
self.style_out = Gtk.TextTag.new("stdout")
self.style_out.set_property("foreground", "midnight blue")
self.style_out.set_property("editable", False)
self.style_err = Gtk.TextTag.new("stderr")
self.style_err.set_property("style", Pango.Style.ITALIC)
self.style_err.set_property("foreground", "red")
self.style_err.set_property("editable", False)
self.text.get_buffer().get_tag_table().add(self.style_banner)
self.text.get_buffer().get_tag_table().add(self.style_ps1)
self.text.get_buffer().get_tag_table().add(self.style_ps2)
self.text.get_buffer().get_tag_table().add(self.style_out)
self.text.get_buffer().get_tag_table().add(self.style_err)
self.stdout = TextViewWriter("stdout", self.text, self.style_out)
self.stderr = TextViewWriter("stderr", self.text, self.style_err)
self.current_prompt = None
self.add(self.text)
self.text.show()
self.write_line(self.banner, self.style_banner)
GLib.idle_add(self.prompt_ps1)
def reset_history(self):
self.history = []
def reset_buffer(self):
self.buffer = []
def prompt_ps1(self):
self.current_prompt = self.prompt_ps1
self.write_line(self.ps1, self.style_ps1)
def prompt_ps2(self):
self.current_prompt = self.prompt_ps2
self.write_line(self.ps2, self.style_ps2)
def write_line(self, text, style=None):
start, end = self.text.get_buffer().get_bounds()
if style:
self.text.get_buffer().insert_with_tags(end, text, style)
else:
self.text.get_buffer().insert(end, text)
self.text.scroll_to_mark(self.mark, 0, True, 1, 1)
def push(self, line):
self.buffer.append(line)
if len(line) > 0:
self.history.append(line)
source = "\n".join(self.buffer)
with self.stdout, self.stderr:
more = self.interpreter.runsource(source, "<<console>>")
if not more:
self.reset_buffer()
return more
def key_pressed(self, widget, event):
if event.keyval == Gdk.keyval_from_name("Return"):
return self.execute_line()
if event.keyval == Gdk.keyval_from_name("Tab"):
return self.complete_line()
if event.keyval == Gdk.keyval_from_name("Up"):
self.current_history = self.current_history - 1
if self.current_history < -len(self.history):
self.current_history = -len(self.history)
return self.show_history()
if event.keyval == Gdk.keyval_from_name("Down"):
self.current_history = self.current_history + 1
if self.current_history > 0:
self.current_history = 0
return self.show_history()
ctrl = event.state & Gdk.ModifierType.CONTROL_MASK
if (event.keyval == Gdk.keyval_from_name("Home")) or (
ctrl and event.keyval == Gdk.KEY_a
):
l = self.text.get_buffer().get_line_count() - 1
start = self.text.get_buffer().get_iter_at_line_offset(l, 4)
self.text.get_buffer().place_cursor(start)
return True
if ctrl and event.keyval == Gdk.KEY_e:
end = self.text.get_buffer().get_end_iter()
self.text.get_buffer().place_cursor(end)
return True
return False
def show_history(self):
if self.current_history == 0:
return True
else:
self.replace_line(self.history[self.current_history])
return True
def current_line(self):
start, end = self.current_line_bounds()
return self.text.get_buffer().get_text(start, end, True)
def current_line_bounds(self):
txt_buffer = self.text.get_buffer()
l = txt_buffer.get_line_count() - 1
start = txt_buffer.get_iter_at_line(l)
if start.get_chars_in_line() >= 4:
start.forward_chars(4)
end = txt_buffer.get_end_iter()
return start, end
def replace_line(self, txt):
start, end = self.current_line_bounds()
self.text.get_buffer().delete(start, end)
self.write_line(txt)
def execute_line(self):
line = self.current_line()
self.write_line("\n")
more = self.push(line)
self.text.get_buffer().place_cursor(self.text.get_buffer().get_end_iter())
if more:
self.prompt_ps2()
else:
self.prompt_ps1()
self.current_history = 0
return True
def complete_line(self):
line = self.current_line()
tokens = line.split()
if tokens:
token = tokens[-1]
completions = []
p = self.completer.complete(token, len(completions))
while p != None:
completions.append(p)
p = self.completer.complete(token, len(completions))
else:
completions = list(self.interpreter.locals.keys())
if len(completions) > 1:
max_len = max(map(len, completions)) + 2
per_line = 80 // max_len
for i, c in enumerate(completions):
if i % per_line == 0:
self.write_line("\n")
self.write_line(c, self.style_ps1)
self.write_line(" " * (max_len - len(c)), self.style_ps1)
self.write_line("\n")
self.current_prompt()
self.write_line(line)
elif len(completions) == 1:
i = line.rfind(token)
line = line[0:i] + completions[0]
self.replace_line(line)
return True
def keyPressEvent(self, event):
qt = QtCore.Qt
if event.key() == qt.Key_Tab:
line = str(self.document().lastBlock().text())[4:]
completer = Completer(self.interpreter.locals)
suggestion = completer.complete(line, 0)
if suggestion is not None:
self.insertPlainText(suggestion[len(line):])
return None
if event.key() == qt.Key_Down:
if self.historyIndex == len(self.history):
self.historyIndex -= 1
try:
if self.historyIndex > -1:
self.historyIndex -= 1
self.recallHistory()
else:
self.clearCurrentBlock()
except:
pass
return None
if event.key() == qt.Key_Up:
try:
if len(self.history) - 1 > self.historyIndex:
self.historyIndex += 1
self.recallHistory()
else:
self.historyIndex = len(self.history)
except:
pass
return None
if event.key() == qt.Key_Home:
# set cursor to position 4 in current block. 4 because that's where
# the marker stops
blockLength = len(self.document().lastBlock().text()[4:])
lineLength = len(self.document().toPlainText())
position = lineLength - blockLength
textCursor = self.textCursor()
textCursor.setPosition(position)
self.setTextCursor(textCursor)
return None
if event.key() in [qt.Key_Left, qt.Key_Backspace]:
# don't allow deletion of marker
if self.textCursor().positionInBlock() == 4:
return None
if event.key() in [qt.Key_Return, qt.Key_Enter]:
# set cursor to end of line to avoid line splitting
textCursor = self.textCursor()
position = len(self.document().toPlainText())
textCursor.setPosition(position)
self.setTextCursor(textCursor)
line = str(self.document().lastBlock().text())[4:] # remove marker
line.rstrip()
self.historyIndex = -1
if self.customCommands(line):
return None
else:
try:
# pylint: disable=pointless-statement
line[-1]
self.haveLine = True
if line[-1] == ':':
self.multiLine = True
self.history.insert(0, line)
except:
self.haveLine = False
if self.haveLine and self.multiLine: # multi line command
self.command += line + '\n' # + command and line
self.append('') # move down one line
self.marker() # handle marker style
return None
if self.haveLine and not self.multiLine: # one line command
self.command = line # line is the command
self.append('') # move down one line
self.interpreter.runIt(self.command)
self.command = '' # clear command
self.marker() # handle marker style
return None
if self.multiLine and not self.haveLine: # multi line done
self.append('') # move down one line
self.interpreter.runIt(self.command)
self.command = '' # clear command
self.multiLine = False # back to single line
self.marker() # handle marker style
return None
if not self.haveLine and not self.multiLine: # just enter
self.append('')
self.marker()
return None
return None
# allow all other key events
super(PyInterp, self).keyPressEvent(event)
def __init__(self, locals=None, banner=banner):
Gtk.ScrolledWindow.__init__(self)
self.set_min_content_width(640)
self.set_min_content_height(480)
self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
self.text = Gtk.TextView()
self.text.set_wrap_mode(True)
self.text.set_monospace(True)
self.text.set_border_width(4)
self.interpreter = code.InteractiveInterpreter(locals)
self.interpreter.locals["help"] = Help()
self.completer = Completer(self.interpreter.locals)
self.buffer = []
self.history = []
self.banner = banner
self.ps1 = ">>> "
self.ps2 = "... "
self.text.add_events(Gdk.EventMask.KEY_PRESS_MASK)
self.text.connect("key_press_event", self.key_pressed)
self.current_history = -1
self.mark = self.text.get_buffer().create_mark(
"End", self.text.get_buffer().get_end_iter(), False
)
# setup colors
self.style_banner = Gtk.TextTag.new("banner")
self.style_banner.set_property("foreground", "saddle brown")
self.style_ps1 = Gtk.TextTag.new("ps1")
self.style_ps1.set_property("foreground", "DarkOrchid4")
self.style_ps1.set_property("editable", False)
self.style_ps2 = Gtk.TextTag.new("ps2")
self.style_ps2.set_property("foreground", "DarkOliveGreen")
self.style_ps2.set_property("editable", False)
self.style_out = Gtk.TextTag.new("stdout")
self.style_out.set_property("foreground", "midnight blue")
self.style_out.set_property("editable", False)
self.style_err = Gtk.TextTag.new("stderr")
self.style_err.set_property("style", Pango.Style.ITALIC)
self.style_err.set_property("foreground", "red")
self.style_err.set_property("editable", False)
self.text.get_buffer().get_tag_table().add(self.style_banner)
self.text.get_buffer().get_tag_table().add(self.style_ps1)
self.text.get_buffer().get_tag_table().add(self.style_ps2)
self.text.get_buffer().get_tag_table().add(self.style_out)
self.text.get_buffer().get_tag_table().add(self.style_err)
self.stdout = TextViewWriter("stdout", self.text, self.style_out)
self.stderr = TextViewWriter("stderr", self.text, self.style_err)
self.current_prompt = None
self.add(self.text)
self.text.show()
self.write_line(self.banner, self.style_banner)
GLib.idle_add(self.prompt_ps1)
sys.path.insert(0, '/home/vsharma/temp/audio/build/lib.linux-x86_64-3.5')
#Python2
#sys.path.insert(0,'/home/vsharma/temp/audio/build/lib.linux-x86_64-2.7')
# For audio preprocessing
import numpy as np
from scipy.io import wavfile
from scipy.signal import resample
import librosa
import torchaudio
import readline
from rlcompleter import Completer
readline.parse_and_bind("tab: complete")
readline.set_completer(Completer(locals()).complete)
##############
#
# Example : CUDA_VISIBLE_DEVICES=2 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=0 --end_movie_num=1
# krenew -b -- screen -Dm -fn
# screen -r
# cd /home/vsharma/Documents/Audio_Visual_Text
# source ~/.bashrc
# CUDA_VISIBLE_DEVICES=0 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=0 --end_movie_num=25
# CUDA_VISIBLE_DEVICES=0 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=25 --end_movie_num=50
# CUDA_VISIBLE_DEVICES=1 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=50 --end_movie_num=75
# CUDA_VISIBLE_DEVICES=1 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=75 --end_movie_num=100
# CUDA_VISIBLE_DEVICES=2 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=100 --end_movie_num=125
# CUDA_VISIBLE_DEVICES=2 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=125 --end_movie_num=150
# CUDA_VISIBLE_DEVICES=3 python3.5 Audio_Visual_Place_Temporal.py --start_movie_num=150 --end_movie_num=175
def __init__(self, ls):
BaseInteractiveConsole.__init__(self, ls)
self.stdout = sys.stdout = sys.stderr = Stdout()
self.completer = Completer(dict(self.locals))
def __init__(self): Completer.__init__(self)
def _make_completer(self):
l = {}
l.update(builtins.__dict__)
l.update(locals())
l.update(self._locals)
self._completer = Completer(l)
class PythonConsole(QPlainTextEdit, pytson.Translatable):
def __init__(self, tabcomplete=True, spaces=True, tabwidth=2,
font=defaultFont(), bgcolor=Qt.black, textcolor=Qt.white,
startup="", silentStartup=False,
parent=None, *, catchstd=False, closeAction):
super(QPlainTextEdit, self).__init__(parent)
self.setLineWrapMode(QPlainTextEdit.NoWrap)
self.setWindowTitle(self._tr("pyTSon Console"))
self.tabcomplete = tabcomplete
self.spaces = spaces
self.tabwidth = tabwidth
self.setFont(font)
self.setContextMenuPolicy(Qt.PreventContextMenu)
p = self.palette
p.setColor(QPalette.Base, bgcolor)
p.setColor(QPalette.Text, textcolor)
self.palette = p
self.history = []
self.curhistory = -1
self.lastinp = ""
self.locked = False
self.globals = {}
self.inmulti = False
self.multi = ""
self.incmd = False
self.comp = Completer(self.globals)
self.selformat = self.currentCharFormat()
self.selformat.setBackground(Qt.white)
self.selformat.setForeground(Qt.black)
self.norformat = self.currentCharFormat()
self.closeAction = closeAction
# we have to make sure, that this runs in the same context as
# commands run from the console
self.clearlocals = list(eval("dir()", self.globals))
self.connect("destroyed()", self._resetdir)
if catchstd:
self.redirector = StdRedirector(self.appendLine)
self.stdout = sys.stdout
sys.stdout = self.redirector
self.connect("destroyed()", self._resetStdout)
else:
self.redirector = None
if os.path.isfile(startup):
with open(startup, "r") as f:
self.runCommand(f.read(), silentStartup)
self.writePrompt(self.plainText != "")
def _resetdir(self):
curlocals = list(eval("dir()", self.globals))
for var in curlocals:
if var not in self.clearlocals:
try:
exec("del %s" % var, self.globals)
except Exception as e:
pass
def _resetStdout(self):
sys.stdout = self.stdout
def setFont(self, f):
QPlainTextEdit.setFont(self, f)
fm = QFontMetrics(f)
self.setCursorWidth(fm.width("X"))
self.setTabStopWidth(fm.width("X") * self.tabwidth)
def prompt(self):
return ">>> " if not self.inmulti else "... "
def promptLength(self):
return len(self.prompt())
def writePrompt(self, newline):
if newline:
self.textCursor().insertBlock()
self.textCursor().insertText(self.prompt())
def promptCursor(self):
retcur = QTextCursor(self.textCursor())
retcur.movePosition(QTextCursor.End)
retcur.movePosition(QTextCursor.StartOfLine)
retcur.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor,
self.promptLength())
return retcur
def keyPressEvent(self, e):
if self.locked:
return
if self.textCursor() < self.promptCursor():
self.moveCursor(QTextCursor.End)
key = e.key()
mods = e.modifiers()
if key == Qt.Key_C and mods & Qt.ControlModifier:
self.doKeyboardInterrupt()
elif key == Qt.Key_D and mods & Qt.ControlModifier:
self.doEndFile()
elif key == Qt.Key_Backspace and mods == Qt.NoModifier:
if self.textCursor() > self.promptCursor():
QPlainTextEdit.keyPressEvent(self, e)
elif key in [Qt.Key_Enter, Qt.Key_Return] and mods == Qt.NoModifier:
self.doExecuteCommand()
elif key == Qt.Key_Up and mods == Qt.NoModifier:
self.doHistoryUp()
elif key == Qt.Key_Down and mods == Qt.NoModifier:
self.doHistoryDown()
elif key == Qt.Key_Left and mods == Qt.NoModifier:
if self.textCursor().positionInBlock() > self.promptLength():
QPlainTextEdit.keyPressEvent(self, e)
elif key == Qt.Key_Right:
QPlainTextEdit.keyPressEvent(self, e)
elif key == Qt.Key_Delete and mods == Qt.NoModifier:
QPlainTextEdit.keyPressEvent(self, e)
elif key == Qt.Key_End and mods == Qt.NoModifier:
self.moveCursor(QTextCursor.EndOfLine)
elif key == Qt.Key_Tab and mods == Qt.NoModifier:
self.doTab()
elif ((key == Qt.Key_Tab and mods == Qt.ShiftModifier) or
key == Qt.Key_Backtab):
self.doUntab()
elif key == Qt.Key_Home and mods == Qt.NoModifier:
self.setTextCursor(self.promptCursor())
else:
QPlainTextEdit.keyPressEvent(self, e)
self.ensureCursorVisible()
def mousePressEvent(self, e):
if e.button() == Qt.LeftButton:
self.seltext = ""
cur = QTextCursor(self.document())
cur.select(QTextCursor.Document)
cur.setCharFormat(self.norformat)
self.selcursor = self.textCursor()
QPlainTextEdit.mousePressEvent(self, e)
else:
QPlainTextEdit.mousePressEvent(self, e)
self.ensureCursorVisible()
def mouseReleaseEvent(self, e):
QPlainTextEdit.mouseReleaseEvent(self, e)
if e.button() == Qt.LeftButton:
self.textCursor().setCharFormat(self.selformat)
self.seltext = self.textCursor().selectedText()
self.setTextCursor(self.selcursor)
elif e.button() == Qt.RightButton:
if self.seltext == "":
self.textCursor().insertText(QApplication.clipboard().text())
else:
self.textCursor().insertText(self.seltext)
QApplication.clipboard().setText(self.seltext)
def doKeyboardInterrupt(self):
self.moveCursor(QTextCursor.End)
self.textCursor().insertBlock()
self.textCursor().insertText("KeyboardInterrupt")
self.inmulti = False
self.multi = ""
self.writePrompt(True)
def doEndFile(self):
cur = self.textCursor()
self.moveCursor(QTextCursor.Right)
# delete key to the right if there are
if cur != self.textCursor():
self.textCursor().deletePreviousChar()
elif self.textCursor() == self.promptCursor():
# if no chars in cur command, close
self.closeAction()
def currentLine(self):
return self.textCursor().block().text()[self.promptLength():]
def removeCurrentLine(self):
self.moveCursor(QTextCursor.End, QTextCursor.MoveAnchor)
self.moveCursor(QTextCursor.StartOfLine, QTextCursor.MoveAnchor)
self.moveCursor(QTextCursor.End, QTextCursor.KeepAnchor)
self.textCursor().removeSelectedText()
def addHistory(self, cmd):
if len(self.history) > 0:
if cmd in self.history:
self.history.pop(self.history.index(cmd))
self.history.append(cmd)
def doHistoryUp(self):
if len(self.history) == 0:
return
if self.curhistory == -1:
self.lastinp = self.currentLine()
self.curhistory = len(self.history)
self.removeCurrentLine()
self.writePrompt(False)
self.curhistory -= 1
if self.curhistory == -1:
self.textCursor().insertText(self.lastinp)
self.curhistory = -1
else:
self.textCursor().insertText(self.history[self.curhistory])
def doHistoryDown(self):
if len(self.history) == 0 or self.curhistory == -1:
return
self.removeCurrentLine()
self.writePrompt(False)
self.curhistory += 1
if self.curhistory == len(self.history):
self.textCursor().insertText(self.lastinp)
self.curhistory = -1
else:
self.textCursor().insertText(self.history[self.curhistory])
def doTab(self):
if self.tabcomplete:
cmd = self.currentLine()
tokens = list(filter(None, re.split("[, \t\-\+\*\[\]\{\}:\(\)]+",
cmd)))
lasttoken = tokens[-1]
if lasttoken != "":
if lasttoken[-1] != cmd[-1]:
# operators are filtered out (such as opening braces),
# so append the last non-alphanumeric characters back
# to the completion token
lastalpha = max(cmd.rfind(i)
for i in string.letters + string.digits)
lasttoken += cmd[- lastalpha + 1:]
state = 0
cur = self.comp.complete(lasttoken, state)
if cur:
l = [cur]
while cur:
state += 1
cur = self.comp.complete(lasttoken, state)
if cur:
l.append(cur)
if len(l) == 1:
self.removeCurrentLine()
self.writePrompt(False)
before = cmd[:-len(lasttoken)]
if before == "":
self.textCursor().insertText(l[0])
else:
self.textCursor().insertText(cmd[:-len(lasttoken)]
+ l[0])
else:
self.appendLine("\t\t".join(l))
prefix = ''.join(c[0] for c in takewhile(lambda x:
all(x[0] == y for y in x), zip(*l)))
if prefix != '':
self.textCursor().insertText(prefix[len(lasttoken):
])
else:
self.textCursor().insertText(cmd)
else:
if self.spaces:
self.textCursor().insertText(" " * self.tabwidth)
else:
self.textCursor().insertText("\t")
def doUntab(self):
if self.tabcomplete:
return
sel = self.textCursor()
tab = " " * self.tabwidth if self.spaces else "\t"
sel.movePosition(QTextCursor.Left, QTextCursor.KeepAnchor, len(tab))
if sel >= self.promptCursor() and sel.selectedText() == tab:
sel.removeSelectedText()
return
def appendLine(self, text):
curline = self.currentLine()
sel = self.textCursor()
self.moveCursor(QTextCursor.End)
self.appendPlainText(text)
if not self.incmd:
self.writePrompt(True)
if curline != "":
self.textCursor().insertText(curline)
cur = self.promptCursor()
cur.movePosition(QTextCursor.Right, QTextCursor.MoveAnchor,
sel.positionInBlock() - self.promptLength())
self.setTextCursor(cur)
def runCommand(self, cmd, silent):
self.incmd = True
if not self.redirector and not silent:
tmp = sys.stdout
sys.stdout = StdRedirector(self.appendLine)
try:
try:
res = eval(cmd, self.globals)
if res is not None:
self.appendLine(repr(res))
except SyntaxError:
exec(cmd, self.globals)
except:
if not silent:
self.appendLine(traceback.format_exc(chain=False))
if not self.redirector and not silent:
sys.stdout = tmp
self.incmd = False
def doExecuteCommand(self):
cmd = self.currentLine().rstrip()
if cmd == "":
if self.inmulti:
cmd = self.multi
self.multi = ""
self.inmulti = False
else:
self.addHistory(cmd)
self.curhistory = -1
if self.inmulti:
self.multi += "\n" + cmd
self.writePrompt(True)
return
if cmd.endswith(":"):
self.inmulti = True
self.multi = cmd
self.writePrompt(True)
return
self.moveCursor(QTextCursor.End)
self.runCommand(cmd, False)
self.writePrompt(True)
self.ensureCursorVisible()