def menu():
crypto_controller = CryptoController()
crypto_controller.print_help(crypto_controller.current_coin)
plt.close("all")
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in crypto_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (crypto)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (crypto)> ")
try:
process_input = crypto_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():
"""Onchain Menu"""
onchain_controller = OnchainController()
onchain_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in onchain_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (crypto)>(onchain)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (crypto)>(onchain)> ")
try:
process_input = onchain_controller.switch(an_input)
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 menu():
"""Screener Menu"""
scr_controller = ScreenerController()
scr_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in scr_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (stocks)>(scr)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (stocks)>(scr)> ")
try:
plt.close("all")
process_input = scr_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(ticker: str, start: str, interval: str, stock: pd.DataFrame):
"""Insider Menu"""
ins_controller = InsiderController(ticker, start, interval, stock)
ins_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None for c in ins_controller.CHOICES}
)
an_input = session.prompt(
f"{get_flair()} (stocks)>(ins)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (stocks)>(ins)> ")
try:
process_input = ins_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():
"""Portfolio Analysis Menu"""
port_controller = PortfolioController()
port_controller.print_help(port_controller.broker_list)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in port_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (pa)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (pa)> ")
try:
process_input = port_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():
"""Econ Menu"""
econ_controller = EconomyController()
econ_controller.print_help()
# Loop forever and ever
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in econ_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (economy)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (economy)> ")
try:
process_input = econ_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():
"""Resource Collection Menu"""
rc_controller = ResourceCollectionController()
rc_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None for c in rc_controller.CHOICES}
)
an_input = session.prompt(
f"{get_flair()} (resources)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (resources)> ")
try:
process_input = rc_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(ticker: str, start: datetime, interval: str):
"""Research Menu"""
res_controller = ResearchController(ticker, start, interval)
res_controller.call_help(None)
print("")
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in res_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (stocks)>(res)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (stocks)>(res)> ")
try:
process_input = res_controller.switch(an_input)
print("")
if process_input is not None:
return process_input
except SystemExit:
print("The command selected doesn't exist\n")
continue
def menu():
"""Forex Menu"""
fx_controller = ForexController()
fx_controller.call_help(None)
while True:
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None for c in fx_controller.CHOICES}
)
an_input = session.prompt(
f"{get_flair()} (forex)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (forex)> ")
try:
process_input = fx_controller.switch(an_input)
if process_input is not None:
return process_input
except SystemExit:
print("The command selected doesn't exit\n")
continue
def menu():
"""Degiro Menu"""
# SETUP CONTROLLER
degiro_controller = DegiroController()
degiro_controller.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 degiro_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (pa)>(degiro)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (pa)>(degiro)> ")
try:
process_input = degiro_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():
"""Discovery Menu"""
disc_controller = DiscoveryController()
disc_controller.call_help(None)
# Loop forever and ever
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None for c in disc_controller.CHOICES}
)
an_input = session.prompt(
f"{get_flair()} (disc)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (disc)> ")
try:
plt.close("all")
process_input = disc_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(ticker: str, start: Union[str, datetime]):
"""Backtesting Menu"""
plt.close("all")
bt_controller = BacktestingController(ticker, start)
bt_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in bt_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (stocks)>(bt)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (stocks)>(bt)> ")
try:
plt.close("all")
process_input = bt_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(ticker: str, start: datetime, context: str = ""):
"""Behavioural Analysis Menu"""
ba_controller = BehaviouralAnalysisController(ticker, start)
ba_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 ba_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} {context}(ba)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} {context}(ba)> ")
try:
process_input = ba_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(ticker: str):
"""Options info Menu."""
op_controller = OptionsController(ticker)
op_controller.call_help(None)
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(tickers: List[str]):
"""Portfolio Optimization Menu"""
if tickers == [""]:
tickers = []
plt.close("all")
po_controller = PortfolioOptimization(tickers)
po_controller.call_help(tickers)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in po_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (po)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (po)> ")
try:
plt.close("all")
process_input = po_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(stock: pd.DataFrame, ticker: str, start: datetime, interval: str):
"""Technical Analysis Menu"""
ta_controller = TechnicalAnalysisController(stock, ticker, start, interval)
ta_controller.call_help(None)
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()} (ta)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (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 menu():
robinhood_controller = RobinhoodController()
robinhood_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 robinhood_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (bro)>(rh)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (bro)>(rh)> ")
try:
process_input = robinhood_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(coin=None, source=None):
source = source if source else "cg"
dd_controller = DueDiligenceController(coin=coin, source=source)
dd_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 dd_controller.CHOICES}
)
an_input = session.prompt(
f"{get_flair()} (crypto)>(dd)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (crypto)>(dd)> ")
try:
process_input = dd_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 opt_menu(s_ticker):
# Add list of arguments that the options parser accepts
opt_parser = argparse.ArgumentParser(prog="opt", add_help=False)
choices = ["help", "q", "quit", "volume", "oi"]
opt_parser.add_argument("cmd", choices=choices)
completer = NestedCompleter.from_nested_dict({c: None for c in choices})
# print_options(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()} (opt)> ",
completer=completer,
)
else:
as_input = input(f"{get_flair()} (opt)> ")
# Parse fundamental analysis command of the list of possible commands
try:
(ns_known_args,
l_args) = opt_parser.parse_known_args(as_input.split())
except SystemExit:
print("The command selected doesn't exist\n")
continue
if ns_known_args.cmd == "help":
pass
# print_options(s_ticker)
elif ns_known_args.cmd == "q":
# Just leave the options menu
return False
elif ns_known_args.cmd == "quit":
# Abandon the program
return True
elif ns_known_args.cmd == "volume":
# call the volume graph
vol.volume_graph(l_args, s_ticker)
elif ns_known_args.cmd == "oi":
# call the volume graph
vol.open_interest_graph(l_args, s_ticker)
else:
print("Command not recognized!")
def call_exp(self, _):
"""Process exp command."""
self.print_exp_dates(self.expiry_date, self.raw_data_options.options)
date_index_choices = list(
range(len(self.raw_data_options.options) - 1))
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in date_index_choices})
an_input = session.prompt(
f"{get_flair()} (exp)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (exp)> ")
try:
plt.close("all")
process_input = an_input
if process_input is not None:
try:
self.__set_exp_date(int(an_input))
print(
f"\nNew selected expiry date : [{self.expiry_date}]\n"
)
return
# menu(self.ticker, self)
except IndexError:
print(
f"\nSelection must be between [0 - {len(self.raw_data_options.options) - 1}]\n"
)
continue
except ValueError:
print("The command selected doesn't exist\n")
self.print_exp_dates(self.expiry_date,
self.raw_data_options.options)
except SystemExit:
print("The command selected doesn't exist\n")
continue
def menu(ticker: str = "",
start: str = "",
stock: pd.DataFrame = pd.DataFrame()):
"""Dark Pool Shorts Menu
Parameters
----------
stock : DataFrame
Due diligence stock dataframe
ticker : str
Due diligence ticker symbol
start : str
Start date of the stock data
"""
dps_controller = DarkPoolShortsController(ticker, start, stock)
dps_controller.call_help(None)
# Loop forever and ever
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in dps_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (stocks)>(dps)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (stocks)>(dps)> ")
try:
plt.close("all")
process_input = dps_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(ticker: str, start: str, interval: str, stock: pd.DataFrame):
"""Comparison Analysis Menu
Parameters
----------
ticker : str
Stock ticker
start : str
Time start
interval : str
Time interval
stock : pd.DataFrame
Stock data
"""
ca_controller = ComparisonAnalysisController(ticker, start, interval,
stock)
ca_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in ca_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (stocks)>(ca)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (stocks)>(ca)> ")
try:
plt.close("all")
process_input = ca_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(stock: DataFrame, ticker: str, start: str, interval: str):
"""Due Diligence Menu
Parameters
----------
stock : DataFrame
Due diligence stock dataframe
ticker : str
Due diligence ticker symbol
start : str
Start date of the stock data
interval : str
Stock data interval
"""
dd_controller = DueDiligenceController(stock, ticker, start, interval)
dd_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None for c in dd_controller.CHOICES}
)
an_input = session.prompt(
f"{get_flair()} (dd)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (dd)> ")
try:
process_input = dd_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(ticker: str, start: str, interval: str):
"""Fundamental Analysis menu
Parameters
----------
ticker : str
Fundamental analysis ticker symbol
start : str
Start date of the stock data
interval : str
Stock data interval
"""
fa_controller = FundamentalAnalysisController(ticker, start, interval)
fa_controller.call_help(None)
while True:
# Get input command from user
if session and gtff.USE_PROMPT_TOOLKIT:
completer = NestedCompleter.from_nested_dict(
{c: None
for c in fa_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (fa)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (fa)> ")
try:
process_input = fa_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():
"""Degiro Menu"""
# SETUP CREDENTIALS
credentials = Credentials(
int_account=None,
username=config.DG_USERNAME,
password=config.DG_PASSWORD,
one_time_password=None,
totp_secret_key=config.DG_TOTP_SECRET,
)
# SETUP CONTROLLER
degiro_controller = DegiroController(credentials=credentials)
degiro_controller.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 degiro_controller.CHOICES})
an_input = session.prompt(
f"{get_flair()} (pa)>(degiro)> ",
completer=completer,
)
else:
an_input = input(f"{get_flair()} (pa)>(degiro)> ")
try:
process_input = degiro_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():
"""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 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 menu(queue: List[str] = None):
"""NFT Menu"""
nft_controller = NFTController(queue=queue)
an_input = "HELP_ME"
while True:
# There is a command in the queue
if nft_controller.queue and len(nft_controller.queue) > 0:
# If the command is quitting the menu we want to return in here
if nft_controller.queue[0] in ("q", "..", "quit"):
if len(nft_controller.queue) > 1:
return nft_controller.queue[1:]
return []
# Consume 1 element from the queue
an_input = nft_controller.queue[0]
nft_controller.queue = nft_controller.queue[1:]
# Print the current location because this was an instruction and we want user to know what was the action
if an_input and an_input.split(" ")[0] in nft_controller.CHOICES_COMMANDS:
print(f"{get_flair()} /crypto/nft/ $ {an_input}")
# Get input command from user
else:
# Display help menu when entering on this menu from a level above
if an_input == "HELP_ME":
nft_controller.print_help()
# Get input from user using auto-completion
if session and gtff.USE_PROMPT_TOOLKIT and nft_controller.completer:
an_input = session.prompt(
f"{get_flair()} /crypto/nft/ $ ",
completer=nft_controller.completer,
search_ignore_case=True,
)
# Get input from user without auto-completion
else:
an_input = input(f"{get_flair()} /crypto/nft/ $ ")
try:
# Process the input command
nft_controller.queue = nft_controller.switch(an_input)
except SystemExit:
print(
f"\nThe command '{an_input}' doesn't exist on the /stocks/options menu.",
end="",
)
similar_cmd = difflib.get_close_matches(
an_input.split(" ")[0] if " " in an_input else an_input,
nft_controller.CHOICES,
n=1,
cutoff=0.7,
)
if similar_cmd:
if " " in an_input:
candidate_input = (
f"{similar_cmd[0]} {' '.join(an_input.split(' ')[1:])}"
)
if candidate_input == an_input:
an_input = ""
nft_controller.queue = []
print("\n")
continue
an_input = candidate_input
else:
an_input = similar_cmd[0]
print(f" Replacing by '{an_input}'.")
nft_controller.queue.insert(0, an_input)
else:
print("\n")
def terminal():
"""Terminal Menu"""
bootup()
process_input = False
t_controller = TerminalController()
if config_terminal.DEFAULT_CONTEXT:
if config_terminal.DEFAULT_CONTEXT in t_controller.CHOICES_MENUS:
try:
print("")
process_input = t_controller.switch(
config_terminal.DEFAULT_CONTEXT.lower())
except SystemExit:
print("")
else:
print("\nInvalid DEFAULT_CONTEXT config selected!", "\n")
if not process_input:
t_controller.print_help()
parsed_stdin = False
while True:
if gtff.ENABLE_QUICK_EXIT:
print("Quick exit enabled")
break
# Get input command from stdin or user
if not parsed_stdin and len(sys.argv) > 1:
an_input = " ".join(sys.argv[1:])
print(f"{get_flair()}> {an_input}")
parsed_stdin = True
elif session and gtff.USE_PROMPT_TOOLKIT:
an_input = session.prompt(f"{get_flair()}> ",
completer=t_controller.completer)
else:
an_input = input(f"{get_flair()}> ")
# Is command empty
if not an_input:
print("")
continue
# Process list of commands selected by user
try:
process_input = t_controller.switch(an_input)
# None - Keep loop
# True - Quit or Reset based on flag
# False - Keep loop and show help menu
if process_input is not None:
# Quit terminal
if process_input:
break
t_controller.print_help()
except SystemExit:
print("The command selected doesn't exist\n")
continue
if not gtff.ENABLE_QUICK_EXIT:
# Check if the user wants to reset application
if an_input == "reset" or t_controller.update_succcess:
ret_code = reset()
if ret_code != 0:
print_goodbye()
else:
print_goodbye()
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!")
