class Stats(object):
"""
docstring
"""
def __init__(self):
"""
docstring
"""
self.db = Database()
self.df = pd.DataFrame()
def get_data(self):
self.db.set_time_from("-120d")
self.df = self.db.load_data(TableName.DAY, symbols="jks")
return self.df
def get_volume_realtions(self):
df = self.get_data()
print(df.corr())
# print(df)
sns.pairplot(df, kind="scatter")
plt.show()
def linear_relations(self):
df = self.get_data()
print(linregress(df['close'], df['volume']))
plt.scatter(df['close'], df['volume'])
plt.show()
def __init__(self):
"""
docstring
"""
self.bs = BuySell()
self.db = Database()
self.bt = BackTest()
def __init__(self):
"""
docstring
"""
self.db = Database()
self.df = pd.DataFrame()
self.bt = BackTest()
def __init__(self):
self.db = Database()
self.bs = BuySell(
trading_strategy=TradingStrategies.LOGISTIC_REGRESSION,
trading_provider=TradingProviders.ALPACA,
fill_open_trades=OpenTradesSource.DB)
self.bs.close_alpaca_postition = True
self.spy_limit = 0
def __init__(self):
self.db = Database()
self.symbols = self.db.get_symbols(TableName.DAY)
self.sectors = self.db.get_sectors(TableName.DAY)
self.sm = StockMess()
self.app = self.get_home_page()
self.sw = StockWhisperer()
self.submit = None
def __init__(self):
self.db = Database()
self.df = self.db.load_data("p_day",
symbols=['SPY'],
time_from="-120d")
self.df = sdf.retype(self.df)
self.df = FinI.add_indicators(self.df)
self.app = self.get_home_page(self.df)
self.fig = None
class MPred():
data = pd.DataFrame()
def __init__(self):
"""
docstring
"""
self.db = Database()
def prepare_prop(self, sym):
# self.db.set_time_from("365d")
data = self.db.load_data("p_day", symbols=sym)
data["ds"] = pd.to_datetime(data.index, utc=True).tz_localize(None)
data["y"] = data.close
print(data)
m = Prophet(daily_seasonality=True) # the Prophet class (model)
m.fit(data) # fit the model using all data
self.plot_prediction(m, sym)
def plot_prediction(self, m, sym):
# we need to specify the number of days in future
future = m.make_future_dataframe(periods=365)
prediction = m.predict(future)
m.plot(prediction)
plt.title("Prediction using the Prophet: " + str(sym))
plt.gca().fmt_xdata = mpl.dates.DateFormatter('%Y-%m-%d')
plt.xlabel("Date")
plt.ylabel("Close Stock Price")
plt.show()
def logistic_regression_raw(db: Database, symbol="SPY"):
df = db.load_data(table_name=TableName.DAY,
time_from="-90D",
symbols=[symbol])
# m_df_spy = self.db.load_data(
# table_name=TableName.DAY, time_from=self.time_from, symbols=["SPY"])
df['open-close'] = df['close'] - df['open'].shift(1)
df['close-close'] = df['close'].shift(-1) - df['close']
# wrong close close only for research
df['close-close-prev'] = df['close'] - df['close'].shift(1)
df['S_9'] = df['close'].rolling(window=9).mean()
df['S_20'] = df['close'].rolling(window=20).mean()
# df['S_50'] = df['close'].rolling(window=50).mean()
# df['S_200'] = df['close'].rolling(window=200).mean()
df['Corr_9'] = df['close'].rolling(window=9).corr(df['S_9'])
df['Corr_20'] = df['close'].rolling(window=9).corr(df['S_20'])
df['RSI'] = ta.momentum.rsi(close=df['close'])
y = np.where(df['close'].shift(-1) > df['close'], 1, -1)
df = df[[
"Corr_9", "open-close", "close-close-prev", "RSI", "S_9", "close"
]]
# df = df[["Corr_9", "open-close", "close-close-prev", "RSI", "S_9"]]
df = df.dropna()
X = df.iloc[:, :30]
# st.write(len(y))
# st.write(len(X))
split = int(0.7 * len(df))
X_train, X_test, y_train, y_test = X[:split], X[split:], y[:split], y[
split:]
# We will instantiate the logistic regression in Python using ‘LogisticRegression’
# function and fit the model on the training dataset using ‘fit’ function.
model = LogisticRegression()
model = model.fit(X_train, y_train)
# Examine coeficients
# pd.DataFrame(zip(X.columns, np.transpose(model.coef_)))
# st.write("Examine The Coefficients")
# st.write(pd.DataFrame(zip(X.columns, np.transpose(model.coef_))))
#We will calculate the probabilities of the class for the test dataset using ‘predict_proba’ function.
probability = model.predict_proba(X_test)
df['Predicted_Signal'] = model.predict(X)
df = df.tail(len(probability))
df["prob_0"] = probability[:, 0]
df["prob_1"] = probability[:, 1]
df["sym"] = symbol
return df
def update_figure(input_value):
if len(input_value) > 1:
input_value = "SPY"
db = Database()
df = db.load_data("p_day", symbols=input_value, time_from="-120d")
df = sdf.retype(df)
df = FinI.add_indicators(df)
fig = go.Figure()
fig.add_trace(
go.Candlestick(x=df.index,
open=df['open'],
high=df['high'],
low=df['low'],
close=df['close']), )
fig.add_trace(go.Scatter(x=df.index, y=df.sma9))
fig.update_layout(transition_duration=500)
return fig
class RunDash():
def __init__(self):
self.db = Database()
self.df = self.db.load_data("p_day",
symbols=['SPY'],
time_from="-120d")
self.df = sdf.retype(self.df)
self.df = FinI.add_indicators(self.df)
self.app = self.get_home_page(self.df)
self.fig = None
# print(self.df)
def get_home_page(self, df):
# print(df.index)
self.fig = go.Figure()
symbols = ["NVDA", "PLUG", "AMD", "SPY"]
self.fig.add_trace(
go.Candlestick(x=df.index,
open=df['open'],
high=df['high'],
low=df['low'],
close=df['close']), )
self.fig.add_trace(go.Scatter(x=df.index, y=df.sma9))
app.layout = html.Div(children=[
html.H1(children='Stock prices'),
dcc.Dropdown(id='buyed_symbols',
options=[{
'label': i,
'value': i
} for i in symbols],
value='symbol'),
html.Br(),
html.Div(id="output"),
dcc.Graph(id='price-graph', figure=self.fig)
])
return app
def __init__(self) -> None:
db = Database()
stocks: pd.DataFrame
stocks_fs = db.load_data(table_name=TableName.DAY_FS, limit=1)
db_mode = "append"
if stocks_fs is not None and len(stocks_fs) > 0:
stocks = db.load_data(table_name=TableName.DAY,
time_from=stocks_fs.index[0])
else:
stocks = db.load_data(table_name=TableName.DAY, time_from="-500d")
db_mode = "replace"
symbols = db.get_symbols()
for sym in symbols:
if len(stocks) > 0:
stocks_sym = FinI.add_indicators(stocks[stocks.sym == sym])
# stocks.columns.drop(["symbol","sector","industry"])
# for idx, sym_s in stocks_sym.iterrows():
# sql_string = "".join(["select * from financials where symbol = '",
# str(sym_s.sym),
# "' and date::date <= date '",
# str(idx.replace(hour=23, minute=59)),
# "' order by date desc limit 1"])
# print(sql_string)
# financials = db.sql_select_query_data(sql_string)
# new_row = pd.concat([stocks_sym, financials], axis=1)
# new_row.to_sql(name="p_day_fs",
# if_exists="append", con=db.engine)
if stocks_sym is not None:
stocks_sym.to_sql(name="p_day_fs",
if_exists=db_mode,
con=db.engine)
print(stocks_sym)
utc = pytz.UTC
# from buy_sell import BuySell
# from sklearn import linear_model, preprocessing
from pytz import timezone
localtz = timezone('Europe/Prague')
# from plot_i import PlotI
# from fin_i import FinI
# from utils import Utils
# from check_indicators import CheckIndicators as chi
from alpaca_examples.market_db import Database, TableName
from buy_sell import BuySell
import logging
# import pytest
db = Database()
bs = BuySell()
data_intc = db.load_data(table_name=TableName.DAY,
time_from="-10d",
symbols=["INTC"])
data_amd = db.load_data(table_name=TableName.DAY,
time_from="-10d",
symbols=["AMD"])
def test_buy_sell_stock_t():
bs.buy_sell_open = pd.DataFrame()
bs.money = 10000
bs.buy_stock_t(data_intc.iloc[0],
data_intc.iloc[0].close,
class PredDT(object):
"""
docstring
"""
def __init__(self):
"""
docstring
"""
self.db = Database()
self.df = pd.DataFrame()
self.bt = BackTest()
def dt_prediction(self):
self.db.set_time_from("730d")
self.df = self.db.load_data(TableName.DAY,symbols='SPY')
# print(self.df)
self.add_sma(30)
self.add_sma(100)
print(self.df)
pass
def add_sma(self, days):
self.df["sma"+str(days)] = self.df['close'].rolling(window=days).mean()
def plot_data(self):
self.df.plot(kind="line", use_index=True,
y=["close","sma30","sma100"], legend=False, color=["b","orange","y"], linewidth=2, alpha=0.7)
plt.show()
def heatmap(self):
self.db.set_time_from("600d")
self.df = self.db.load_data(TableName.DAY, symbols='CHWY')
# calculate the correlation matrix
# self.df = ta.add_all_ta_features(self.df,open="open",close="close",high="high",low="low", volume="volume")
stocks = sdf.retype(self.df)
stocks = FinI.add_indicators(stocks)
stocks.get("macd")
stocks.get("kdjk")
stocks.get("boll")
stocks.get("sma")
print(stocks)
# stocks = FinI.add_day_types(stocks)
stocks.drop(columns=["open", "high", "low",
"sym", "sector", ], inplace=True)
print(stocks[['volume',"yearweek"]])
corr = stocks.corr()
corr = corr.round(1)
# print(corr)
# plot the heatmap
sns.heatmap(corr, annot=True, cmap="coolwarm",
xticklabels=corr.columns,
yticklabels=corr.columns)
plt.show()
def prediction(self):
df = self.df[['close']]
future_days = 25
# create the future date set X and convert it ti numpy array and remove last 'x' rows/days
df['Prediction'] = df[['close']].shift(-future_days)
X=np.array(df.drop(['Prediction'],1))[:-future_days]
# create the target data cell and get all of the target data
y=np.array(df['Prediction'])[:-future_days]
# print(y)
# lets split the data into 75% training and 25 %tresting
x_train,x_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)
# create decision tree regresor
tree = DecisionTreeRegressor().fit(x_train, y_train)
# create regresssion model
lr = LinearRegression().fit(x_train, y_train)
# get the last x rows of the future data set
x_future = df.drop(['Prediction'],1)[:-future_days]
x_future = x_future.tail(future_days)
x_future = np.array(x_future)
tree_prediction = tree.predict(x_future)
print(tree_prediction)
lr_prediction = lr.predict(x_future)
print()
print(lr_prediction)
# visualise predicted data
predictions = tree_prediction
valid = df[X.shape[0]:]
valid['Predictions'] = predictions
plt.figure(figsize=(16,8))
plt.title('days')
plt.xlabel('days')
plt.gca().fmt_xdata = mpl.dates.DateFormatter('%Y-%m-%d')
plt.grid(axis="both")
plt.ylabel("prediction")
plt.plot(df['close'])
plt.plot(valid[['close','Predictions']])
plt.legend(['Orig','Val', 'Pred'])
plt.show()
def __init__(self):
"""
docstring
"""
self.db = Database()
import pytz
utc = pytz.UTC
# from alpaca_examples.buy_sell import BuySell
# from sklearn import linear_model, preprocessing
from pytz import timezone
localtz = timezone('Europe/Prague')
from alpaca_examples.plot_i import PlotI
from alpaca_examples.fin_i import FinI
from alpaca_examples.utils import Utils
from alpaca_examples.check_indicators import CheckIndicators as chi
from alpaca_examples.market_db import Database, TableName
import pytest
db = Database()
sym = "INTC"
def test_get_nearest_values():
# price_levels = np.array([10,8,5,3,-1,-5,-10,-15])
df = db.load_data(table_name=TableName.DAY, symbols=[sym])
df = FinI.add_levels(df)
price = df.iloc[-1].close
low, high = FinI.get_nearest_values(
price_levels=df.price_level.dropna().tolist(), price=price)
print("low" + str(low))
print("high" + str(high))
assert low is not None and low[0] < price, "low array failed"
class Trading():
def __init__(self):
self.db = Database()
self.bs = BuySell(
trading_strategy=TradingStrategies.LOGISTIC_REGRESSION,
trading_provider=TradingProviders.ALPACA,
fill_open_trades=OpenTradesSource.DB)
self.bs.close_alpaca_postition = True
self.spy_limit = 0
def lr_best_candidate(self):
logging.warning("start")
df_best_buy = pd.DataFrame()
symbols = self.db.get_symbols()
prob_perc = 0.9
spy_lr_raw = self.logistic_regression_raw(self.db, symbol="SPY")
if spy_lr_raw.tail(1).iloc[0].prob_1 > self.spy_limit:
for sym in symbols:
try:
logging.info(f"filling: {sym}")
df_lr_raw = self.logistic_regression_raw(self.db, sym)
df_best_buy = df_best_buy.append(df_lr_raw.tail(1))
logging.info(sym + str(df_lr_raw.tail(1).iloc[0].prob_1))
logging.info("SPY: " +
str(spy_lr_raw.tail(1).iloc[0].prob_1))
# BUY
if df_lr_raw.tail(1).iloc[0].prob_1 > prob_perc:
self.bs.buy_stock_t(
stock=df_lr_raw.tail(1).iloc[0],
price=df_lr_raw.tail(1).iloc[0].close,
qty=1,
buy_already_buyed=True)
logging.info("Buy" + sym)
Utils.countdown(10)
# SELL
elif df_lr_raw.tail(
1
).iloc[0].prob_1 < prob_perc and sym in self.bs.buy_sell_open[
"sym"]:
self.bs.sell_stock_t(
sym=sym,
price=df_lr_raw.tail(1).iloc[0].close,
qty=1)
logging.info("Sell" + sym)
except Exception as e:
logging.info(e)
if len(df_best_buy) > 0:
logging.info(df_best_buy.sort_values(by="prob_1"))
else:
logging.error("no data")
else:
self.close_all_alpaca_postitions()
self.close_all_db_postitions()
logger.info("Buy prob: " + str(spy_lr_raw.tail(1).iloc[0].prob_1) +
" Sell prob: " +
str(spy_lr_raw.tail(1).iloc[0].prob_0))
def close_all_alpaca_postitions(self):
self.bs.close_all_alpaca_postitions()
def close_all_db_postitions(self):
self.bs.clean_all_db_postitions()
@staticmethod
def logistic_regression_raw(db: Database, symbol="SPY"):
df = db.load_data(table_name=TableName.DAY,
time_from="-90D",
symbols=[symbol])
# m_df_spy = self.db.load_data(
# table_name=TableName.DAY, time_from=self.time_from, symbols=["SPY"])
df['open-close'] = df['close'] - df['open'].shift(1)
df['close-close'] = df['close'].shift(-1) - df['close']
# wrong close close only for research
df['close-close-prev'] = df['close'] - df['close'].shift(1)
df['S_9'] = df['close'].rolling(window=9).mean()
df['S_20'] = df['close'].rolling(window=20).mean()
# df['S_50'] = df['close'].rolling(window=50).mean()
# df['S_200'] = df['close'].rolling(window=200).mean()
df['Corr_9'] = df['close'].rolling(window=9).corr(df['S_9'])
df['Corr_20'] = df['close'].rolling(window=9).corr(df['S_20'])
df['RSI'] = ta.momentum.rsi(close=df['close'])
y = np.where(df['close'].shift(-1) > df['close'], 1, -1)
df = df[[
"Corr_9", "open-close", "close-close-prev", "RSI", "S_9", "close"
]]
# df = df[["Corr_9", "open-close", "close-close-prev", "RSI", "S_9"]]
df = df.dropna()
X = df.iloc[:, :30]
# st.write(len(y))
# st.write(len(X))
split = int(0.7 * len(df))
X_train, X_test, y_train, y_test = X[:split], X[split:], y[:split], y[
split:]
# We will instantiate the logistic regression in Python using ‘LogisticRegression’
# function and fit the model on the training dataset using ‘fit’ function.
model = LogisticRegression()
model = model.fit(X_train, y_train)
# Examine coeficients
# pd.DataFrame(zip(X.columns, np.transpose(model.coef_)))
# st.write("Examine The Coefficients")
# st.write(pd.DataFrame(zip(X.columns, np.transpose(model.coef_))))
#We will calculate the probabilities of the class for the test dataset using ‘predict_proba’ function.
probability = model.predict_proba(X_test)
df['Predicted_Signal'] = model.predict(X)
df = df.tail(len(probability))
df["prob_0"] = probability[:, 0]
df["prob_1"] = probability[:, 1]
df["sym"] = symbol
return df
class Trader(object):
"""
docstring
"""
def __init__(self):
"""
docstring
"""
self.bs = BuySell()
self.db = Database()
self.bt = BackTest()
def load_data(self,
table_name=None,
symbols=None,
sectors=None,
limit=None):
symbols = symbols if symbols is not None else self.symbols
return sdf.retype(
self.db.load_data(table_name,
symbols=symbols,
sectors=sectors,
limit=limit))
def test_boll_rsi_macd(self, table_name=None, buy_now=False):
self.bs.buyed_stocks = 0
self.bs.money = self.bs.credit["start_amount"]
spy_stocks = self.load_data(table_name=table_name, symbols="SPY")
symbols = self.db.get_symbols()
print(str(symbols))
for symbol in symbols:
print("symbol: " + str(symbol))
stck = self.load_data(table_name=table_name, symbols=symbol)
if len(stck) < 1:
break
stck = self.bt.add_indicators(stck)
print("calculating percent change:" + str(symbol))
# stck = self.stocks.loc[self.stocks.sym ==symbol[0]].sort_values(by='index')
buy_now_process = buy_now
self.symbols = symbol[0]
cross_bollinger = 0
# self.prev_stock = stck.iloc[0]
# self.first_stock = stck.iloc[0]
# self.sell_marks = self.sell_marks.iloc[0:0]
# self.buy_marks = self.buy_marks.iloc[0:0]
self.transactions = 0
self.profit_perc = 0
for inx in range(50, len(stck)):
# def check_boll():
"""
docstring
"""
if stck.iloc[inx].boll >= stck.iloc[inx-1].close and \
stck.iloc[inx]['boll'] <= stck.iloc[inx].close:
print("go up " + str(stck.iloc[inx].name) + " - boll:" +
str(stck.iloc[inx - 1].boll) + " -prev: " +
str(stck.iloc[inx - 1].close) + " - curr:" +
str(stck.iloc[inx].close))
cross_bollinger = 1
elif stck.iloc[inx]['boll'] <= stck.iloc[inx-1]['close'] and \
stck.iloc[inx]['boll'] >= stck.iloc[inx]['close']:
print("go down " + str(stck.iloc[inx].name) + " - boll:" +
str(stck.iloc[inx - 1].boll) + " -prev: " +
str(stck.iloc[inx - 1].close) + " - curr:" +
str(stck.iloc[inx]['close']))
cross_bollinger = -1
else:
cross_bollinger = 0
if self.bs.buyed_stocks == 0 and \
(cross_bollinger == 1) or \
buy_now_process:
self.bs.buy(stck)
buy_now_process = False
#comment this block for selling at the end of the date
if self.bs.buyed_stocks != 0 and \
(cross_bollinger == -1 or
(stck['boll_mid_lb'] <= stck.iloc[inx-1]['close'] and stck.iloc[inx]['boll_mid_lb'] > stck.iloc[inx]['close'])):
self.bs.sell(stck.iloc[inx])
# if self.buyed_stocks == 0 and \
# (cross_bollinger == 1 or \
# (stock['boll_mid_ub'] >= self.prev_stock['close'] and stock['boll_mid_ub'] < stock['close']) or \
# (stock['boll_mid_lb'] >= self.prev_stock['close'] and stock['boll_mid_lb'] < stock['close'])):
# self.buy_stock(stock)
# if self.buyed_stocks != 0 and \
# (cross_bollinger == -1 or \
# (stock['boll_mid_ub'] <= self.prev_stock['close'] and stock['boll_mid_ub'] > stock['close']) or \
# (stock['boll_mid_lb'] <= self.prev_stock['close'] and stock['boll_mid_lb'] > stock['close'])):
# self.sell_stock(stock)
# if self.buyed_stocks == 0 and \
# (cross_bollinger == 1 or \
# (stock['boll_mid_ub'] >= self.prev_stock['close'] and stock['boll_mid_ub'] < stock['close'])):
# self.buy_stock(stock)
# if self.buyed_stocks != 0 and \
# (cross_bollinger == -1 or \
# (stock['boll_mid_ub'] <= self.prev_stock['close'] and stock['boll_mid_ub'] > stock['close'])):
# self.sell_stock(stock)
# self.prev_stock = stck
# check_boll()
if self.transactions > 0:
self.show_stats(symbol)
# self.plot_stats(stck, spy_stocks)
else:
print("Theres no transactions please change BUY/SELL params")
class RunData():
selected_stock = None
timetick = None
time_from = None
time_to = None
selected = {}
action_type = None
types = ["sector-stats", "stock-detail",
"stocks-stats"]
def __init__(self):
self.db = Database()
self.symbols = self.db.get_symbols(TableName.DAY)
self.sectors = self.db.get_sectors(TableName.DAY)
self.sm = StockMess()
self.app = self.get_home_page()
self.sw = StockWhisperer()
self.submit = None
# self.fig = None
# print(self.df)
# def load_data(self, option, time_from = "-180d", time_to = None):
# df = self.db.load_data(
# "p_day", symbols=option, time_from=time_from, time_to = time_to)
# df = FinI.add_indicators(sdf.retype(df))
# return df
def get_home_page(self):
st.set_page_config(layout="wide")
asyncio.new_event_loop().run_until_complete(RunData.prepare_test_tasks())
@staticmethod
async def prepare_test_tasks():
tasks = []
task = asyncio.ensure_future(RunData.async_test(0.05))
tasks.append(task)
task = asyncio.ensure_future(RunData.async_test(0.1))
tasks.append(task)
await asyncio.gather(*tasks, return_exceptions=True)
@staticmethod
async def async_test(sleep):
progress_bar = st.sidebar.progress(0)
status_text = st.sidebar.empty()
last_rows = np.random.randn(1, 1)
chart = st.line_chart(last_rows)
for i in range(1, 101):
new_rows = last_rows[-1, :] + np.random.randn(5, 1).cumsum(axis=0)
status_text.text("%i%% Complete" % i)
chart.add_rows(new_rows)
progress_bar.progress(i)
last_rows = new_rows
await asyncio.sleep(sleep)
progress_bar.empty()
class SlAs():
selected_stock = None
timetick = None
def __init__(self):
self.db = Database()
self.symbols = self.db.get_symbols(TableName.DAY)
self.sectors = self.db.get_sectors(TableName.DAY)
self.sm = StockMess()
self.app = self.get_home_page()
self.sw = StockWhisperer()
self.submit = None
def get_home_page(self):
st.set_page_config(layout="wide")
t1 = threading.Thread(target=SlAs.watch, args=(st, ))
t1.start()
# loop = asyncio.get_event_loop()
print('after async')
test = st.text_area("websocket", self.timetick)
st.write("some text")
test = st.text_area("websocket2", self.timetick)
@staticmethod
def watch(sti):
i = 0
while True:
print('thread')
Utils.countdown(5)
i += 1
st.write(str(i))
# test = st.empty()
async def watch2(self, test):
while True:
print('async')
Utils.countdown(5)
test = str(datetime.now())
# test.markdown(
# f"""
# <p class="time">
# {str(datetime.now())}
# </p>
# """, unsafe_allow_html=True)
try:
await asyncio.sleep(1)
except KeyboardInterrupt:
print("ending async")
exit()
test = st.empty()
@staticmethod
async def time_tick():
timetick = 0
while True:
timetick += 1
await asyncio.sleep(1)
