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()
