def enableAutoComplete(matchList):
""" Enables tab-autocomplete functionality in user input.
Parameters:
matchList(list<str>): List of strings that can be matched to.
"""
readline.parse_and_bind("tab: complete")
readline.set_completer_delims("")
def complete(text, state):
""" Credit Chris Siebenmann: https://bit.ly/2E0pNDB"""
# generate candidate completion list
if text == "":
matches = matchList
else:
matches = [
x for x in matchList if x.lower().startswith(text.lower())
]
# return current completion match
if state > len(matches):
return None
else:
return matches[state]
readline.set_completer(complete)
def init_completer(self):
try:
import rlcompleter
readline.parse_and_bind("tab: complete")
readline.set_completer_delims("")
readline.write_history_file(os.path.join(dxpy.config.get_user_conf_dir(), '.dx_history'))
readline.clear_history()
readline.set_completer()
except:
pass
def preloop(self):
delims = set(readline.get_completer_delims())
for d in "%*-/":
try:
delims.remove(d)
except KeyError:
pass
readline.set_completer_delims(''.join(delims))
try:
readline.read_history_file(self.HISTORY_FILE)
except (OSError, IOError) as e:
warn("Can't read history file")
def cmdloop(self, line=None):
"""Handle interactive and non-interactive input"""
if line:
# non-interactive (file or command)
self.use_rawinput = False
line = self.precmd(line)
stop = self.onecmd(line)
stop = self.postcmd(stop, line)
else:
# interactive
self.interactive = True
try:
readline.set_completer_delims(self.DELIMS)
except (AttributeError, NameError):
# platforms that do not support readline (Windows)
pass
self.set_prompt()
cmd.Cmd.cmdloop(self)
def setup(self):
""" Initialization of third-party libraries
Setting interpreter history.
Setting appropriate completer function.
:return:
"""
if not os.path.exists(self.history_file):
open(self.history_file, 'a+').close()
readline.read_history_file(self.history_file)
readline.set_history_length(self.history_length)
atexit.register(readline.write_history_file, self.history_file)
readline.parse_and_bind('set enable-keypad on')
readline.set_completer(self.complete)
readline.set_completer_delims(' \t\n;')
readline.parse_and_bind("tab: complete")
def setup(self):
""" Initialization of third-party libraries
Setting interpreter history.
Setting appropriate completer function.
:return:
"""
if not os.path.exists(self.history_file):
open(self.history_file, 'a+').close()
readline.read_history_file(self.history_file)
readline.set_history_length(self.history_length)
atexit.register(readline.write_history_file, self.history_file)
readline.parse_and_bind('set enable-keypad on')
readline.set_completer(self.complete)
readline.set_completer_delims(' \t\n;')
readline.parse_and_bind("tab: complete")
ret.append(None)
last_clist = ret
return last_clist[state]
# some python distributions don't have readline, so handle that case
# with a try/except
try:
if platform.system() == 'Darwin':
import gnureadline as readline
else:
try:
import readline
except ImportError:
import pyreadline as readline
readline.set_completer_delims(' \t\n;')
readline.parse_and_bind("tab: complete")
readline.set_completer(complete)
redisplay = readline.redisplay
except Exception:
pass
if __name__ == "__main__":
from mp_settings import MPSettings, MPSetting
class mystate(object):
def __init__(self):
self.settings = MPSettings([
MPSetting('foo',
int,
1,
def init_readline(self):
readline.parse_and_bind('tab: complete')
readline.set_completer(complete)
readline.set_completer_delims(' \t')
self.init_history_file()
readline.read_history_file(self.history)
"Python": python,
"bash": bash
}
completer_state = {
"available": False
}
try:
try:
import gnureadline as readline
except ImportError:
import readline
import rlcompleter
readline.parse_and_bind("tab: complete")
readline.set_completer_delims("")
completer_state['available'] = True
except ImportError:
print('NOTE: readline module not available. Install for tab-completion.')
class Completer():
def __init__(self, choices):
self.matches = None
self.choices = choices
def complete(self, text, state):
if state == 0:
self.matches = filter(lambda choice: choice.startswith(text),
self.choices)
if self.matches is not None and state < len(self.matches):
def input_with_prefill(prompt, text):
def hook():
readline.insert_text(text)
readline.redisplay()
readline.set_pre_input_hook(hook)
try:
result = input(prompt)
except:
result = ''
readline.set_pre_input_hook()
return result
readline.set_completer_delims('')
if 'libedit' in readline.__doc__:
readline.parse_and_bind("bind ^I rl_complete")
else:
readline.parse_and_bind("tab: complete")
os.chdir(DMSdirectory + 'Documents')
for (dirpath, dirnames, filenames) in os.walk(DMSdirectory + 'inbox'):
for name in filenames:
filename_old = os.path.join(dirpath, name)
if name.endswith(".pdf"):
print('Processing: ' + filename_old)
subprocess.call([
last_clist = ret
return last_clist[state]
# some python distributions don't have readline, so handle that case
# with a try/except
try:
if platform.system() == 'Darwin':
import gnureadline as readline
else:
try:
import readline
except ImportError:
import pyreadline as readline
readline.set_completer_delims(' \t\n;')
readline.parse_and_bind("tab: complete")
readline.set_completer(complete)
redisplay = readline.redisplay
except Exception:
pass
if __name__ == "__main__":
from mp_settings import MPSettings, MPSetting
class mystate(object):
def __init__(self):
self.settings = MPSettings(
[ MPSetting('foo', int, 1, 'foo int', tab='Link', range=(0,4), increment=1),
MPSetting('bar', float, 4, 'bar float', range=(-1,20), increment=1)])
def __init__(
self, command: str, rebuild: bool, config_path: str, nix: bool = False, settings_path: str = SETTINGS_PATH
):
self._command = command
self._rebuild: bool = rebuild
self._nix: bool = nix # Not currently supported
self._config_path: str = config_path
self._settings_path: str = settings_path
assert command in RUNNER_COMMANDS
# Some state flags/vars used by eg the UI/event loop
self._primary_attached_app: Optional[Dict] = None
self._shutdown: threading.Event = threading.Event()
self._awaiting_input: bool = False
self._suppress_log_printing: bool = False
self._filter_logs: Sequence[str] = []
self._use_docker_services: bool = False
self._processes: dict = {}
self._dmservices = None
self._main_log_name = "manager"
self.config: Dict = {}
# Temporarily ignore SIGINT while setting up multiprocessing components.
# START
curr_signal = signal.getsignal(signal.SIGINT)
signal.signal(signal.SIGINT, signal.SIG_IGN)
self._manager = multiprocessing.Manager()
self._apps: Dict[str, Dict[str, Any]] = self._manager.dict()
signal.signal(signal.SIGINT, curr_signal) # Probably a race condition?
# END
with open(self._settings_path) as settings_file:
self.settings: dict = yaml.safe_load(settings_file.read())
# load environment variables from settings file,
# taking care not to override existing envvars
if self.settings.get("environment"):
for key, value in self.settings["environment"].items():
if key not in os.environ:
self.logger(f"setting environment variable {key}")
os.environ[key] = str(value)
self._main_log_name = "setup"
# Handles initialization of external state required to run this correctly (repos, docker images, config, etc).
exitcode, self._use_docker_services, self.config = setup_and_check_requirements(
logger=self.logger,
config=self.config,
config_path=self._config_path,
settings=self.settings,
command=self._command,
)
if exitcode or self._command != RUNNER_COMMAND_RUN:
self.shutdown()
sys.exit(exitcode)
self._inject_credentials()
self._main_log_name = "manager"
self._populate_multiprocessing_components()
# Setup tab completion for app names.
readline.parse_and_bind("tab: complete")
readline.set_completer(self._app_name_completer)
readline.set_completer_delims(" ")
from collections import defaultdict
from termcolor import colored as term_colored
from xclib.conductor import Conductor
from xclib.conductor.models import Datacenter, Project, Host, Group
import sys, fcntl, termios, struct, os, cmd, re
reload(sys)
sys.setdefaultencoding("utf8")
try:
import gnureadline as readline
except ImportError:
import readline
sys.modules["readline"] = readline
readline.parse_and_bind("tab: complete")
readline.set_completer_delims(readline.get_completer_delims().replace(":", ""))
def terminal_size():
h, w, hp, wp = struct.unpack(
'HHHH',
fcntl.ioctl(0, termios.TIOCGWINSZ, struct.pack('HHHH', 0, 0, 0, 0)))
return w, h
def colored(*args, **kwargs):
if "sym_ignore" in kwargs:
sym_ignore = kwargs["sym_ignore"]
del (kwargs["sym_ignore"])
else:
sym_ignore = False
def console():
# Configuring the commpleter
comp = Completer(['load', 'set', 'show', 'run', 'back', 'warriors', 'quit', 'help'])
gnureadline.set_completer_delims(' \t\n;')
gnureadline.parse_and_bind("tab: complete")
gnureadline.set_completer(comp.complete)
print (banners.get_banner())
cprint(' [+]', 'yellow', end='')
print (' Starting the console...')
cprint(' [*]', 'green', end='')
print (' Console ready!\n')
session = None
while True:
if session is None:
# With termcolor not work colors
# user_input = input(
# colored('iBombShell> ', 'green', attrs=['bold'])).split()
# /* Definitions available for use by readline clients. */
# define RL_PROMPT_START_IGNORE '\001'
# define RL_PROMPT_END_IGNORE '\002'
user_input = input('\001\033[1;32m\002iBombShell> \001\033[0m\002').split()
else:
# user_input = input(
# "iBombShell["
# + colored(session.header(), 'green', attrs=['bold'])
# + "]> ").split()
user_input = input('iBombShell[' +
'\001\033[1;32m\002' +
session.header() +
'\001\033[0m\002' +
']> ').split()
if user_input == []:
continue
elif user_input[0] in CLEAR_COMMANDS:
os.system('cls' if os.name=='nt' else 'clear')
elif user_input[0] == 'back':
session = None
elif user_input[0] == 'warriors':
i = 0
for p in Path("/tmp/").glob("ibs-*"):
i += 1
cprint(str(p)[9:], 'yellow')
if i == 0:
cprint('[!] Warriors haven\'t been found...', 'red')
elif user_input[0] in END_COMMANDS:
cprint('[+] Killing warriors...', 'green')
for p in Path("/tmp/").glob("ibs-*"):
p.unlink()
cprint('[+] Exit...', 'green')
os._exit(-1)
elif user_input[0] == 'load':
if (len(user_input) == 1):
cprint('[!] Please, load a module', 'red')
continue
session = Session(user_input[1])
# The module is incorrect
if not(session.correct_module()):
cprint('[!] Invalid module', 'red')
session = None
elif user_input[0] == 'show':
if session is None:
cprint('[!] Please, load a module', 'red')
continue
session.show()
elif user_input[0] == 'set':
if session is None:
cprint('[!] Please, load a module', 'red')
continue
else:
value = ' '.join([str(x) for x in user_input[2:]])
session.set(user_input[1], value)
elif user_input[0] == 'run':
if session is None:
cprint('[!] Please, load a module', 'red')
continue
session.run()
else:
cprint('[!] Command not found', 'red')
