def get_completer(): topics = {f"{k}": None for (k, v) in mqtt.devices.items()} topics_long = {f"{k}/{v.func}/": None for (k, v) in mqtt.devices.items()} completer = NestedCompleter.from_nested_dict({ "help": None, "exit": None, "pub": topics_long, "ping": { **{ "all": None }, **topics }, "write": topics, "read": topics, "add": None, "list": None, "kaljaa": None, }) return completer
def get_completer(): def get_paths(): return [build_context.config.work_dir] return NestedCompleter.from_nested_dict({ "help": None, "glob": { "build": None, "host": None }, "exit": None, "ls": PathCompleter(get_paths=get_paths), "edit": { "file": PathCompleter(get_paths=get_paths), "script": None, "recipe": None, }, "build": None, })
def menu(ticker: str, start: datetime, interval: str, stock: pd.DataFrame, context: str = ""): """Technical Analysis Menu""" ta_controller = TechnicalAnalysisController(ticker, start, interval, stock) ta_controller.call_help(None) if context: context = f"({context})>" while True: # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: completer = NestedCompleter.from_nested_dict( {c: None for c in ta_controller.CHOICES}) an_input = session.prompt( f"{get_flair()} {context}(ta)> ", completer=completer, ) else: an_input = input(f"{get_flair()} {context}(ta)> ") try: plt.close("all") process_input = ta_controller.switch(an_input) if process_input is not None: return process_input except SystemExit: print("The command selected doesn't exist\n") continue
def _create_completer(self): variable_completer = ScopeCompleter(self.runner, 'variable_names') loop_completer = LoopCompleter(self.runner) modifier_completer = ScopeCompleter(self.runner, 'modifier_names') d = { k: None for k in itertools.chain( langref.KEYWORDS, langref.SPECIAL_REFERENCES, ) } d['->'] = modifier_completer d['=>'] = modifier_completer d['has'] = {'do': None} d['for'] = {'every': None} d['except'] = {'when': None} d['but'] = {'if': None, 'always': None} d['restart'] = { 'before': loop_completer, 'at': loop_completer, 'after': loop_completer, } d['clear'] = variable_completer return NestedCompleter.from_nested_dict(d)
def __init__( self, ticker: str, start: datetime, interval: str, stock: pd.DataFrame, queue: List[str] = None, ): """Constructor""" super().__init__(queue) self.ticker = ticker self.start = start self.interval = interval self.stock = stock if session and gtff.USE_PROMPT_TOOLKIT: choices: dict = {c: {} for c in self.controller_choices} choices["load"]["-i"] = {c: {} for c in stocks_helper.INTERVALS} choices["load"]["-s"] = {c: {} for c in stocks_helper.SOURCES} choices["recom"]["-i"] = {c: {} for c in tradingview_model.INTERVALS.keys()} choices["recom"]["-s"] = {c: {} for c in tradingview_model.SCREENERS} choices["kc"]["-m"] = {c: {} for c in volatility_model.MAMODES} self.completer = NestedCompleter.from_nested_dict(choices)
def menu(): """Brokers Menu""" bro_controller = BrokersController() print( "\nUSE THIS MENU AT YOUR OWN DISCRETION\n" " - This menu is the only one in the entire repository that has access to your broker accounts. " "If you have provided your login details on the config_terminal.py file" " - We review the code thoroughly from each contributor, hence, we can ensure that our codebase " "does not take advantage of your data.\n" " - HOWEVER, our project imports almost 200 different open source python modules. Therefore, it " "is impossible for us to check the coding standards and security of each of these modules. " "Hence why adding this disclaimer here.\n") bro_controller.print_help() while True: # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: completer = NestedCompleter.from_nested_dict( {c: None for c in bro_controller.CHOICES}) an_input = session.prompt( f"{get_flair()} (bro)> ", completer=completer, ) else: an_input = input(f"{get_flair()} (bro)> ") try: process_input = bro_controller.switch(an_input) if process_input is not None: return process_input except SystemExit: print("The command selected doesn't exist\n") continue
def __init__( self, ticker: str, start: datetime, interval: str, stock: pd.DataFrame, queue: List[str] = None, ): """Constructor""" super().__init__(queue) # TODO: Move these calculations to a model stock["Returns"] = stock["Adj Close"].pct_change() stock["LogRet"] = np.log(stock["Adj Close"]) - np.log( stock["Adj Close"].shift(1)) stock["LogPrice"] = np.log(stock["Adj Close"]) stock = stock.rename(columns={"Adj Close": "AdjClose"}) stock = stock.dropna() stock.columns = [x.lower() for x in stock.columns] self.stock = stock self.ticker = ticker self.start = start self.interval = interval self.target = "returns" if session and gtff.USE_PROMPT_TOOLKIT: choices: dict = {c: {} for c in self.controller_choices} choices["pick"] = {c: None for c in list(stock.columns)} choices["load"]["-i"] = {c: None for c in self.stock_interval} choices["load"]["--interval"] = { c: None for c in self.stock_interval } choices["load"]["--source"] = {c: None for c in self.stock_sources} self.completer = NestedCompleter.from_nested_dict(choices)
def __init__( self, ticker: str, start: str, interval: str, queue: List[str] = None, ): """Constructor Parameters ---------- ticker : str Fundamental analysis ticker symbol start : str Stat date of the stock data interval : str Stock data interval """ self.ticker = ticker self.start = start self.interval = interval self.fmp_parser = argparse.ArgumentParser(add_help=False, prog="fmp") self.fmp_parser.add_argument( "cmd", choices=self.CHOICES, ) self.completer: Union[None, NestedCompleter] = None if session and gtff.USE_PROMPT_TOOLKIT: choices: dict = {c: {} for c in self.CHOICES} self.completer = NestedCompleter.from_nested_dict(choices) if queue: self.queue = queue else: self.queue = list()
def __init__(self, queue: List[str] = None): """Constructor""" super().__init__(queue) self.preset = "top_gainers" self.screen_tickers: List = list() if session and gtff.USE_PROMPT_TOOLKIT: choices: dict = {c: {} for c in self.controller_choices} choices["view"] = {c: None for c in self.preset_choices} choices["set"] = { c: None for c in self.preset_choices + list(finviz_model.d_signals.keys()) } choices["historical"]["-t"] = { c: None for c in self.historical_candle_choices } choices["overview"]["-s"] = { c: None for c in finviz_view.d_cols_to_sort["overview"] } choices["valuation"]["-s"] = { c: None for c in finviz_view.d_cols_to_sort["valuation"] } choices["financial"]["-s"] = { c: None for c in finviz_view.d_cols_to_sort["financial"] } choices["ownership"]["-s"] = { c: None for c in finviz_view.d_cols_to_sort["ownership"] } choices["performance"]["-s"] = { c: None for c in finviz_view.d_cols_to_sort["performance"] } choices["technical"]["-s"] = { c: None for c in finviz_view.d_cols_to_sort["technical"] } self.completer = NestedCompleter.from_nested_dict(choices)
def menu(): """Portfolio Analysis Menu""" pa_controller = PortfolioController() pa_controller.print_help() while True: # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: completer = NestedCompleter.from_nested_dict( {c: None for c in pa_controller.CHOICES}) an_input = session.prompt( f"{get_flair()} (portfolio)>(pa)> ", completer=completer, ) else: an_input = input(f"{get_flair()} (portfolio)>(pa)> ") try: pa_controller.switch(an_input) except SystemExit: print("The command selected doesn't exist\n") continue
def __init__( self, ticker: str, queue: List[str] = None, ): """Constructor""" super().__init__(queue) self.ticker = ticker if session and gtff.USE_PROMPT_TOOLKIT: choices: dict = {c: {} for c in self.controller_choices} choices["lasttrades"] = {c: {} for c in self.gov_type_choices} choices["topbuys"] = {c: {} for c in self.gov_type_choices} choices["topsells"] = {c: {} for c in self.gov_type_choices} choices["qtrcontracts"]["-a"] = { c: {} for c in self.analysis_choices } choices["qtrcontracts"]["--analysis"] = { c: {} for c in self.analysis_choices } self.completer = NestedCompleter.from_nested_dict(choices)
def __init__( self, coin: str, data: pd.DataFrame, queue: List[str] = None, ): """Constructor""" self.pred_parser = argparse.ArgumentParser(add_help=False, prog="pred") self.pred_parser.add_argument( "cmd", choices=self.CHOICES, ) data["Returns"] = data["Close"].pct_change() data["LogRet"] = np.log(data["Close"]) - np.log(data["Close"].shift(1)) data = data.dropna() self.data = data self.coin = coin self.resolution = "1D" self.target = "Close" self.completer: Union[None, NestedCompleter] = None if session and gtff.USE_PROMPT_TOOLKIT: choices: dict = {c: {} for c in self.CHOICES} choices["load"]["-r"] = {c: {} for c in c_help.INTERVALS} choices["pick"] = {c: {} for c in self.data.columns} choices["ets"]["-t"] = {c: {} for c in ets_model.TRENDS} choices["ets"]["-s"] = {c: {} for c in ets_model.SEASONS} choices["arima"]["-i"] = {c: {} for c in arima_model.ICS} choices["mc"]["--dist"] = {c: {} for c in mc_model.DISTRIBUTIONS} self.completer = NestedCompleter.from_nested_dict(choices) if queue: self.queue = queue else: self.queue = list()
def menu(ticker: str, last_adj_close_price: float): """ Options Menu. """ try: op_controller = OptionsController(ticker, last_adj_close_price) op_controller.call_help(None) except IndexError: print("No options found for " + ticker) print("") process_input = False return process_input while True: # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: completer = NestedCompleter.from_nested_dict( {c: None for c in op_controller.CHOICES}) an_input = session.prompt( f"{get_flair()} (op)> ", completer=completer, ) else: an_input = input(f"{get_flair()} (op)> ") try: plt.close("all") process_input = op_controller.switch(an_input) if process_input is not None: return process_input except SystemExit: print("The command selected doesn't exist\n") continue
def menu(): """Report Menu""" report_controller = ReportController() report_controller.call_help(None) # Initialize jupyter notebook cmd = f"jupyter notebook --port={config_terminal.PAPERMILL_NOTEBOOK_REPORT_PORT}" proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) while True: # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: completer = NestedCompleter.from_nested_dict( {c: None for c in report_controller.CHOICES}) an_input = session.prompt( f"{get_flair()} (stocks)>(report)> ", completer=completer, ) else: an_input = input(f"{get_flair()} (stocks)>(report)> ") try: process_input = report_controller.switch(an_input, proc) except SystemExit: print("The command selected doesn't exist\n") continue if process_input is False: return False if process_input is True: return True
def sen_menu(s_ticker, s_start): # Add list of arguments that the discovery parser accepts sen_parser = argparse.ArgumentParser(prog="sen", add_help=False) choices = [ "help", "q", "quit", "watchlist", "spac", "spac_c", "wsb", "popular", "bullbear", "messages", "trending", "stalker", "infer", "sentiment", "mentions", "regions", "queries", "rise", ] sen_parser.add_argument("cmd", choices=choices) completer = NestedCompleter.from_nested_dict({c: None for c in choices}) print_sentiment() # Loop forever and ever while True: # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: as_input = session.prompt( f"{get_flair()} (sen)> ", completer=completer, ) else: as_input = input(f"{get_flair()} (sen)> ") # Parse sentiment command of the list of possible commands try: (ns_known_args, l_args) = sen_parser.parse_known_args(as_input.split()) except SystemExit: print("The command selected doesn't exist\n") continue if ns_known_args.cmd == "help": print_sentiment() elif ns_known_args.cmd == "q": # Just leave the DISC menu return False elif ns_known_args.cmd == "quit": # Abandon the program return True elif ns_known_args.cmd == "watchlist": reddit_api.watchlist(l_args) elif ns_known_args.cmd == "spac": reddit_api.spac(l_args) elif ns_known_args.cmd == "spac_c": reddit_api.spac_community(l_args) elif ns_known_args.cmd == "wsb": reddit_api.wsb_community(l_args) elif ns_known_args.cmd == "popular": reddit_api.popular_tickers(l_args) elif ns_known_args.cmd == "bullbear": stocktwits_api.bullbear(l_args, s_ticker) elif ns_known_args.cmd == "messages": stocktwits_api.messages(l_args, s_ticker) elif ns_known_args.cmd == "trending": stocktwits_api.trending(l_args) elif ns_known_args.cmd == "stalker": stocktwits_api.stalker(l_args) elif ns_known_args.cmd == "infer": if not gtff.ENABLE_PREDICT: print("Predict is not enabled in feature_flags.py") print("Twitter inference menu is disabled") print("") continue try: # pylint: disable=import-outside-toplevel from gamestonk_terminal.sentiment import twitter_api except ModuleNotFoundError as e: print("One of the optional packages seems to be missing") print("Optional packages need to be installed") print(e) print("") continue except Exception as e: print(e) print("") continue twitter_api.inference(l_args, s_ticker) elif ns_known_args.cmd == "sentiment": if not gtff.ENABLE_PREDICT: print("Predict is not enabled in config_terminal.py") print("Twitter sentiment menu is disabled") print("") continue try: # pylint: disable=import-outside-toplevel from gamestonk_terminal.sentiment import twitter_api except ModuleNotFoundError as e: print("One of the optional packages seems to be missing") print("Optional packages need to be installed") print(e) print("") continue except Exception as e: print(e) print("") continue twitter_api.sentiment(l_args, s_ticker) elif ns_known_args.cmd == "mentions": google_api.mentions(l_args, s_ticker, s_start) elif ns_known_args.cmd == "regions": google_api.regions(l_args, s_ticker) elif ns_known_args.cmd == "queries": google_api.queries(l_args, s_ticker) elif ns_known_args.cmd == "rise": google_api.rise(l_args, s_ticker) else: print("Command not recognized!")
def setup_completer(self): if not self.cfSlugs or not self.wowiSlugs: # noinspection PyBroadException try: self.cfSlugs = pickle.load( gzip.open( io.BytesIO( requests.get( 'https://storage.googleapis.com/cursebreaker/cfslugs.pickle.gz', headers=HEADERS).content))) self.wowiSlugs = pickle.load( gzip.open( io.BytesIO( requests.get( 'https://storage.googleapis.com/cursebreaker/wowislugs.pickle.gz', headers=HEADERS).content))) except Exception: self.cfSlugs = [] self.wowiSlugs = [] addons = [] for addon in sorted(self.core.config['Addons'], key=lambda k: k['Name'].lower()): addons.append(f'"{addon["Name"]}"' if ',' in addon["Name"] else addon["Name"]) slugs = ['ElvUI', 'Tukui'] for item in self.cfSlugs: slugs.append(f'cf:{item}') for item in self.wowiSlugs: slugs.append(f'wowi:{item}') slugs.extend(['ElvUI:Dev', 'SLE:Dev']) accounts = [] for account in self.core.detect_accounts(): accounts.append(account) self.completer = NestedCompleter.from_nested_dict({ 'install': WordCompleter(slugs, ignore_case=True, match_middle=True, WORD=True), 'uninstall': WordCompleter(addons, ignore_case=True), 'update': WordCompleter(addons, ignore_case=True), 'force_update': WordCompleter(addons, ignore_case=True), 'wago_update': None, 'status': WordCompleter(addons, ignore_case=True), 'orphans': { 'delete': None }, 'search': None, 'import': { 'install': None }, 'export': None, 'toggle_backup': None, 'toggle_dev': WordCompleter(addons + ['global'], ignore_case=True, sentence=True), 'toggle_block': WordCompleter(addons, ignore_case=True, sentence=True), 'toggle_compact_mode': None, 'toggle_wago': None, 'set_wago_api': None, 'set_wago_wow_account': WordCompleter(accounts, ignore_case=True, sentence=True), 'uri_integration': None, 'help': None, 'exit': None })
# dataDemo = {**dataDemo , **dataDemoModules } for m in plugins.Plugin.pluginsActivated: print(m) dataDemoModules = {} dataDemoModules = yaml.load( plugins.Plugin.pluginsActivated[m].getDemoDataYaml(), Loader=yaml.SafeLoader) dataDemo = {**dataDemo, **dataDemoModules} if os.getenv("ST_DEMO") == '1': my_fun(dataDemo, menu_completion, "", "") else: my_fun(jinjaFile2yaml(file_main), menu_completion, "", "") completer = FuzzyCompleter(NestedCompleter.from_nested_dict(menu_completion)) def getIcon(icon, defaultIcon=""): if detectNerdFont: return icon return defaultIcon bindings = KeyBindings() @bindings.add('c-c') def _(event): #" Exit when `c-x` is pressed. " event.app.exit()
def pred_menu(df_stock, s_ticker, s_start, s_interval): # Add list of arguments that the prediction techniques parser accepts pred_parser = argparse.ArgumentParser(prog="pred", add_help=False) choices = [ "help", "q", "quit", "sma", "ets", "knn", "linear", "quadratic", "cubic", "regression", "arima", "prophet", "mlp", "rnn", "lstm", ] pred_parser.add_argument("cmd", choices=choices) completer = NestedCompleter.from_nested_dict({c: None for c in choices}) print_prediction(s_ticker, s_start, s_interval) # Loop forever and ever while True: # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: as_input = session.prompt( f"{get_flair()} (pred)> ", completer=completer, ) else: as_input = input(f"{get_flair()} (pred)> ") # Images are non blocking - allows to close them if we type other command plt.close("all") # Parse prediction techniques command of the list of possible commands try: (ns_known_args, l_args) = pred_parser.parse_known_args(as_input.split()) except SystemExit: print("The command selected doesn't exist\n") continue if ns_known_args.cmd == "help": print_prediction(s_ticker, s_start, s_interval) elif ns_known_args.cmd == "q": # Just leave the FA menu return False elif ns_known_args.cmd == "quit": # Abandon the program return True elif ns_known_args.cmd == "sma": sma.simple_moving_average(l_args, s_ticker, df_stock) elif ns_known_args.cmd == "ets": ets.exponential_smoothing(l_args, s_ticker, df_stock) elif ns_known_args.cmd == "knn": knn.k_nearest_neighbors(l_args, s_ticker, df_stock) elif ns_known_args.cmd == "linear": regression.regression(l_args, s_ticker, df_stock, regression.LINEAR) elif ns_known_args.cmd == "quadratic": regression.regression(l_args, s_ticker, df_stock, regression.QUADRATIC) elif ns_known_args.cmd == "cubic": regression.regression(l_args, s_ticker, df_stock, regression.CUBIC) elif ns_known_args.cmd == "regression": regression.regression(l_args, s_ticker, df_stock, regression.USER_INPUT) elif ns_known_args.cmd == "arima": arima.arima(l_args, s_ticker, df_stock) elif ns_known_args.cmd == "prophet": fbprophet.fbprophet(l_args, s_ticker, df_stock) elif ns_known_args.cmd == "mlp": neural_networks.mlp(l_args, s_ticker, df_stock) elif ns_known_args.cmd == "rnn": neural_networks.rnn(l_args, s_ticker, df_stock) elif ns_known_args.cmd == "lstm": neural_networks.lstm(l_args, s_ticker, df_stock) else: print("Command not recognized!")
def port_menu(): plt.close("all") port_parser = argparse.ArgumentParser(prog="port", add_help=False) choices = ["help", "q", "quit", "hold", "rhhist", "login"] port_parser.add_argument("cmd", choices=choices) completer = NestedCompleter.from_nested_dict({c: None for c in choices}) should_print_help = True print_login = True while True: if should_print_help: print_port(print_login) should_print_help = False # Get input command from user if session and gtff.USE_PROMPT_TOOLKIT: as_input = session.prompt( f"{get_flair()} (port)> ", completer=completer, ) else: as_input = input(f"{get_flair()} (port)> ") try: (ns_known_args, l_args) = port_parser.parse_known_args(as_input.split()) except SystemExit: print("The command selected doesn't exist\n") continue if ns_known_args.cmd == "help": should_print_help = True elif ns_known_args.cmd == "q": # Leave the port menu + logout of robinhood # logoff raises error if not logged in try: rh_api.logoff() except Exception: pass return False elif ns_known_args.cmd == "quit": # Will raise exception if not logged in try: rh_api.logoff() except Exception: pass # Abandon the program return True elif ns_known_args.cmd == "hold": try: rh_api.show_holdings() except Exception as e: print(e) print("") elif ns_known_args.cmd == "rhhist": rh_api.plot_historical(l_args) elif ns_known_args.cmd == "login": try: rh_api.login() should_print_help = True print_login = False except Exception as e: print("") print(e) print( "Make sure credentials are defined in config_terminal.py ") print("") should_print_help = False print_login = True else: print("Command not recognized") print("")
async def main(): '''Main stuff''' try: asyncio.create_task(qrzLookupQueue()) data = None while True: infinite = True if 1 in sys.argv: callLookup = "lookup " + sys.argv[1] infinite = False else: try: call_completer = NestedCompleter.from_nested_dict(commands) if oneshot is False: message = [('class:message', 'qrz'), ('class:prompt', '> ')] else: message = '' callLookup = await session.prompt_async( message, style=style, completer=call_completer, complete_while_typing=True, enable_history_search=True, auto_suggest=AutoSuggestFromHistory()) except KeyboardInterrupt: await shutdown() command = (callLookup.lower().split(sep=" ", maxsplit=2))[0] if command in ['exit', 'quit', 'rotate', 'email', 'maps']: if command in ['']: pass if command in ['exit', 'quit']: await shutdown() if command in ['email']: if data is None: print("First do a lookup !") else: sendemail(cfg, data) if command in ['rotate']: if data is None: print("First do a lookup !") else: rotate(cfg, data) if command in ['maps']: if data is None: print("First do a lookup !") else: print("Start maps") maps(cfg, data) else: if command in ['lookup']: data = await qrzLookup(callLookup, cfg) if data['callsign'] is not None: await qsoLookup(data['callsign']) print() if not infinite: sys.exit() else: redis.rpush('qrzLookupQueue', callLookup) except EOFError: pass
def get_completer(): csv_files = [s for s in listdir() if s.endswith('.csv')] completions['load'] = WordCompleter(csv_files) completer = NestedCompleter.from_nested_dict(completions) return FuzzyCompleter(completer)
from pygments.style import Style from pygments.token import Keyword, Name, Comment, String, Error, \ Number, Operator, Generic from prompt_toolkit import prompt from prompt_toolkit.completion import NestedCompleter completer = NestedCompleter.from_nested_dict({ 'show': { 'version': None, 'clock': None, 'ip': { 'interface': {'brief'} }, }, 'exit': None, }) while True: text = prompt('> ', completer=completer, complete_while_typing=True) if text == 'exit': break
def __init__( self, ticker: str, queue: List[str] = None, ): """Constructor""" super().__init__(queue) self.country = "United States" self.sector = "Financial Services" self.industry = "Financial Data & Stock Exchanges" self.mktcap = "Large" self.exclude_exchanges = True self.period = "Annual" self.ticker = ticker self.stocks_data: dict = {} self.tickers: List = list() self.currency: str = "" if ticker: data = yf.utils.get_json( f"https://finance.yahoo.com/quote/{ticker}") if "summaryProfile" in data: self.country = data["summaryProfile"]["country"] if self.country not in financedatabase_model.get_countries(): similar_cmd = difflib.get_close_matches( self.country, financedatabase_model.get_countries(), n=1, cutoff=0.7, ) if similar_cmd: self.country = similar_cmd[0] self.sector = data["summaryProfile"]["sector"] if self.sector not in financedatabase_model.get_sectors(): similar_cmd = difflib.get_close_matches( self.sector, financedatabase_model.get_sectors(), n=1, cutoff=0.7, ) if similar_cmd: self.sector = similar_cmd[0] self.industry = data["summaryProfile"]["industry"] if self.industry not in financedatabase_model.get_industries(): similar_cmd = difflib.get_close_matches( self.industry, financedatabase_model.get_industries(), n=1, cutoff=0.7, ) if similar_cmd: self.industry = similar_cmd[0] if "price" in data: mktcap = data["price"]["marketCap"] if mktcap < 2_000_000_000: self.mktcap = "Small" elif mktcap > 10_000_000_000: self.mktcap = "Large" else: self.mktcap = "Mid" if session and gtff.USE_PROMPT_TOOLKIT: choices: dict = {c: {} for c in self.controller_choices} choices["mktcap"] = {c: None for c in self.mktcap_choices} choices["period"] = {c: None for c in self.period_choices} choices["clear"] = {c: None for c in self.clear_choices} choices["metric"] = {c: None for c in self.metric_choices} # This menu contains dynamic choices that may change during runtime self.choices = choices self.completer = NestedCompleter.from_nested_dict(choices)
def update_runtime_choices(self): if session and gtff.USE_PROMPT_TOOLKIT: self.choices["pick"] = {c: None for c in list(self.df.columns)} self.completer = NestedCompleter.from_nested_dict(self.choices)
Crack("crack brute ?a") Crack("crack brute ?a?a") Crack("crack brute ?a?a?a") Crack("crack brute ?a?a?a?a") Crack("crack brute ?a?a?a?a?a") Crack("crack brute ?a?a?a?a?a?a") Crack("crack brute ?a?a?a?a?a?a?a") # Maybe keyboard walk? Crack("crack kwp") # Cracks more but is larger space Crack("crack rules OneRuleToRuleThemAll.rule") # Last gasp. Try out prince Crack("crack prince") # https://github.com/intel/compute-runtime/blob/master/documentation/Neo_in_distributions.md # intel-opencl-icd # https://software.intel.com/en-us/articles/opencl-drivers#latest_CPU_runtime LOGGER = logging.getLogger(__name__) CRACK_COMPLETER = NestedCompleter({ 'brute': None, 'kwp': None, 'prince': None, 'rules': None, 'show': None, 'wordlist': None, })
completer = NestedCompleter.from_nested_dict({ 'attribute': None, 'advancement': { 'grant': None, 'revoke': None }, 'ban': None, 'ban-ip': None, 'banlist': { 'ips': None, 'players': None }, 'bossbar': { 'add': None, 'get': None, 'list': None, 'remove': None, 'set': None }, 'clear': None, 'clone': None, 'data': { 'get' : {'block':None, 'entity':None, 'storage':None}, 'merge' : {'block':None, 'entity':None, 'storage':None}, 'modify' : {'block':None, 'entity':None, 'storage':None}, 'remove' : {'block':None, 'entity':None, 'storage':None} }, 'datapack': { 'disable': None, 'enable': None, 'list': None }, 'defaultgamemode': { 'adventure': None, 'creative':None, 'spectator': None, 'survival': None }, 'deop': None, 'difficulty': None, 'effect': { 'clear': None, 'give': None }, 'enchant': None, 'experience': { 'add': None, 'set': None, 'query': None }, 'xp': { 'add': None, 'set': None, 'query': None }, 'list': None, 'help': None, 'gamemode': { 'adventure': None, 'creative':None, 'spectator': None, 'survival': None }, 'time':{ 'add': None, 'query': { 'daytime': None, 'gametime': None, 'day': None }, 'set': { 'day': None, 'night': None, 'noon': None, 'midnight': None } } })
def get_auto_complete(cli: Group) -> NestedCompleter: commands = {"flask": get_commands(cli), "info": None} completer = NestedCompleter.from_nested_dict(commands) return completer
def main(): """ Gamestonk Terminal is an awesome stock market terminal that has been developed for fun, while I saw my GME shares tanking. But hey, I like the stock. """ # Enable VT100 Escape Sequence for WINDOWS 10 Ver. 1607 if sys.platform == "win32": os.system("") s_ticker = "" s_start = "" df_stock = pd.DataFrame() s_interval = "1440min" # Set stock by default to speed up testing # s_ticker = "BB" # ts = TimeSeries(key=cfg.API_KEY_ALPHAVANTAGE, output_format='pandas') # df_stock, d_stock_metadata = ts.get_daily_adjusted(symbol=s_ticker, outputsize='full') # df_stock.sort_index(ascending=True, inplace=True) # s_start = datetime.strptime("2020-06-04", "%Y-%m-%d") # df_stock = df_stock[s_start:] # Add list of arguments that the main parser accepts menu_parser = argparse.ArgumentParser(add_help=False, prog="gamestonk_terminal") choices = [ "help", "quit", "q", "clear", "load", "candle", "view", "export", "disc", "mill", "ba", "res", "fa", "ta", "dd", "pred", "ca", "op", "fred", "port", ] menu_parser.add_argument("opt", choices=choices) completer = NestedCompleter.from_nested_dict({c: None for c in choices}) # Print first welcome message and help print("\nWelcome to Gamestonk Terminal 🚀\n") should_print_help = True parsed_stdin = False if gtff.ENABLE_THOUGHTS_DAY: print("-------------------") try: thought.get_thought_of_the_day() except Exception as e: print(e) print("") # Loop forever and ever while True: main_cmd = False if should_print_help: print_help(s_ticker, s_start, s_interval, b_is_stock_market_open()) should_print_help = False # Get input command from stdin or user if not parsed_stdin and len(sys.argv) > 1: as_input = " ".join(sys.argv[1:]) parsed_stdin = True print(f"{get_flair()}> {as_input}") elif session and gtff.USE_PROMPT_TOOLKIT: as_input = session.prompt(f"{get_flair()}> ", completer=completer) else: as_input = input(f"{get_flair()}> ") # Is command empty if not as_input: print("") continue # Parse main command of the list of possible commands try: (ns_known_args, l_args) = menu_parser.parse_known_args(as_input.split()) except SystemExit: print("The command selected doesn't exist\n") continue b_quit = False if ns_known_args.opt == "help": should_print_help = True elif (ns_known_args.opt == "quit") or (ns_known_args.opt == "q"): break elif ns_known_args.opt == "clear": s_ticker, s_start, s_interval, df_stock = clear( l_args, s_ticker, s_start, s_interval, df_stock) main_cmd = True elif ns_known_args.opt == "load": s_ticker, s_start, s_interval, df_stock = load( l_args, s_ticker, s_start, s_interval, df_stock) main_cmd = True elif ns_known_args.opt == "candle": if s_ticker: candle( s_ticker, (datetime.now() - timedelta(days=180)).strftime("%Y-%m-%d"), ) else: print( "No ticker selected. Use 'load ticker' to load the ticker you want to look at.", "\n", ) main_cmd = True elif ns_known_args.opt == "view": if s_ticker: view(l_args, s_ticker, s_start, s_interval, df_stock) else: print( "No ticker selected. Use 'load ticker' to load the ticker you want to look at." ) main_cmd = True elif ns_known_args.opt == "export": export(l_args, df_stock) main_cmd = True elif ns_known_args.opt == "disc": b_quit = dm.disc_menu() elif ns_known_args.opt == "mill": b_quit = mill.papermill_menu() elif ns_known_args.opt == "ba": b_quit = ba_controller.menu(s_ticker, s_start) elif ns_known_args.opt == "res": b_quit = rm.res_menu(s_ticker, s_start, s_interval) elif ns_known_args.opt == "ca": b_quit = ca_controller.menu(df_stock, s_ticker, s_start, s_interval) elif ns_known_args.opt == "fa": b_quit = fam.fa_menu(s_ticker, s_start, s_interval) elif ns_known_args.opt == "ta": b_quit = tam.ta_menu(df_stock, s_ticker, s_start, s_interval) elif ns_known_args.opt == "dd": b_quit = ddm.dd_menu(df_stock, s_ticker, s_start, s_interval) elif ns_known_args.opt == "op": b_quit = opm.opt_menu(s_ticker) elif ns_known_args.opt == "fred": b_quit = fm.fred_menu() elif ns_known_args.opt == "port": b_quit = port_menu.port_menu() elif ns_known_args.opt == "pred": if not gtff.ENABLE_PREDICT: print("Predict is not enabled in feature_flags.py") print("Prediction menu is disabled") print("") continue try: # pylint: disable=import-outside-toplevel from gamestonk_terminal.prediction_techniques import pred_menu as pm except ModuleNotFoundError as e: print("One of the optional packages seems to be missing") print("Optional packages need to be installed") print(e) print("") continue except Exception as e: print(e) print("") continue if s_interval == "1440min": b_quit = pm.pred_menu(df_stock, s_ticker, s_start, s_interval) # If stock data is intradaily, we need to get data again as prediction # techniques work on daily adjusted data. By default we load data from # Alpha Vantage because the historical data loaded gives a larger # dataset than the one provided by quandl else: try: ts = TimeSeries(key=cfg.API_KEY_ALPHAVANTAGE, output_format="pandas") # pylint: disable=unbalanced-tuple-unpacking df_stock_pred, _ = ts.get_daily_adjusted(symbol=s_ticker, outputsize="full") # pylint: disable=no-member df_stock_pred = df_stock_pred.sort_index(ascending=True) df_stock_pred = df_stock_pred[s_start:] b_quit = pm.pred_menu(df_stock_pred, s_ticker, s_start, s_interval="1440min") except Exception as e: print(e) print( "Either the ticker or the API_KEY are invalids. Try again!" ) return else: print("Shouldn't see this command!") continue if b_quit: break else: if not main_cmd: should_print_help = True print( "Hope you enjoyed the terminal. Remember that stonks only go up. Diamond hands.\n" )
def main(): completer = NestedCompleter.from_nested_dict( mainCommandsDict ) validator_main = Validator.from_callable( is_valid_main, error_message="Invalid command", move_cursor_to_end=True, ) try: server_addr = ('192.168.214.1', 8888) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: sock.bind(server_addr) sock.listen(1) print('Listening') connection, client_addr = sock.accept() while True: user_input = prompt(u' > ', history=FileHistory('history.txt'), validator=validator_main, completer=completer, ) while len(user_input.strip()) == 0: user_input = prompt(u' > ', history=FileHistory('history.txt'), validator=validator_main, completer=completer, ) if user_input.strip().split(' ')[0] == 'PULL': if len(user_input.strip().split(' ')) != 3: print('USAGE: PULL <remote file> <local save location> ') continue try: _, remote, local = user_input.split(' ') command, _ = user_input.rsplit(' ', 1) command = encode(command) connection.send(command.encode('utf-8')) with open(local, 'wb') as f: file = recv_all(connection) f.write(file) except FileNotFoundError: print(f'Can\'t find file {local}') continue elif user_input.strip().split(' ')[0] == 'PUSH': if len(user_input.strip().split(' ')) != 3: print('USAGE: PUSH <remote save location> <local file> ') continue try: _, remote, local = user_input.split(' ') command, _ = user_input.rsplit(' ', 1) command = encode(command) connection.send(command.encode('utf-8')) with open(local, 'rb') as f: part = f.read(1024) while part: connection.send(part) part = f.read(1024) except FileNotFoundError: print(f'Can\'t find file {local}') continue else: k = user_input[0] user_input = encode(user_input) connection.send(user_input.encode('utf-8')) time.sleep(.1) data = recv_all(connection) data = decode(data, k) print(data) print() except (KeyboardInterrupt, ConnectionResetError): print('Shutting down') exit(0)
#!/usr/bin/env python """ Example of nested autocompletion. """ from prompt_toolkit import prompt from prompt_toolkit.completion import NestedCompleter completer = NestedCompleter.from_nested_dict({ "show": { "version": None, "clock": None, "ip": { "interface": { "brief": None } } }, "exit": None, }) def main(): text = prompt("Type a command: ", completer=completer) print("You said: %s" % text) if __name__ == "__main__": main()