jerry/OpenBB
1
0
Fork 0
mirror of https://github.com/OpenBB-finance/OpenBB.git synced 2026-10-28 13:01:38 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #108 from DidierRLopes/improve-ta

Browse Source 
Improve TA plotting, dont block plots
This commit is contained in:
DidierRLopes
2021-03-06 19:16:15 +00:00
committed by GitHub
parent 30a23fe7bb a18932522f
commit 97bb344eec
9 changed files with 387 additions and 641 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
gamestonk_terminal/fundamental_analysis/business_insider_api.py
View File

@@ -86,7 +86,9 @@ def management(l_args, s_ticker):
for ind in df_management.index:
s_name = f"{ind}{(max([len(x) for x in df_management.index])-len(ind))*' '}"
s_title = f"{df_management['Title'][ind]}{(max([len(x) for x in df_management['Title']])-len(df_management['Title'][ind]))*' '}"
df_mgmt_title = df_management["Title"]
spaces = max([len(x) for x in df_mgmt_title]) - len(df_mgmt_title[ind])
s_title = f"{df_mgmt_title[ind]}{spaces * ' '}"
s_management = f"""{s_name} {s_title} {df_management['Info'][ind]}"""
print(s_management)
if df_management["Insider Activity"][ind] not in "-":

68
gamestonk_terminal/helper_funcs.py
View File

