def strat():
CustomStrategy = ta.Strategy(
name="Momo and Volatility",
description="SMA 50,200, BBANDS, RSI, MACD and Volume SMA 20",
ta=[
{
"kind": "sma",
"length": 11
},
{
"kind": "sma",
"length": 20
},
{
"kind": "bbands",
"length": 20
},
{
"kind": "rsi"
},
{
"kind": "macd",
"fast": 8,
"slow": 21
},
{
"kind": "sma",
"close": "volume",
"length": 20,
"prefix": "VOLUME"
},
])
# To run your "Custom Strategy"
my_data.ta.strategy(CustomStrategy)
print(my_data)
def calculate_all_technicals_with_pandas_ta(
technicals: pd.DataFrame, ) -> pd.DataFrame:
default_strategy = ta.Strategy(
name="Default",
description=
"PVOL, SMA15, SMA40, EMA200, RSI, MACD, Trix, Williams %R, MFI, ROC, EMV",
ta=[
{
"kind": "pvol"
},
{
"kind": "sma",
"length": 15
},
{
"kind": "sma",
"length": 40
},
{
"kind": "ema",
"length": 200
},
{
"kind": "rsi",
"length": 14
},
{
"kind": "macd",
"fast": 12,
"slow": 26,
"signal": 9
},
{
"kind": "trix",
"length": 14,
"signal": 9
},
{
"kind": "willr",
"length": 10
},
{
"kind": "mfi",
"length": 14
},
{
"kind": "roc",
"length": 14
},
{
"kind": "eom",
"length": 14
},
],
)
technicals.ta.strategy(default_strategy)
return technicals
def test_get_technical_indicator(self, dictList_stock):
data = dictList_stock
df = pd.DataFrame(data)
stock = Stock(data, 'Date')
strategy = ta.Strategy(name='sma', ta=[{'kind': 'sma', 'length': 2}])
df.ta.strategy(strategy)
stock = stock.get_technical_indicator(strategy)
test = to_pandas(stock, False, False, 'ignore')
test.columns = test.columns.str.lower()
df.columns = df.columns.str.lower()
pd.testing.assert_frame_equal(df, test, False)
def customEntryStrategy(bot_controller, symbol):
## This is the function that pyjuque will call to check for entry signal
## the first parammeter is a bot_controller, through which we have access
## to the following objects:
##
## bot_controller.bot_model (a SQLAlchemy model, containing the info that
# we store in the database for this bot plus a few methods)
## bot_controller.session (a SQLAlchemy database session)
## bot_controller.exchange (a CcxtExchanges, exposing a few wrapped methods
## written to work with pyjuque plus all the ccxt unified api methods,
## through bot_controller.exchange.ccxt)
## bot_controller.strategy (in our case it will be None)
## bot_controller.status_printer (yaspin object)
##
## and the following method:
## bot_controller.executeBot() (executes a loop of the bot - checking
## entry signals on all symbols, placing orders if any signals are
## found, then checking all the open orders and updating them)
##
## it returns a boolean (the signal) and the current price of the asset
# Get data from exchange for multiple timeframes
df_15min = bot_controller.exchange.getOHLCV(symbol, '15m', limit=100)
df_1hour = bot_controller.exchange.getOHLCV(symbol, '1h', limit=100)
df_4hour = bot_controller.exchange.getOHLCV(symbol, '4h', limit=100)
# Define and compute indicators for each timeframe
Strat = ta.Strategy(name="EMAs",
ta=[
{
"kind": "ema",
"length": 20
},
{
"kind": "ema",
"length": 50
},
])
df_15min.ta.strategy(Strat)
df_1hour.ta.strategy(Strat)
df_4hour.ta.strategy(Strat)
# Check entry signal on each timeframe separately
entry_signal_15 = df_15min.iloc[-1]['EMA_50'] > df_15min.iloc[-1]['EMA_20']
entry_signal_1h = df_1hour.iloc[-1]['EMA_50'] > df_1hour.iloc[-1]['EMA_20']
entry_signal_4h = df_4hour.iloc[-1]['EMA_50'] > df_1hour.iloc[-1]['EMA_20'] and \
df_4hour.iloc[-2]['EMA_50'] < df_1hour.iloc[-2]['EMA_20']
# Combine them
entry_signal = entry_signal_15 and entry_signal_1h and entry_signal_4h
# Return the signal and the last price
return entry_signal, df_4hour.iloc[-1]['close']
def test_single_stock_technical_indicator(self, single_stock):
strategy = ta.Strategy(name='sma', ta=[{'kind': 'sma', 'length': 2}])
df = pd.DataFrame(single_stock['train'])
sit = Stock_Technical_Indicator_Transformer(strategy, 'Date')
sit.fit(df)
y = sit.transform(df)
df.ta.strategy(strategy)
np.testing.assert_equal(y.reshape(-1), df['SMA_2'].values)
df = pd.DataFrame(single_stock['train'])
df = df.append(pd.DataFrame(single_stock['test']), True)
df2 = pd.DataFrame(single_stock['test'])
y = sit.transform(df2)
df.ta.strategy(strategy)
np.testing.assert_equal(y.reshape(-1), df.tail(3)['SMA_2'].values)
def test_single_make_technical_indicator(self, dictList_stock):
MyStrategy = ta.Strategy(name="DCSMA10",
ta=[{
"kind": "sma",
"length": 1
}])
df = pd.DataFrame(dictList_stock)
stockTrans = Stock_Transformer.from_pandas(df, 'Date', None)
stockTrans = stockTrans.get_technial_indicator(MyStrategy)
df.ta.strategy(MyStrategy)
test = stockTrans.to_pandas(False, False, 'ignore')
test.columns = test.columns.str.lower()
df.columns = df.columns.str.lower()
df = df[test.columns]
pd.testing.assert_frame_equal(test, df, False)
def test_get_technical_indicator(self, dictList_portfolio):
data = dictList_portfolio
df = pd.DataFrame(data)
tsd = Time_Series_Data(data, 'Date')
tsc = Time_Series_Data_Collection(tsd, 'Date', 'symbol')
port = Portfolio.from_time_series_collection(tsc)
strategy = ta.Strategy(name='sma', ta=[{'kind': 'sma', 'length': 2}])
port = port.get_technical_indicator(strategy)
test = to_pandas(port, False, False, 'ignore')
test.columns = test.columns.str.lower()
for i in port:
tmp = df[df.symbol == i]
tmp.ta.strategy(strategy)
tmp.columns = tmp.columns.str.lower()
tmp_test = test[test.symbol == i]
tmp_test = tmp_test[tmp.columns]
pd.testing.assert_frame_equal(tmp_test.reset_index(drop=True),
tmp.reset_index(drop=True), False)
def test_collection_make_technical_indicator(self, dictList_portfolio):
MyStrategy = ta.Strategy(name="DCSMA10",
ta=[{
"kind": "sma",
"length": 1
}])
df = pd.DataFrame(dictList_portfolio)
stockTrans = Stock_Transformer.from_pandas(df, 'Date', None)
stockTrans = stockTrans.get_technial_indicator(MyStrategy)
test = stockTrans.to_pandas(False, False, 'ignore')
test.columns = test.columns.str.lower()
for i in test.symbol.unique():
tmp_df = df[df.symbol == i]
tmp_test = test[test.symbol == i]
tmp_df.ta.strategy(MyStrategy)
tmp_df.columns = tmp_df.columns.str.lower()
tmp_df = tmp_df[tmp_test.columns]
pd.testing.assert_frame_equal(tmp_test, tmp_df, False)
def custom_MACD(symbol, date):
time_delta = 100
trade = OpenClose.objects.filter(symbol=symbol, date__gte=date-timedelta(days=time_delta), date__lte=date).order_by('date')
value = [[t.date, t.open, t.high, t.low, t.close, t.volume] for t in trade]
columns_name = ["date", "open", "high", "low", "close", "volume"]
trade = pd.DataFrame(value, columns=columns_name).set_index("date")
CustomMACDStrategy = ta.Strategy(
name="EMAs, BBs, and MACD",
description="Non Multiprocessing Strategy by rename Columns",
ta=[
{"kind": "macd", "fast": 8, "slow": 21},
{"kind": "macd", "fast": 12, "slow": 26},
{"kind": "macd", "fast": 14, "slow": 28},
]
)
trade.ta.strategy(CustomMACDStrategy)
print(trade)
def test_collection_stock_technical_indicator(self, collection_stock):
strategy = ta.Strategy(name='sma', ta=[{'kind': 'sma', 'length': 2}])
df = pd.DataFrame(collection_stock['train'])
sit = Stock_Technical_Indicator_Transformer(strategy, 'Date', 'symbol')
sit.fit(df)
y = sit.transform(df)
res = []
for i in df.symbol.unique():
tmp = df[df.symbol == i]
tmp.ta.strategy(strategy)
res.extend(tmp['SMA_2'])
np.testing.assert_equal(y.reshape(-1), np.array(res))
df = pd.DataFrame(collection_stock['test'])
y = sit.transform(df)
df = pd.DataFrame(collection_stock['train'])
df = df.append(pd.DataFrame(collection_stock['test']), True)
res = []
for i in df.symbol.unique():
tmp = df[df.symbol == i]
tmp.ta.strategy(strategy)
res.extend(tmp['SMA_2'].tail(2).tolist())
np.testing.assert_equal(y.reshape(-1), np.array(res))
def test_strategy(self, symbol, path):
if not self.watchlist_contains(symbol):
print("The selected symbol is not in the watchlist!")
return
acc = PaperAccount()
acc.init_session(10000, False)
csv_path = os.path.join(path, "{0}.csv".format(symbol))
df = pd.read_csv(csv_path, sep=",")
RSIStrategy = ta.Strategy(
name="RSI",
description="RSI to measure stock price strength",
ta=[
{"kind": "rsi"}
]
)
shares = 0
df.ta.strategy(RSIStrategy)
# Predefined ruleset: buy if RSI_14 less than 35, hold and sell until RSI_14 over 55
for index, row in df.iterrows():
if row['RSI_14'] < 35:
shares = acc.buy_stock(symbol, row['close'], 10)
if row['RSI_14'] > 50:
shares = acc.sell_stock(symbol, row['close'], ALL_SHARES_AVAILABLE)
# Analysis
result = acc.get_profit_loss()
if result < 0:
print("Realized loss:" + str(result))
else:
print("Realized gain: " + str(result))
buys, sells = acc.get_total_transactions()
print("Total # buys: " + str(buys))
print("Total # sells: " + str(sells))
import pandas_ta as ta
strategy_test = ta.Strategy(
name=
"Crossing Moving Average - https://www.investopedia.com/ask/answers/122314/how-do-i-use-moving-average-ma-create-forex-trading-strategy.asp",
description="SMA 50,200, BBANDS, RSI, MACD and Volume SMA 20",
ta=[
{
"kind": "ema",
"length": 5
},
{
"kind": "ema",
"length": 20
},
{
"kind": "ema",
"length": 50
},
])
def neural_network(ticker, start, end, column, split):
global lr
df = data_get(ticker, start, end)
CustomStrategy = ta.Strategy(
name="Momo and Volatility",
description="SMA 50,200, BBANDS, RSI, MACD and Volume SMA 20",
ta=[
#{"kind": "sma", "length": 50},
#{"kind": "sma", "length": 200},
#{"kind": "bbands", "length": 20},
{
"kind": "rsi"
},
{
"kind": "stoch"
},
{
"kind": "bbands"
},
{
"kind": "ema"
},
{
"kind": "ao"
},
{
"kind": "apo"
},
{
"kind": "brar"
},
{
"kind": "cci"
},
{
"kind": "ha"
},
{
"kind": "aberration"
},
{
"kind": "accbands"
},
{
"kind": "adx"
},
{
"kind": "bias"
},
{
"kind": "cmf"
},
{
"kind": "midprice"
},
{
"kind": "pvol"
},
#{"kind": "macd", "fast": 8, "slow": 21},
#{"kind": "sma", "close": "volume", "length": 20, "prefix": "VOLUME"},
])
df.ta.strategy(CustomStrategy) #error here
#print(df)
df = df.dropna()
#print(df)
#print("__________________________________")
#print(df)
X, y, X_test, y_test = data_process(df, column, split)
lr.fit(np.array(X), np.array(y))
a = lr.predict(np.array(X_test))
b = np.array(y_test)
t = 0
# Accuracy Calculator
for z in range(len(a)):
w = a[z]
v = b[z]
if z != 0:
u = b[z - 1]
if (w[0] < u[0] and v[0] < u[0]) or (w[0] > u[0] and v[0] > u[0]):
t += 1
# Output Accuracy
print(lr.score(np.array(X_test), np.array(y_test)))
print("High Direction Accuracy: " + str(t / len(a) * 100) + "%")
#print(df)
return df, X, y, X_test, y_test
def stock_linear_trending_api(symbol, date):
time_delta = 50
tickers = OpenClose.objects.filter(symbol=symbol,
date__gte=date -
timedelta(days=time_delta),
date__lte=date).order_by('-date')
close = pd.DataFrame([[t.date, t.close, t.volume] for t in tickers],
columns=["date", "close", "volume"]).set_index("date")
last_20 = close['close'][:20]
_1 = np.quantile(last_20, q=0.25)
_2 = np.quantile(last_20, q=0.5)
_3 = np.quantile(last_20, q=0.75)
if close['close'][0] > _3:
q_l = 4
elif _2 <= close['close'][0] < _3:
q_l = 3
elif _1 <= close['close'][0] < _2:
q_l = 2
else:
q_l = 1
if 5 < len(tickers) < 10:
CustomSMAStrategy = ta.Strategy(
name="EMAs, BBs, and MACD",
description="Non Multiprocessing Strategy by rename Columns",
ta=[
{
"kind": "sma",
"length": 5
},
])
close.ta.strategy(CustomSMAStrategy)
trend = TrendingRecord(
date=date,
symbol=symbol,
close=tickers[0].close,
sma_5d=close['SMA_5'][-1],
quantile20=q_l,
cross_sma5=tickers[0].close - close['SMA_5'][-1],
)
trend.save()
if 10 <= len(tickers) < 20:
CustomSMAStrategy = ta.Strategy(
name="EMAs, BBs, and MACD",
description="Non Multiprocessing Strategy by rename Columns",
ta=[
{
"kind": "sma",
"length": 5
},
{
"kind": "sma",
"length": 10
},
])
close.ta.strategy(CustomSMAStrategy)
trend = TrendingRecord(
date=date,
symbol=symbol,
close=tickers[0].close,
sma_5d=close['SMA_5'][-1],
sma_10d=close['SMA_10'][-1],
quantile20=q_l,
cross_sma5=tickers[0].close - close['SMA_5'][-1],
cross_sma10=tickers[0].close - close['SMA_10'][-1],
)
trend.save()
if 20 <= len(tickers) < 30:
CustomSMAStrategy = ta.Strategy(
name="EMAs, BBs, and MACD",
description="Non Multiprocessing Strategy by rename Columns",
ta=[
{
"kind": "sma",
"length": 5
},
{
"kind": "sma",
"length": 10
},
{
"kind": "sma",
"length": 20
},
])
close.ta.strategy(CustomSMAStrategy)
X = np.array([i for i in range(len(tickers[:20]))]).reshape((-1, 1))
y = np.array([t.close for t in tickers[:20]])
model = LinearRegression()
reg = model.fit(X=X, y=y)
slope = reg.coef_
angle = np.rad2deg(np.arctan2(y[-1] - y[0], X[-1] - X[0]))
trend = TrendingRecord(
date=date,
symbol=symbol,
close=tickers[0].close,
sma_5d=close['SMA_5'][-1],
sma_10d=close['SMA_10'][-1],
sma_20d=close['SMA_20'][-1],
quantile20=q_l,
cross_sma5=tickers[0].close - close['SMA_5'][-1],
cross_sma10=tickers[0].close - close['SMA_10'][-1],
cross_sma20=tickers[0].close - close['SMA_20'][-1],
angle=angle,
slope=slope)
trend.save()
if 30 <= len(tickers):
CustomSMAStrategy = ta.Strategy(
name="EMAs, BBs, and MACD",
description="Non Multiprocessing Strategy by rename Columns",
ta=[
{
"kind": "sma",
"length": 5
},
{
"kind": "sma",
"length": 10
},
{
"kind": "sma",
"length": 20
},
{
"kind": "sma",
"length": 30
},
])
close.ta.strategy(CustomSMAStrategy)
X = np.array([i for i in range(len(tickers[:20]))]).reshape((-1, 1))
y = np.array([t.close for t in tickers[:20]])
model = LinearRegression()
reg = model.fit(X=X, y=y)
slope = reg.coef_
angle = np.rad2deg(np.arctan2(y[-1] - y[0], X[-1] - X[0]))
trend = TrendingRecord(
date=date,
symbol=symbol,
close=tickers[0].close,
sma_5d=close['SMA_5'][-1],
sma_10d=close['SMA_10'][-1],
sma_20d=close['SMA_20'][-1],
sma_30d=close['SMA_30'][-1],
quantile20=q_l,
cross_sma5=tickers[0].close - close['SMA_5'][-1],
cross_sma10=tickers[0].close - close['SMA_10'][-1],
cross_sma20=tickers[0].close - close['SMA_20'][-1],
cross_sma30=tickers[0].close - close['SMA_30'][-1],
angle=angle,
slope=slope)
trend.save()