@@ -6,9 +6,12 @@ import sys
from pytz import timezone
import iso8601
import matplotlib.pyplot as plt
from holidays import US as holidaysUS
import pandas.io.formats.format
from pandas._config.config import get_option
from holidays import US as holidaysUS
from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()
def check_non_negative(value) -> int:
@@ -51,69 +54,6 @@ def plot_view_stock(df, symbol):
print("")
def plot_stock_ta(df_stock, s_ticker, df_ta, s_ta):
plt.plot(df_stock.index, df_stock.values, color="k")
plt.plot(df_ta.index, df_ta.values)
plt.title(f"{s_ta} on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
# Pandas series
if len(df_ta.shape) == 1:
l_legend = [s_ticker, s_ta]
# Pandas dataframe
else:
l_legend = df_ta.columns.tolist()
l_legend.insert(0, s_ticker)
plt.legend(l_legend)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
print("")
def plot_stock_and_ta(df_stock, s_ticker, df_ta, s_ta):
_, axPrice = plt.subplots()
plt.title(f"{s_ta} on {s_ticker}")
plt.plot(df_stock.index, df_stock.values, "k", lw=3)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel(f"Share Price of {s_ticker} ($)")
axTa = axPrice.twinx()
plt.plot(df_ta.index, df_ta.values)
# Pandas series
if len(df_ta.shape) == 1:
l_legend = [s_ta]
# Pandas dataframe
else:
l_legend = df_ta.columns.tolist()
plt.legend(l_legend)
axTa.set_ylabel(s_ta, color="tab:blue")
axTa.spines["right"].set_color("tab:blue")
axTa.tick_params(axis="y", colors="tab:blue")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
print("")
def plot_ta(s_ticker, df_ta, s_ta):
plt.plot(df_ta.index, df_ta.values)
plt.title(f"{s_ta} on {s_ticker}")
plt.xlim(df_ta.index[0], df_ta.index[-1])
plt.xlabel("Time")
# plt.ylabel('Share Price ($)')
# if isinstance(df_ta, pd.DataFrame):
# plt.legend(df_ta.columns)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
print("")
def b_is_stock_market_open() -> bool:
""" checks if the stock market is open """
# Get current US time

30
gamestonk_terminal/prediction_techniques/arima.py
View File

@@ -4,25 +4,27 @@ import pandas as pd
from pandas.plotting import register_matplotlib_converters
import pmdarima
from statsmodels.tsa.arima.model import ARIMA
from gamestonk_terminal.helper_funcs import check_positive, get_next_stock_market_days
from gamestonk_terminal.helper_funcs import (
check_positive,
get_next_stock_market_days,
parse_known_args_and_warn,
)
register_matplotlib_converters()
# -------------------------------------------------- ARIMA --------------------------------------------------
# pylint: disable=unused-argument
def arima(l_args, s_ticker, s_interval, df_stock):
def arima(l_args, s_ticker, df_stock):
parser = argparse.ArgumentParser(
prog="arima",
description="""
In statistics and econometrics, and in particular in time
series analysis, an autoregressive integrated moving average (ARIMA) model
is a generalization of an autoregressive moving average (ARMA) model. Both
of these models are fitted to time series data either to better understand
the data or to predict future points in the series (forecasting).
ARIMA(p,d,q) where parameters p, d, and q are non-negative integers, p is
the order (number of time lags) of the autoregressive model, d is the degree
of differencing (the number of times the data have had past values subtracted),
In statistics and econometrics, and in particular in time series analysis, an
autoregressive integrated moving average (ARIMA) model is a generalization of an
autoregressive moving average (ARMA) model. Both of these models are fitted to time
series data either to better understand the data or to predict future points in the
series (forecasting). ARIMA(p,d,q) where parameters p, d, and q are non-negative
integers, p is the order (number of time lags) of the autoregressive model, d is the
degree of differencing (the number of times the data have had past values subtracted),
and q is the order of the moving-average model.
""",
)
@@ -72,11 +74,7 @@ def arima(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Machine Learning model
if ns_parser.s_order:

343
gamestonk_terminal/technical_analysis/momentum.py
View File

@@ -2,12 +2,11 @@ import argparse
import matplotlib.pyplot as plt
import pandas_ta as ta
from pandas.plotting import register_matplotlib_converters
from gamestonk_terminal.helper_funcs import check_positive
from gamestonk_terminal.helper_funcs import check_positive, parse_known_args_and_warn
register_matplotlib_converters()
# ----------------------------------------------------- CCI -----------------------------------------------------
def cci(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="cci",
@@ -49,11 +48,7 @@ def cci(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -66,30 +61,6 @@ def cci(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.title(f"Commodity Channel Index (CCI) on {s_ticker}")
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(100, plt.gca().get_ylim()[1], facecolor="r", alpha=0.2)
plt.axhspan(plt.gca().get_ylim()[0], -100, facecolor="g", alpha=0.2)
plt.axhline(100, linewidth=3, color="r", ls="--")
plt.axhline(-100, linewidth=3, color="g", ls="--")
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.2, 0.8], ("OVERSOLD", "OVERBOUGHT"))
plt.show()
# Intraday
else:
df_ta = ta.cci(
@@ -101,29 +72,35 @@ def cci(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.title(f"Commodity Channel Index (CCI) on {s_ticker}")
plt.figure()
plt.subplot(211)
plt.title(f"Commodity Channel Index (CCI) on {s_ticker}")
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
else:
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(100, plt.gca().get_ylim()[1], facecolor="r", alpha=0.2)
plt.axhspan(plt.gca().get_ylim()[0], -100, facecolor="g", alpha=0.2)
plt.axhline(100, linewidth=3, color="r", ls="--")
plt.axhline(-100, linewidth=3, color="g", ls="--")
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.2, 0.8], ("OVERSOLD", "OVERBOUGHT"))
plt.show()
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(100, plt.gca().get_ylim()[1], facecolor="r", alpha=0.2)
plt.axhspan(plt.gca().get_ylim()[0], -100, facecolor="g", alpha=0.2)
plt.axhline(100, linewidth=3, color="r", ls="--")
plt.axhline(-100, linewidth=3, color="g", ls="--")
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.2, 0.8], ("OVERSOLD", "OVERBOUGHT"))
plt.ion()
plt.show()
print("")
except Exception as e:
@@ -131,7 +108,6 @@ def cci(l_args, s_ticker, s_interval, df_stock):
print("")
# ----------------------------------------------------- MACD -----------------------------------------------------
def macd(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="macd",
@@ -185,11 +161,7 @@ def macd(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -201,32 +173,6 @@ def macd(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.title(f"Moving Average Convergence Divergence (MACD) on {s_ticker}")
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "b", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "r", lw=2)
plt.bar(df_ta.index, df_ta.iloc[:, 1].values, color="g")
plt.legend(
[
f"MACD Line {df_ta.columns[0]}",
f"Signal Line {df_ta.columns[2]}",
f"Histogram {df_ta.columns[1]}",
]
)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.xlabel("Time")
plt.show()
# Intraday
else:
df_ta = ta.macd(
@@ -237,31 +183,36 @@ def macd(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.title(f"Moving Average Convergence Divergence (MACD) on {s_ticker}")
plt.figure()
plt.subplot(211)
plt.title(f"Moving Average Convergence Divergence (MACD) on {s_ticker}")
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
else:
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "b", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "r", lw=2)
plt.bar(df_ta.index, df_ta.iloc[:, 1].values, color="g")
plt.legend(
[
f"MACD Line {df_ta.columns[0]}",
f"Signal Line {df_ta.columns[2]}",
f"Histogram {df_ta.columns[1]}",
]
)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.xlabel("Time")
plt.show()
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "b", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "r", lw=2)
plt.bar(df_ta.index, df_ta.iloc[:, 1].values, color="g")
plt.legend(
[
f"MACD Line {df_ta.columns[0]}",
f"Signal Line {df_ta.columns[2]}",
f"Histogram {df_ta.columns[1]}",
]
)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.xlabel("Time")
plt.ion()
plt.show()
print("")
except Exception as e:
@@ -269,7 +220,6 @@ def macd(l_args, s_ticker, s_interval, df_stock):
print("")
# ----------------------------------------------------- RSI -----------------------------------------------------
def rsi(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="rsi",
@@ -320,11 +270,7 @@ def rsi(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -336,31 +282,6 @@ def rsi(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
plt.title(f"Relative Strength Index (RSI) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(70, 100, facecolor="r", alpha=0.2)
plt.axhspan(0, 30, facecolor="g", alpha=0.2)
plt.axhline(70, linewidth=3, color="r", ls="--")
plt.axhline(30, linewidth=3, color="g", ls="--")
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.15, 0.85], ("OVERSOLD", "OVERBOUGHT"))
plt.show()
# Intraday
else:
df_ta = ta.rsi(
@@ -371,30 +292,36 @@ def rsi(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.figure()
plt.subplot(211)
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
else:
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.title(f"Relative Strength Index (RSI) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(70, 100, facecolor="r", alpha=0.2)
plt.axhspan(0, 30, facecolor="g", alpha=0.2)
plt.axhline(70, linewidth=3, color="r", ls="--")
plt.axhline(30, linewidth=3, color="g", ls="--")
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.15, 0.85], ("OVERSOLD", "OVERBOUGHT"))
plt.show()
plt.title(f"Relative Strength Index (RSI) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=2)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(70, 100, facecolor="r", alpha=0.2)
plt.axhspan(0, 30, facecolor="g", alpha=0.2)
plt.axhline(70, linewidth=3, color="r", ls="--")
plt.axhline(30, linewidth=3, color="g", ls="--")
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.15, 0.85], ("OVERSOLD", "OVERBOUGHT"))
plt.ion()
plt.show()
print("")
except Exception as e:
@@ -402,7 +329,6 @@ def rsi(l_args, s_ticker, s_interval, df_stock):
print("")
# ----------------------------------------------------- STOCH -----------------------------------------------------
def stoch(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="stoch",
@@ -453,11 +379,7 @@ def stoch(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -471,33 +393,6 @@ def stoch(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
plt.title(f"Stochastic Relative Strength Index (STOCH RSI) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "k", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "b", lw=2, ls="--")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(80, 100, facecolor="r", alpha=0.2)
plt.axhspan(0, 20, facecolor="g", alpha=0.2)
plt.axhline(80, linewidth=3, color="r", ls="--")
plt.axhline(20, linewidth=3, color="g", ls="--")
plt.legend([f"%K {df_ta.columns[0]}", f"%D {df_ta.columns[1]}"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.1, 0.9], ("OVERSOLD", "OVERBOUGHT"))
plt.show()
# Intraday
else:
df_ta = ta.stoch(
@@ -510,32 +405,38 @@ def stoch(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.figure()
plt.subplot(211)
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
else:
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.title(f"Stochastic Relative Strength Index (STOCH RSI) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "k", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "b", lw=2, ls="--")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(80, 100, facecolor="r", alpha=0.2)
plt.axhspan(0, 20, facecolor="g", alpha=0.2)
plt.axhline(80, linewidth=3, color="r", ls="--")
plt.axhline(20, linewidth=3, color="g", ls="--")
plt.legend([f"%K {df_ta.columns[0]}", f"%D {df_ta.columns[1]}"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.1, 0.9], ("OVERSOLD", "OVERBOUGHT"))
plt.show()
plt.title(f"Stochastic Relative Strength Index (STOCH RSI) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "k", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "b", lw=2, ls="--")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhspan(80, 100, facecolor="r", alpha=0.2)
plt.axhspan(0, 20, facecolor="g", alpha=0.2)
plt.axhline(80, linewidth=3, color="r", ls="--")
plt.axhline(20, linewidth=3, color="g", ls="--")
plt.legend([f"%K {df_ta.columns[0]}", f"%D {df_ta.columns[1]}"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.gca().twinx()
plt.ylim(plt.gca().get_ylim())
plt.yticks([0.1, 0.9], ("OVERSOLD", "OVERBOUGHT"))
plt.ion()
plt.show()
print("")
except Exception as e:

184
gamestonk_terminal/technical_analysis/overlap.py
View File

@@ -2,12 +2,11 @@ import argparse
import matplotlib.pyplot as plt
import pandas_ta as ta
from pandas.plotting import register_matplotlib_converters
from gamestonk_terminal.helper_funcs import check_positive, plot_stock_ta
from gamestonk_terminal.helper_funcs import check_positive, parse_known_args_and_warn
register_matplotlib_converters()
# ----------------------------------------------------- EMA -----------------------------------------------------
def ema(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="ema",
@@ -43,11 +42,7 @@ def ema(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -56,12 +51,6 @@ def ema(l_args, s_ticker, s_interval, df_stock):
length=ns_parser.n_length,
offset=ns_parser.n_offset,
).dropna()
plot_stock_ta(
df_stock["5. adjusted close"],
s_ticker,
df_ta,
f"{ns_parser.n_length} EMA",
)
# Intraday
else:
@@ -70,16 +59,49 @@ def ema(l_args, s_ticker, s_interval, df_stock):
length=ns_parser.n_length,
offset=ns_parser.n_offset,
).dropna()
plot_stock_ta(
df_stock["4. close"], s_ticker, df_ta, f"{ns_parser.n_length} EMA"
_, axPrice = plt.subplots()
plt.title(f"{ns_parser.n_length} EMA on {s_ticker}")
if s_interval == "1440min":
plt.plot(
df_stock["5. adjusted close"].index,
df_stock["5. adjusted close"].values,
"k",
lw=3,
)
plt.xlim(
df_stock["5. adjusted close"].index[0],
df_stock["5. adjusted close"].index[-1],
)
else:
plt.plot(df_stock["4. close"].index, df_stock["4. close"].values, "k", lw=3)
plt.xlim(df_stock["4. close"].index[0], df_stock["4. close"].index[-1])
plt.xlabel("Time")
plt.ylabel(f"Share Price of {s_ticker} ($)")
axTa = axPrice.twinx()
plt.plot(df_ta.index, df_ta.values)
# Pandas series
if len(df_ta.shape) == 1:
l_legend = ["{ns_parser.n_length} EMA"]
# Pandas dataframe
else:
l_legend = df_ta.columns.tolist()
plt.legend(l_legend)
axTa.set_ylabel("{ns_parser.n_length} EMA", color="tab:blue")
axTa.spines["right"].set_color("tab:blue")
axTa.tick_params(axis="y", colors="tab:blue")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ion()
plt.show()
print("")
except Exception as e:
print(e)
print("")
# ----------------------------------------------------- SMA -----------------------------------------------------
def sma(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="sma",
@@ -113,55 +135,38 @@ def sma(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
ns_parser = parse_known_args_and_warn(parser, l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
# Daily
plt.figure()
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, color="k")
l_legend = list()
l_legend.append(s_ticker)
for length in ns_parser.l_length:
else:
plt.plot(df_stock.index, df_stock["4. close"].values, color="k")
l_legend = list()
l_legend.append(s_ticker)
for length in ns_parser.l_length:
if s_interval == "1440min":
df_ta = ta.sma(
df_stock["5. adjusted close"],
length=length,
offset=ns_parser.n_offset,
).dropna()
plt.plot(df_ta.index, df_ta.values)
l_legend.append(f"{length} SMA")
plt.title(f"SMA on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend(l_legend)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
# Intraday
else:
plt.plot(df_stock.index, df_stock["4. close"].values, color="k")
l_legend = list()
l_legend.append(s_ticker)
for length in ns_parser.n_length:
else:
df_ta = ta.sma(
df_stock["4. close"], length=length, offset=ns_parser.n_offset
).dropna()
plt.plot(df_ta.index, df_ta.values)
l_legend.append(f"{length} SMA")
plt.title(f"SMA on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend(l_legend)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
plt.plot(df_ta.index, df_ta.values)
l_legend.append(f"{length} SMA")
plt.title(f"SMA on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend(l_legend)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ion()
plt.show()
print("")
except Exception as e:
@@ -169,7 +174,6 @@ def sma(l_args, s_ticker, s_interval, df_stock):
print("")
# ----------------------------------------------------- VWAP -----------------------------------------------------
def vwap(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="vwap",
@@ -190,11 +194,7 @@ def vwap(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -206,29 +206,6 @@ def vwap(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
)
_, axPrice = plt.subplots()
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, color="k")
plt.plot(df_ta.index, df_ta.values)
plt.title(f"VWAP on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend([s_ticker, "VWAP"])
_ = axPrice.twinx()
plt.bar(
df_stock.index,
df_stock["6. volume"].values,
color="k",
alpha=0.8,
width=0.3,
)
plt.ylabel("Volume")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
print("")
# Intraday
else:
df_ta = ta.vwap(
@@ -239,15 +216,27 @@ def vwap(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
)
_, axPrice = plt.subplots()
_, axPrice = plt.subplots()
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, color="k")
else:
plt.plot(df_stock.index, df_stock["4. close"].values, color="k")
plt.plot(df_ta.index, df_ta.values)
plt.title(f"VWAP on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend([s_ticker, "VWAP"])
_ = axPrice.twinx()
plt.plot(df_ta.index, df_ta.values)
plt.title(f"VWAP on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend([s_ticker, "VWAP"])
_ = axPrice.twinx()
if s_interval == "1440min":
plt.bar(
df_stock.index,
df_stock["6. volume"].values,
color="k",
alpha=0.8,
width=0.3,
)
else:
plt.bar(
df_stock.index,
df_stock["5. volume"].values,
@@ -255,12 +244,13 @@ def vwap(l_args, s_ticker, s_interval, df_stock):
alpha=0.8,
width=0.3,
)
plt.ylabel("Volume")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
print("")
plt.ylabel("Volume")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ion()
plt.show()
print("")
except Exception as e:
print(e)

27
gamestonk_terminal/technical_analysis/ta_menu.py
View File

@@ -5,9 +5,9 @@ from gamestonk_terminal.technical_analysis import momentum as ta_momentum
from gamestonk_terminal.technical_analysis import trend as ta_trend
from gamestonk_terminal.technical_analysis import volatility as ta_volatility
from gamestonk_terminal.technical_analysis import volume as ta_volume
import matplotlib.pyplot as plt
# -----------------------------------------------------------------------------------------------------------------------
def print_technical_analysis(s_ticker, s_start, s_interval):
""" Print help """
@@ -42,7 +42,6 @@ def print_technical_analysis(s_ticker, s_start, s_interval):
print("")
# ---------------------------------------------------- MENU ----------------------------------------------------
def ta_menu(df_stock, s_ticker, s_start, s_interval):
# Add list of arguments that the technical analysis parser accepts
@@ -55,18 +54,18 @@ def ta_menu(df_stock, s_ticker, s_start, s_interval):
"quit",
"ema",
"sma",
"vwap", # overlap
"vwap",
"cci",
"macd",
"rsi",
"stoch", # momentum
"stoch",
"adx",
"aroon", # trend
"bbands", # volatility
"aroon",
"bbands",
"ad",
"obv",
],
) # volume
)
print_technical_analysis(s_ticker, s_start, s_interval)
@@ -75,6 +74,9 @@ def ta_menu(df_stock, s_ticker, s_start, s_interval):
# Get input command from user
as_input = input("> ")
# Images are non blocking - allows to close them if we type other command
plt.close()
# Parse fundamental analysis command of the list of possible commands
try:
(ns_known_args, l_args) = ta_parser.parse_known_args(as_input.split())
@@ -94,7 +96,7 @@ def ta_menu(df_stock, s_ticker, s_start, s_interval):
# Abandon the program
return True
# -------------------------------------------------- OVERLAP --------------------------------------------------
# OVERLAP
elif ns_known_args.cmd == "ema":
ta_overlap.ema(l_args, s_ticker, s_interval, df_stock)
@@ -104,7 +106,7 @@ def ta_menu(df_stock, s_ticker, s_start, s_interval):
elif ns_known_args.cmd == "vwap":
ta_overlap.vwap(l_args, s_ticker, s_interval, df_stock)
# --------------------------------------------------- MOMENTUM ---------------------------------------------------
# MOMENTUM
elif ns_known_args.cmd == "cci":
ta_momentum.cci(l_args, s_ticker, s_interval, df_stock)
@@ -117,24 +119,23 @@ def ta_menu(df_stock, s_ticker, s_start, s_interval):
elif ns_known_args.cmd == "stoch":
ta_momentum.stoch(l_args, s_ticker, s_interval, df_stock)
# ---------------------------------------------------- TREND ----------------------------------------------------
# TREND
elif ns_known_args.cmd == "adx":
ta_trend.adx(l_args, s_ticker, s_interval, df_stock)
elif ns_known_args.cmd == "aroon":
ta_trend.aroon(l_args, s_ticker, s_interval, df_stock)
# -------------------------------------------------- VOLATILITY --------------------------------------------------
# VOLATILITY
elif ns_known_args.cmd == "bbands":
ta_volatility.bbands(l_args, s_ticker, s_interval, df_stock)
# ---------------------------------------------------- VOLUME ----------------------------------------------------
# VOLUME
elif ns_known_args.cmd == "ad":
ta_volume.ad(l_args, s_ticker, s_interval, df_stock)
elif ns_known_args.cmd == "obv":
ta_volume.obv(l_args, s_ticker, s_interval, df_stock)
# ------------------------------------------------------------------------------------------------------------
else:
print("Command not recognized!")

112
gamestonk_terminal/technical_analysis/trend.py
View File

@@ -2,12 +2,11 @@ import argparse
import matplotlib.pyplot as plt
import pandas_ta as ta
from pandas.plotting import register_matplotlib_converters
from gamestonk_terminal.helper_funcs import check_positive
from gamestonk_terminal.helper_funcs import check_positive, parse_known_args_and_warn
register_matplotlib_converters()
# ----------------------------------------------------- ADX -----------------------------------------------------
def adx(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="adx",
@@ -56,11 +55,7 @@ def adx(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -74,34 +69,6 @@ def adx(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
plt.title(f"Average Directional Movement Index (ADX) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "b", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "g", lw=1)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "r", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(25, linewidth=3, color="k", ls="--")
plt.legend(
[
f"ADX ({df_ta.columns[0]})",
f"+DI ({df_ta.columns[1]})",
f"- DI ({df_ta.columns[2]})",
]
)
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.show()
# Intraday
else:
df_ta = ta.adx(
@@ -114,33 +81,8 @@ def adx(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.subplot(211)
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.title(f"Average Directional Movement Index (ADX) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "b", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "g", lw=1)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "r", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(25, linewidth=3, color="k", ls="--")
plt.legend(
[
f"ADX ({df_ta.columns[0]})",
f"+DI ({df_ta.columns[1]})",
f"- DI ({df_ta.columns[2]})",
]
)
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.show()
plot_adx(df_stock, s_ticker, df_ta)
print("")
except Exception as e:
@@ -148,7 +90,38 @@ def adx(l_args, s_ticker, s_interval, df_stock):
print("")
# ----------------------------------------------------- AROON -----------------------------------------------------
def plot_adx(df_stock, s_ticker, df_ta):
plt.figure()
plt.subplot(211)
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.title(f"Average Directional Movement Index (ADX) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "b", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "g", lw=1)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "r", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(25, linewidth=3, color="k", ls="--")
plt.legend(
[
f"ADX ({df_ta.columns[0]})",
f"+DI ({df_ta.columns[1]})",
f"- DI ({df_ta.columns[2]})",
]
)
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.ion()
plt.show()
def aroon(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="aroon",
@@ -195,11 +168,7 @@ def aroon(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
df_ta = ta.aroon(
high=df_stock["2. high"],
@@ -209,21 +178,22 @@ def aroon(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
plt.figure()
plt.subplot(311)
# Daily
if s_interval == "1440min":
# plot_stock_and_ta(df_stock['5. adjusted close'], s_ticker, df_ta.iloc[:,-1], "AROON")
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
# Intraday
else:
# plot_stock_and_ta(df_stock['4. close'], s_ticker, df_ta.iloc[:,-1], "AROON")
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.title(f"Aroon on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.subplot(312)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "r", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "g", lw=2)
@@ -236,6 +206,7 @@ def aroon(l_args, s_ticker, s_interval, df_stock):
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([0, 100])
plt.subplot(313)
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "b", lw=2)
plt.xlabel("Time")
@@ -244,6 +215,7 @@ def aroon(l_args, s_ticker, s_interval, df_stock):
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ylim([-100, 100])
plt.ion()
plt.show()
print("")

93
gamestonk_terminal/technical_analysis/volatility.py
View File

@@ -2,12 +2,11 @@ import argparse
import matplotlib.pyplot as plt
import pandas_ta as ta
from pandas.plotting import register_matplotlib_converters
from gamestonk_terminal.helper_funcs import check_positive
from gamestonk_terminal.helper_funcs import check_positive, parse_known_args_and_warn
register_matplotlib_converters()
# ----------------------------------------------------- BBANDS -----------------------------------------------------
def bbands(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="bbands",
@@ -15,13 +14,13 @@ def bbands(l_args, s_ticker, s_interval, df_stock):
Bollinger Bands consist of three lines. The middle band is a simple
moving average (generally 20 periods) of the typical price (TP). The upper and lower
bands are F standard deviations (generally 2) above and below the middle band.
The bands widen and narrow when the volatility of the price is higher or lower, respectively.
\n \nBollinger Bands do not, in themselves, generate buy or sell signals; they are an
indicator of overbought or oversold conditions. When the price is near the upper or lower
band it indicates that a reversal may be imminent. The middle band becomes a support or
resistance level. The upper and lower bands can also be interpreted as price targets.
When the price bounces off of the lower band and crosses the middle band, then the
upper band becomes the price target.
The bands widen and narrow when the volatility of the price is higher or lower,
respectively. \n \nBollinger Bands do not, in themselves, generate buy or sell signals;
they are an indicator of overbought or oversold conditions. When the price is near the
upper or lower band it indicates that a reversal may be imminent. The middle band
becomes a support or resistance level. The upper and lower bands can also be
interpreted as price targets. When the price bounces off of the lower band and crosses
the middle band, then the upper band becomes the price target.
""",
)
@@ -57,11 +56,7 @@ def bbands(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -72,30 +67,6 @@ def bbands(l_args, s_ticker, s_interval, df_stock):
mamode=ns_parser.s_mamode,
offset=ns_parser.n_offset,
).dropna()
# plot_stock_ta(df_stock['5. adjusted close'], s_ticker, df_ta, "BBANDS")
plt.plot(
df_stock.index, df_stock["5. adjusted close"].values, color="k", lw=3
)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "r", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "b", lw=1.5, ls="--")
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "g", lw=2)
plt.title(f"Bollinger Band (BBands) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend([s_ticker, df_ta.columns[0], df_ta.columns[1], df_ta.columns[2]])
plt.gca().fill_between(
df_ta.index,
df_ta.iloc[:, 0].values,
df_ta.iloc[:, 2].values,
alpha=0.1,
color="b",
)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
# Intraday
else:
@@ -106,28 +77,34 @@ def bbands(l_args, s_ticker, s_interval, df_stock):
mamode=ns_parser.s_mamode,
offset=ns_parser.n_offset,
).dropna()
# plot_stock_ta(df_stock['4. close'], s_ticker, df_ta, "BBANDS")
plt.plot(df_stock.index, df_stock["4. close"].values, color="k", lw=3)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "r", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "b", lw=1.5, ls="--")
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "g", lw=2)
plt.title(f"Bollinger Band (BBands) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend([s_ticker, df_ta.columns[0], df_ta.columns[1], df_ta.columns[2]])
plt.gca().fill_between(
df_ta.index,
df_ta.iloc[:, 0].values,
df_ta.iloc[:, 2].values,
alpha=0.1,
color="b",
plt.figure()
if s_ticker == "1440min":
plt.plot(
df_stock.index, df_stock["5. adjusted close"].values, color="k", lw=3
)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
else:
plt.plot(df_stock.index, df_stock["4. close"].values, color="k", lw=3)
plt.plot(df_ta.index, df_ta.iloc[:, 0].values, "r", lw=2)
plt.plot(df_ta.index, df_ta.iloc[:, 1].values, "b", lw=1.5, ls="--")
plt.plot(df_ta.index, df_ta.iloc[:, 2].values, "g", lw=2)
plt.title(f"Bollinger Band (BBands) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.xlabel("Time")
plt.ylabel("Share Price ($)")
plt.legend([s_ticker, df_ta.columns[0], df_ta.columns[1], df_ta.columns[2]])
plt.gca().fill_between(
df_ta.index,
df_ta.iloc[:, 0].values,
df_ta.iloc[:, 2].values,
alpha=0.1,
color="b",
)
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ion()
plt.show()
print("")
except Exception as e:

167
gamestonk_terminal/technical_analysis/volume.py
View File

@@ -2,12 +2,11 @@ import argparse
import matplotlib.pyplot as plt
import pandas_ta as ta
from pandas.plotting import register_matplotlib_converters
from gamestonk_terminal.helper_funcs import check_positive
from gamestonk_terminal.helper_funcs import check_positive, parse_known_args_and_warn
register_matplotlib_converters()
# ------------------------------------------------------- AD -------------------------------------------------------
def ad(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="ad",
@@ -43,11 +42,7 @@ def ad(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -71,33 +66,6 @@ def ad(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
axPrice = plt.subplot(211)
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
plt.title(f"Accumulation/Distribution Line (AD) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
_ = axPrice.twinx()
plt.bar(
df_stock.index,
df_stock["6. volume"].values,
color="k",
alpha=0.8,
width=0.3,
)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(0, linewidth=2, color="k", ls="--")
plt.legend(["Chaikin Oscillator"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
# Intraday
else:
# Use open stock values
@@ -120,15 +88,28 @@ def ad(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
axPrice = plt.subplot(211)
plt.figure()
axPrice = plt.subplot(211)
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
else:
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.title(f"Accumulation/Distribution Line (AD) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
_ = axPrice.twinx()
plt.title(f"Accumulation/Distribution Line (AD) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
_ = axPrice.twinx()
if s_interval == "1440min":
plt.bar(
df_stock.index,
df_stock["6. volume"].values,
color="k",
alpha=0.8,
width=0.3,
)
else:
plt.bar(
df_stock.index,
df_stock["5. volume"].values,
@@ -136,16 +117,17 @@ def ad(l_args, s_ticker, s_interval, df_stock):
alpha=0.8,
width=0.3,
)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(0, linewidth=2, color="k", ls="--")
plt.legend(["Chaikin Oscillator"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.axhline(0, linewidth=2, color="k", ls="--")
plt.legend(["Chaikin Oscillator"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ion()
plt.show()
print("")
except Exception as e:
@@ -154,7 +136,6 @@ def ad(l_args, s_ticker, s_interval, df_stock):
return
# ------------------------------------------------------- OBV -------------------------------------------------------
def obv(l_args, s_ticker, s_interval, df_stock):
parser = argparse.ArgumentParser(
prog="obv",
@@ -180,11 +161,7 @@ def obv(l_args, s_ticker, s_interval, df_stock):
)
try:
(ns_parser, l_unknown_args) = parser.parse_known_args(l_args)
if l_unknown_args:
print(f"The following args couldn't be interpreted: {l_unknown_args}\n")
return
ns_parser = parse_known_args_and_warn(parser, l_args)
# Daily
if s_interval == "1440min":
@@ -194,32 +171,6 @@ def obv(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
axPrice = plt.subplot(211)
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
plt.title(f"On-Balance Volume (OBV) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
_ = axPrice.twinx()
plt.bar(
df_stock.index,
df_stock["6. volume"].values,
color="k",
alpha=0.8,
width=0.3,
)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.legend(["OBV"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
# Intraday
else:
df_ta = ta.obv(
@@ -228,15 +179,28 @@ def obv(l_args, s_ticker, s_interval, df_stock):
offset=ns_parser.n_offset,
).dropna()
axPrice = plt.subplot(211)
plt.figure()
axPrice = plt.subplot(211)
if s_interval == "1440min":
plt.plot(df_stock.index, df_stock["5. adjusted close"].values, "k", lw=2)
plt.title(f"On-Balance Volume (OBV) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
_ = axPrice.twinx()
else:
plt.plot(df_stock.index, df_stock["4. close"].values, "k", lw=2)
plt.title(f"On-Balance Volume (OBV) on {s_ticker}")
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.ylabel("Share Price ($)")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
_ = axPrice.twinx()
if s_interval == "1440min":
plt.bar(
df_stock.index,
df_stock["6. volume"].values,
color="k",
alpha=0.8,
width=0.3,
)
else:
plt.bar(
df_stock.index,
df_stock["5. volume"].values,
@@ -244,15 +208,16 @@ def obv(l_args, s_ticker, s_interval, df_stock):
alpha=0.8,
width=0.3,
)
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.legend(["OBV"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.show()
plt.subplot(212)
plt.plot(df_ta.index, df_ta.values, "b", lw=1)
plt.xlim(df_stock.index[0], df_stock.index[-1])
plt.legend(["OBV"])
plt.xlabel("Time")
plt.grid(b=True, which="major", color="#666666", linestyle="-")
plt.minorticks_on()
plt.grid(b=True, which="minor", color="#999999", linestyle="-", alpha=0.2)
plt.ion()
plt.show()
print("")