def download(ticker,
filename=None,
period='1y',
interval='1d',
start='',
end=''):
"""
https://yahooquery.dpguthrie.com/
:param ticker: stock symbol
:param period: valid periods: 1d,5d,1mo,3mo,6mo,1y,2y,5y,10y,ytd,max
:param interval: valid intervals: 1m,2m,5m,15m,30m,60m,90m,1h,1d,5d,1wk,1mo,3mo
:param start: YYYY–MM–DD
:param end: YYYY–MM–DD
:return:
"""
ticker = Ticker(ticker + ".SA")
if len(start) and len(end):
data = ticker.history(start=start, end=end, interval=interval)
else:
data = ticker.history(period=period, interval=interval)
if filename is not None and len(data):
data.to_csv(filename)
return ticker
def fetch_all_data():
os.system('rm -rf {}_data/*.npz'.format(exchange))
init = Ticker(tickers)
data = init.history(start=source_start_str)
if type(data) == type(constituents):
data = {k: data.loc[k] for k in tickers}
# Need to create dataframe if yahooquery returns a dict and ensure all entries are dataframes,
# are continually traded since 2015, and traded actively enough to not throw "divide by zero" error when standardizing.
print('{} total companies in {}.'.format(len(data), exchange))
num_days = data[('JPM' if exchange == 'nyse' else 'GOOG')].shape[0]
data = {
k: v[column_titles].ewm(alpha=1, axis=0,
adjust=False).mean().to_numpy()[-128:, :]
for k, v in data.items()
if (type(v) == type(constituents)
#and str(v.index.array[0])[:10] == source_start_str
and
not np.any(pd.isnull(v[column_titles])) and v.shape[0] == num_days)
}
print('Data sift has produced {} total companies from {} '
'for consideration.'.format(len(data), exchange))
all_companies_history = []
std_single_window = np.zeros((128, 1))
for k, v in data.items():
average = np.mean(v, axis=-1, keepdims=True)
data_price_avg = np.mean(v[:, :4], axis=None)
data_price_std = np.std(v[:, :4], axis=None)
std_single_window[:, :] = np.divide(average - data_price_avg,
data_price_std)
all_companies_history.append(std_single_window)
history = np.stack(all_companies_history, axis=0)
index_init = Ticker(('^NYA' if exchange == 'nyse' else
('^GSPC' if exchange == 'snp' else '^NDX')))
index_data = index_init.history(start=source_start_str)
index = index_data[column_titles].ewm(alpha=1,
axis=0).mean()[-128:].to_numpy()
index_average = np.mean(index, axis=-1, keepdims=True)
index_price_avg = np.mean(index[:, :4], axis=None)
index_price_std = np.mean(index[:, :4], axis=None)
index = np.divide(index_average - index_price_avg, index_price_std)
np.savez('{}_data/{}.npz'.format(exchange, source_end_str),
history=history,
index=index)
# Destroy loading window
loading.destroy()
class YahooApi:
def __init__(self, symbol: Optional[str] = None) -> None:
self.symbol = symbol
self.ticker = Ticker(self.symbol)
if symbol:
try:
self.check_symbol(symbol)
except SymbolNotFoundException:
if not str(symbol).endswith(".SA"):
self.symbol = symbol + ".SA"
self.ticker = Ticker(self.symbol)
self.check_symbol(self.symbol)
else:
raise
def check_symbol(self, symbol: str) -> None:
price = self.ticker.price
if type(price[symbol]) != dict:
raise SymbolNotFoundException(price[symbol])
def extract_prefix(self, symbol: str) -> str:
if symbol.endswith(".SA"):
return symbol.split(".")[0]
else:
return symbol
@symbol_required
def get_price(self) -> float:
price = self.ticker.price
if type(price[self.symbol]) != dict:
raise SymbolNotFoundException(price[self.symbol])
market_price = price[self.symbol].get("regularMarketPrice", None)
try:
float(market_price)
return market_price
except:
traceback.print_exc()
raise Exception("An error occured when reading the price")
def get_history(self, period) -> DataFrame:
return self.ticker.history(period)
@symbol_required
def get_details(self) -> dict:
summary_detail = self.ticker.summary_detail
if type(summary_detail) != dict:
raise Exception
return self.ticker.summary_detail
@symbol_required
def historic(self, period, interval) -> DataFrame:
return self.ticker.history(period=period, interval=interval)
def main(argv):
interval = ''
try:
opts, args = getopt.getopt(argv, "hi:", ["interval="])
except getopt.GetoptError:
print('tradingdatadownload.py -i <interval>')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print('tradingdatadownload.py -i <interval>')
sys.exit()
elif opt in ("-i", "--interval"):
interval = arg.lstrip()
if interval == '':
print('tradingdatadownload.py -i <interval>')
sys.exit(2)
#cnxn = pyodbc.connect("dsn=azure-trading;UID=sqladmin;PWD=Duoduo88")
#engine = create_engine("mssql+pyodbc://sqladmin:Duoduo88@azure-trading")
cnxn = pyodbc.connect(
"DRIVER={ODBC Driver 17 for SQL Server};SERVER=192.168.1.19;UID=sa;PWD=Duoduo88;database=trading"
)
engine = create_engine(
"mssql+pyodbc://sa:[email protected]/trading?driver=ODBC+Driver+17+for+SQL+Server"
)
sym = pd.read_sql_table("Symbol", engine)
ticker_symbols = sym['Symbol'].values.tolist()
print(ticker_symbols)
if interval == 'weekly':
tickers = Ticker(ticker_symbols)
weekly = tickers.history(period='5y', interval='1wk')
print('Download weekly completed')
saveToTable(weekly, 'Weekly', cnxn, engine)
print('Saved to table weekly')
if interval == 'daily':
#daily = tickers.history('1mo', interval='1d')
#saveToTable(daily, 'Daily', cnxn, engine)
downloadDaily(ticker_symbols, cnxn, engine)
if interval == 'hourly':
tickers = Ticker(ticker_symbols)
hourly = tickers.history(period='1mo', interval='1h')
print('Download hourly completed')
saveToTable(hourly, 'Hourly', cnxn, engine)
print('Saved to table hourly')
def update_table(n, local_data_json, period):
callback = dash.callback_context.triggered[0]["prop_id"]
local_data = json.loads(local_data_json)
n_clicks = local_data["n_clicks"]
n_previous_clicks = local_data["n_previous_clicks"]
if (
n > 0 or (n_clicks > n_previous_clicks)
) and "date_input" not in callback and "select" not in callback and period:
tickers = []
for symbol in current_tickers:
ticker = Ticker(symbol.lower())
row = ticker.history(interval='1h', period=period)
row["Symbol"] = symbol
tickers.append(row)
df = pd.concat(tickers)
df = df.reset_index()
df = df[["date", "close", "Symbol"]]
df_pivot = df.pivot("date", "Symbol", "close").reset_index()
corr_df = df_pivot.corr(method="pearson")
corr_df.head().reset_index()
matrix = corr_df.to_dict('records')
for i, element in enumerate(matrix):
element = dict(sorted(element.items()))
for i in range(len(matrix)):
matrix[i]["Tickers"] = list(current_tickers[i])
last_update_time = time.strftime("%Y-%m-%d %H:%M:%S")
return matrix, [html.P(last_update_time)], "", [{
"name": i,
"id": i
} for i in ["Tickers"] + current_tickers]
else:
raise dash.exceptions.PreventUpdate
def createFolders(execType):
TickerNames = pd.read_csv('./src/tickerNames/TickerNames.csv')
TickerNames = TickerNames.values
if execType == 0:
pathName = './backtestdatabase/'
else:
pathName = './database'
for tickerName in TickerNames:
if not os.path.exists(pathName + tickerName[0]):
tickers = Ticker(tickerName[0])
df = tickers.history(period='max', interval='1d')
print("Creating and Updating " + tickerName[0] + " at " +
datetime.fromtimestamp(time.time()).strftime('%H:%M'))
os.makedirs(pathName + tickerName[0] + '/')
analysisColumnNames = [
'Time Stamp', 'Strategy', 'Position', 'Amount', 'Entry',
'Stop Loss', 'Take Profit', 'Confidence', 'Outcome', 'Profits',
'Points Gained/Lost'
]
analysisFrame = pd.DataFrame(columns=analysisColumnNames)
analysisFrame.to_csv(pathName + tickerName[0] + '/analysis.csv')
tradeColumnNames = [
'Time Stamp', 'Position', 'Amount', 'Entry', 'Stop Loss',
'Target', 'Confidence', 'Leverage', 'Outcome', 'Profits'
]
tradeFrame = pd.DataFrame(columns=tradeColumnNames)
tradeFrame.to_csv(pathName + tickerName[0] + '/trades.csv')
df.to_csv(pathName + tickerName[0] + '/temp.csv')
def yfi(self, identifier, options):
# convert
convert = {"daily": "1d", "monthly": "1m", "weekly": "1w"}
ticker = identifier.split(".yfi")[0]
stockObject = Ticker(ticker)
history = stockObject.history(period="max", interval=convert[options["range"]])
return history
def download_prices(stocks_table,
interval='1d',
default_min_date='2016-01-01'):
"""
Function to run prices on a specific list of stocks and store results in list
"""
# Create list of symbols
stocks_list = stocks_table.read_table_to_pandas()['symbol'].to_list()
# Create instance of Tickers
tickers = Ticker(stocks_list,
asynchronous=True,
formatted=True,
max_workers=32)
# Run query and create instance with query
price_query = tickers.history(start=default_min_date, interval=interval)
# Check result data types
# If it's a dataframe then all symbols in list are good
if isinstance(price_query, pd.DataFrame):
# Reset Index to make the symbol index another column
stock_prices = price_query.reset_index()
return stock_prices
def min_variance(ticker_list, period='1y', interval='1d', cash=10000000):
x = Ticker(ticker_list,
retry=20,
status_forcelist=[404, 429, 500, 502, 503, 504])
data = x.history(period=period, interval=interval)
if len(ticker_list) > 1:
data = yf.download(ticker_list,
period='10y',
interval=interval,
group_by='ticker')
new_data = []
df = pd.DataFrame()
weight = 1 / len(ticker_list)
for i in ticker_list:
stock_normal_ret = data['close'] / data.iloc[0]['close']
df[i] = data['close']
if len(ticker_list) > 1:
stock_normal_ret = data[i]['close'] / data[i].iloc[0]['close']
df[i] = data[i]['close']
alloc = stock_normal_ret * weight
balance = alloc * cash
new_data.append(balance)
mu = expected_returns.mean_historical_return(df)
s = risk_models.sample_cov(df)
ef = EfficientFrontier(mu, s)
weights = ef.min_volatility()
sharpe = ef.max_sharpe()
cleaned_weights = ef.clean_weights()
x = ef.portfolio_performance(verbose=False)
return cleaned_weights, round(2.5 * x[2] / 15, 3) # sharpe adjusted weight
def adosc(portfolio_item,transaction_volume, buy_threshold_difference=2, sell_threshold_difference=2, period='5d',
fastperiod=3, slowperiod=10):
"""
strategy that trades based on reversals in the chaikin oscillator
:param transaction_volume:
:param portfolio_item:
:param buy_threshold_difference:
:param sell_threshold_difference:
:param period:
:param fastperiod:
:param slowperiod:
:return:
"""
from yahooquery import Ticker
from time import sleep
from math import floor
import talib
from .TradeHistoryItem import log_trade
from API.Help import pct_change, initialize_alpaca
alpaca = initialize_alpaca()
ticker = str(portfolio_item)
yahoo_ticker = Ticker(ticker)
history = yahoo_ticker.history(period=period, interval=portfolio_item.portfolio.get_trading_frequency())
ticker_adosc = talib.ADOSC(high=history['high'], low=history['low'], close=history['close'],
volume=history['volume'], fastperiod=fastperiod, slowperiod=slowperiod)
ticker_adosc_pct = pct_change(ticker_adosc)
# Buy when in the bottom of a dip in the chalking oscillator graph
if ticker_adosc_pct[-2] < 0 and \
abs(ticker_adosc_pct[-2] - ticker_adosc_pct[-1]) > buy_threshold_difference and \
ticker_adosc_pct[-1] > 0 and portfolio_item.transaction_status != portfolio_item.BUY:
if portfolio_item.transaction_status == 2: # only buy to cover if stock has been shorted before
print('buying to cover {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'buy', 'market', 'day')
portfolio_item.buy_to_cover(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=2)
sleep(1) # hopefully combats 403 alpaca error
print('buying {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'buy', 'market', 'day')
portfolio_item.buy(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=0)
# Sell at a tip in chaikin oscillator
elif ticker_adosc_pct[-2] > 0 and \
abs(ticker_adosc_pct[-2] - ticker_adosc_pct[-1]) > sell_threshold_difference and \
ticker_adosc_pct[-1] < 0:
if portfolio_item.transaction_status == portfolio_item.BUY: # making sure stock exists before selling it
print('selling {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'sell', 'market', 'day')
portfolio_item.sell(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=1)
sleep(1)
if portfolio_item.transaction_status != portfolio_item.SHORT: # make sure we dont short twice in a row
transaction_volume = floor(portfolio_item.cash_allocated / (
portfolio_item.ticker.price_now * 1.1)) # gives us a 10% buffer if the stock goes the other way
print('shorting {} shares of {}'.format(transaction_volume, ticker))
alpaca.submit_order(ticker, transaction_volume, 'sell', 'market', 'day')
portfolio_item.short(transaction_volume=transaction_volume)
log_trade(portfolio_item=portfolio_item, transaction_volume=transaction_volume, transaction_type=3)
def scrape(self, ChangePendingToVoid):
tickers = Ticker(self.tickerName)
df = tickers.history(period='2y', interval='1d')
df = df.iloc[::-1]
if os.path.exists('./database/' + self.tickerName):
##Change all previously unfinished analysis rows to 'void' on startup
# if ChangePendingToVoid == True:
# analysisRead = pd.read_csv('./database/' + self.tickerName + '/analysis.csv', index_col= 0)
# for index,row in analysisRead.iterrows():
# if row['Outcome'] == 'Pending':
# analysisRead.loc[index, 'Outcome'] = 'Void (Prog Closed)'
# analysisRead.to_csv('./database/' + self.tickerName + '/analysis.csv')
## This saving then re-reading is necessary to prevent the buggy header issues
df.to_csv('./database/' + self.tickerName + '/temp.csv')
df = pd.read_csv('./database/' + self.tickerName + '/temp.csv')
###########################
dfFirstTwoRows = df.head(2)
dfSecondRow = dfFirstTwoRows.iloc[1:].head(1)
dfDate = dfSecondRow['date'].values[0]
database = pd.read_csv('./database/' + self.tickerName +
'/query.csv',
index_col=0)
databaseFirstTwoRow = database.head(2)
databaseSecondRow = databaseFirstTwoRow.iloc[1:].head(1)
dbDate = databaseSecondRow['date'].values[0]
if not (dbDate == dfDate):
print("Updating " + self.tickerName + " at " +
datetime.fromtimestamp(time.time()).strftime('%H:%M'))
df.to_csv('./database/' + self.tickerName + '/query.csv')
self.stratCalc.inform(df, 1)
else:
print("Creating and Updating " + self.tickerName + " at " +
datetime.fromtimestamp(time.time()).strftime('%H:%M'))
os.makedirs('./database/' + self.tickerName + '/')
analysisColumnNames = [
'Time Stamp', 'Strategy', 'Position', 'Amount', 'Entry',
'Stop Loss', 'Take Profit', 'Confidence', 'Outcome', 'Profits',
'Points Gained/Lost'
]
analysisFrame = pd.DataFrame(columns=analysisColumnNames)
analysisFrame.to_csv('./database/' + self.tickerName +
'/analysis.csv')
tradeColumnNames = [
'Time Stamp', 'Position', 'Amount', 'Entry', 'Stop Loss',
'Target', 'Confidence', 'Leverage', 'Outcome', 'Profits'
]
tradeFrame = pd.DataFrame(columns=tradeColumnNames)
tradeFrame.to_csv('./database/' + self.tickerName + '/trades.csv')
df.to_csv('./database/' + self.tickerName + '/query.csv')
df.to_csv('./database/' + self.tickerName + '/temp.csv')
df = pd.read_csv('./database/' + self.tickerName + '/temp.csv')
self.stratCalc.inform(df, 1)
pass
def fusao_tres_candles(ticker): #junta os ultimos tres candles
ativo = Ticker(ticker) #chama funcao Ticker do yahooquery entrada eh o ticker
hist = ativo.history('5d','1d')#retorna dataframe pandas com o historico de cotacoes do ticker ultimos 5 dias
hist_low_5d = hist["low"]#lista com o minimo dos ultimos 5 pregoes
minimo = hist_low_5d.tail(3).min() #minimo dos minimos dos tres dia
fechamento = hist["close"].tail(1).max()#fechamento do ultimo pregao
fusao = [minimo, fechamento] #tres ultimos candles transofrmados em 1
return fusao
def display_value(n_clicks, symbol: str):
if n_clicks is None:
raise PreventUpdate
if symbol is None:
raise PreventUpdate
else:
symbol = symbol.upper().strip()
ticker = symbol + ".NS"
yTicker = Ticker(ticker)
yearly_pricing_data = yTicker.history(period='1y',
interval='1d').loc[ticker]
yearly_pricing_data = yearly_pricing_data.reset_index()
pricing = yTicker.price[ticker]
sTicker = STicker(symbol=symbol)
yt_asset_profile = yTicker.asset_profile[ticker]
moneycontrol_url = get_moneycontrol_url(symbol=symbol)
moneycontrol_data = get_moneycontrol_data(moneycontrol_url)
key_stats = sTicker.get_key_stats()
return html.Div([
dbc.Row(
dbc.Container([
html.H1(sTicker.get_company_name(), className="display-3"),
get_links(sTicker=sTicker,
moneycontrol_url=moneycontrol_url),
html.H4(f"Industry : {yt_asset_profile['industry']}"),
html.H4(f"Sector : {yt_asset_profile['sector']}"),
html.Hr(className="my-2"),
dbc.Row([
dbc.Col([
dbc.Row(html.Br()),
get_ohlc_data(pricing=pricing),
dbc.Row(html.Br()),
dbc.Row(
dbc.Col(
dcc.Graph(figure=get_ytd_chart(
yearly_pricing_data)))),
dbc.Row(html.Br()),
dbc.Row(get_ranges(pricing, moneycontrol_data),
justify='center')
]),
dbc.Col([
dbc.Row(get_company_description(sTicker=sTicker)),
dbc.Row(html.Br()),
dbc.Row(
get_key_stats(key_stats, yTicker, ticker,
pricing)),
dbc.Row(html.Br()),
])
])
],
fluid=True)),
dbc.Row(dbc.Container(html.Div(), style={'height': '3rem'})),
dbc.Row(
dbc.Container(get_tables(sTicker),
fluid=True,
style={'height': '50rem'}))
])
def hist_price(symbol, start=None, end=None, interval='1d'):
if end is None and start is None:
raise ValueError('Requires at value for start or end')
if start is None:
raise ValueError('Requires value for start')
stockyq = Ticker(symbol)
price = stockyq.history(interval=interval, start=start, end=end)
#price.to_excel("price.xlsx")
return price
def get_historical(exchange='SGX', start_year=2018, interval='1d'):
'''
Query latest historical prices of stocks.
Parameters:
exchange : Short name for stock exchange. Default value is SGX
start_year : Reference start year. Default value is 2018
interval : Reference interval period. Default value is daily
'''
# Initialise parameter #
## Tickers ##
filepath = re.split(exchange, download_path)[0]
stocks = pd.read_excel(filepath + exchange + '_TICKERS.xlsx')
target_tickers = list(stocks['TICKER'])
# Get historical prices - Default end date is now #
tickers = Ticker(target_tickers)
if interval == '1d':
historical = tickers.history(start=dt.datetime(start_year, 1, 1),
end=dt.datetime.now())
else:
first_recent = get_working_day()
second_recent = first_recent - dt.timedelta(7)
historical = tickers.history(interval=interval,
start=second_recent,
end=first_recent)
# Access each ticker and output data #
for target_ticker in target_tickers:
target = historical[target_ticker]
company = stocks.loc[stocks['TICKER'] == target_ticker,
'COMPANY'].iloc[0]
try:
# target.index = [timestamp.date() for timestamp in list(target.index)]
target.index.name = 'date'
target.sort_index(ascending=False, inplace=True)
if interval == '1d':
target.to_csv(download_path + '\\' + exchange + \
r'\Prices\Daily\%s_%s.csv' % (target_ticker, company))
else:
target.dropna(inplace=True)
target.to_csv(download_path + '\\' + exchange + \
r'\Prices\Minute\%s_%s.csv' % (target_ticker, company))
except:
pass
def gerar_valor_acao(codigo_acao):
ticker_acao = Ticker(codigo_acao)
resultado = ticker_acao.history(period="7d", interval="5m")
resultado.reset_index(inplace=True)
index = random.randrange(0, resultado.shape[0], 1)
resultado = resultado.iloc[[index]]
retorno = {'codigo': codigo_acao,
'horario': datetime.now(pytz.timezone('AMERICA/Sao_Paulo')).isoformat(),
'valor': resultado['close'].values[0]}
return json.dumps(retorno), 200
class Stock(object):
def __init__(self, ticker, fundamental_frequency='q'):
self.ticker= ticker
self.zacks_earnings_cal = get_zacks_earnings_calendar(ticker)
self.yquery = Ticker(ticker)
self.returns_data = self.yquery.history(adj_ohlc=True,
start=(datetime.today() \
-timedelta(days = 365*3)
).strftime('%Y-%m-%d'),
end = datetime.today().strftime('%Y-%m-%d')
).droplevel(0).rename(columns={'high': 'PriceHigh',
'volume': 'Volume',
'open': 'PriceOpen',
'low': 'PriceLow',
'close': 'PriceClose'
})
self.financial_data = self.get_all_financial_data(fundamental_frequency=fundamental_frequency)
try:
self.ratings_data = get_finviz_fundamentals_ratings(ticker)
except:
self.ratings_data = None
try:
self.insider_trading_data = get_finviz_inside_trading(ticker)
except:
self.insider_trading_data = None
try:
self.news_data = get_finviz_news(ticker)
except:
self.news_data = None
def get_all_financial_data (self, fundamental_frequency='q'):
df = self.yquery.all_financial_data( frequency = fundamental_frequency)
df['Quarter'] = df['asOfDate'].apply(lambda x: as_of_date_to_quarter(x))
df = pd.merge(df, self.zacks_earnings_cal, how = 'left', on = 'Quarter')\
.set_index('ReleaseDate').drop(['asOfDate', 'periodType', 'Quarter'], axis = 1)
return df
def get_fundamental_ts (self, item):
ts = self.financial_data[item]
date_idx = pd.date_range(self.returns_data.index[0], self.returns_data.index[-1])
ts = ts.reindex(index = date_idx).shift(1).ffill()
ts = ts.loc[self.returns_data.index]
return ts
def __getitem__(self, item):
if item in self.returns_data.columns:
return self.returns_data[item]
elif item in self.financial_data.columns:
return self.get_fundamental_ts(item)
else:
raise KeyError('Item not Found!')
def train(ticket):
# ts = TimeSeries(key=ALPHA_VANTAGE_API_KEY, output_format='pandas')
# df, data_info = ts.get_intraday(ticket, outputsize='full', interval='5min')
# df = df[::-1]
ticket = ticket.lower()
if not os.path.exists('cache.json'):
cache = []
else:
with open('cache.json') as file:
cache = json.load(file)
for item in cache:
if item['ticket'] == ticket and (
datetime.now() - parser.parse(item['time'])).seconds < 3600:
return
ticker = Ticker(ticket, asynchronous=True)
df = ticker.history(period='5d', interval='1m')
data = df.filter(['close'])
print(data)
dataset = data.values
training_data_len = math.ceil(len(dataset) * .8)
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(dataset)
train_data = scaled_data[0:training_data_len:]
x_train = []
y_train = []
for i in range(60, len(train_data)):
x_train.append(train_data[i - 60:i, 0])
y_train.append(train_data[i, 0])
x_train, y_train = np.array(x_train), np.array(y_train)
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 1))
model = Sequential()
model.add(
LSTM(50, return_sequences=True, input_shape=(x_train.shape[1], 1)))
model.add(LSTM(50, return_sequences=False))
model.add(Dense(25))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')
model.fit(x_train, y_train, batch_size=1, epochs=1)
model.save(f'/Users/maximsurovtsev/Stocks prediction/{ticket}')
with open('cache.json', 'w') as file:
cache.append({'ticket': ticket, 'time': str(datetime.now())})
json.dump(cache, file, indent=4)
def get_stock(symbol):
try:
symbol = symbol + '.SA'
ticker = Ticker(symbol)
df = ticker.history(period='1mo', interval='1d')
value = df.close[-1]
value_ = df.close[-2]
percent_day = ((value - value_) / value_) * 100
return value, percent_day
except AttributeError:
raise AttributeError(ticker.financial_data)
def get_ticker_data(self, symbol):
"""Returns the stock symbol ticker data, either from YAHOO or from local cache."""
now = datetime.datetime.now()
x = self.data_df2y_cache.get(symbol, None)
cache_time = self.data_cache_time.get(symbol, 99)
if cache_time != now.hour or x is None:
# Download from YAHOO
self.data_cache_time[symbol] = now.hour
t = Ticker(symbol, formatted=True)
valid = not "Quote not found" in t.price[symbol]
if valid:
df2y = t.history(period='2y', interval='1d')
df5y = t.history(period='5y', interval='1d')
df3m = t.history(period='3mo', interval='1d')
# 1d interval for 5y is overkill, but needed otherwise the plot will differ from the 2y plot due
# to quick variations.
price = float(t.price[list(
t.price)[0]]['regularMarketPrice']['fmt'].replace(',', ''))
short_name = t.quote_type[list(t.quote_type)[0]]['shortName']
else:
df2y = None
df5y = None
df3m = None
price = 0
short_name = "Unknown Ticker"
self.data_df2y_cache[symbol] = df2y
self.data_df5y_cache[symbol] = df5y
self.data_df3m_cache[symbol] = df3m
self.data_price_cache[symbol] = price
self.short_name_cache[symbol] = short_name
else:
# Get from Cache
df2y = self.data_df2y_cache.get(symbol)
df5y = self.data_df5y_cache.get(symbol)
df3m = self.data_df3m_cache.get(symbol)
price = self.data_price_cache.get(symbol)
return float(price), df3m, df5y, df2y
def get_stock_history(ticker, period, interval):
"""
Input example: {"stocks":["GOOG","MSFT"], "period":"1y", "interval":"1wk"}
"""
ticker = Ticker(ticker)
history = ticker.history(period=period, interval=interval)
dates = history.index.get_level_values(1).tolist()
close = history['close'].values.tolist()
open = history['open'].values.tolist()
high = history['high'].values.tolist()
low = history['low'].values.tolist()
result = {'dates': dates, "close": close, "open": open, "high": high, "low": low}
return jsonify(result)
def train(msg):
comm, ticket = msg.text.split()
ticker = Ticker(ticket, asynchronous=True)
df = ticker.history(period='5d', interval='1m')
if df[ticket] == 'No data found, symbol may be delisted':
bot.send_message(msg.chat.id, 'Не нашел такой :(')
else:
bot.send_message(msg.chat.id, 'Нужно немного подождать')
net.train(ticket)
bot.send_message(
msg.chat.id,
f'Модель по {ticket} обучена и будет доступна в течение часа.')
price = net.magic(ticket)
bot.send_message(
msg.chat.id,
f'Предполагаемая цена закрытия следующей свечи: {price}')
def get_papel_values(papel_alias):
ticker = Ticker(papel_alias)
sum = ticker.summary_detail
if sum[papel_alias] != "No fundamentals data found for any of the summaryTypes=summaryDetail":
end = datetime.now().strftime('%Y-%m-%d')
start = (datetime.now() - timedelta(days=180)).strftime('%Y-%m-%d')
ticker_hist = ticker.history(start=start, end=end)
if isinstance(ticker_hist, pd.DataFrame):
ticker_hist.sort_values(by='date', ascending=False, inplace=True)
else:
pass
else:
ticker_hist = 0
return ticker_hist
def max_sharpe(ticker, period='1y', interval='1d'):
x = Ticker(ticker,
retry=20,
status_forcelist=[404, 429, 500, 502, 503, 504])
data = x.history(period=period, interval=interval)
df = pd.DataFrame()
df[ticker] = data['close']
mu = expected_returns.mean_historical_return(df)
s = risk_models.sample_cov(df)
ef = EfficientFrontier(mu, s)
weights = ef.max_sharpe()
cleaned_weights = ef.clean_weights()
x = ef.portfolio_performance(verbose=False)
if x is None:
return 0
else:
return round(2.5 * x[2] / 15, 3) # sharpe adjusted weight
def update(self):
stratCalc = StrategyCalculator(self.tickerName)
tickers = Ticker(self.tickerName)
df = tickers.history(period='max', interval='1d')
# df = df.iloc[::-1]
endOfBacktest = False
while endOfBacktest == False:
if os.path.exists('./database/' + self.tickerName):
initialbool = False
if initialbool == False:
df.to_csv('./database/' + self.tickerName + '/temp.csv')
df = pd.read_csv('./database/' + self.tickerName +
'/temp.csv',
index_col=0)
initialbool = True
inputt = df
inputt = inputt.head(201)
inputt = inputt.iloc[::-1]
stratCalc.inform(df=inputt)
df = df.iloc[1:]
if len(df.index) < 201:
endOfBacktest = True
else:
print("Creating and Updating " + self.tickerName + " at " +
datetime.fromtimestamp(time.time()).strftime('%H:%M'))
os.makedirs('./database/' + self.tickerName + '/')
analysisColumnNames = [
'Time Stamp', 'Strategy', 'Position', 'Amount', 'Entry',
'Stop Loss', 'Take Profit', 'Confidence', 'Outcome',
'Profits', 'Points Gained/Lost'
]
analysisFrame = pd.DataFrame(columns=analysisColumnNames)
analysisFrame.to_csv('./database/' + self.tickerName +
'/analysis.csv')
tradeColumnNames = [
'Time Stamp', 'Position', 'Amount', 'Entry', 'Stop Loss',
'Target', 'Confidence', 'Leverage', 'Outcome', 'Profits'
]
tradeFrame = pd.DataFrame(columns=tradeColumnNames)
tradeFrame.to_csv('./database/' + self.tickerName +
'/trades.csv')
df.to_csv('./database/' + self.tickerName + '/temp.csv')
df = pd.read_csv('./database/' + self.tickerName + '/temp.csv')
def scrape(self):
tickers = Ticker(self.tickerName)
df = tickers.history(period='7d', interval='1m')
df = df.iloc[::-1]
if os.path.exists('./database/' + self.tickerName):
## This saving then re-reading is necessary to prevent the buggy header issues
df.to_csv('./database/' + self.tickerName + '/temp.csv')
df = pd.read_csv('./database/' + self.tickerName + '/temp.csv')
###########################
dfFirstTwoRows = df.head(2)
dfSecondRow = dfFirstTwoRows.iloc[1:].head(1)
dfDate = dfSecondRow['date'].values[0]
print("DfDate = " + str(dfDate))
database = pd.read_csv('./database/' + self.tickerName +
'/query.csv',
index_col=0)
databaseFirstTwoRow = database.head(2)
databaseSecondRow = databaseFirstTwoRow.iloc[1:].head(1)
dbDate = databaseSecondRow['date'].values[0]
print("DbDate = " + dbDate)
if not (dbDate == dfDate):
print("Updating " + self.tickerName + " at " +
datetime.fromtimestamp(time.time()).strftime('%H:%M'))
df.to_csv('./database/' + self.tickerName + '/query.csv')
self.stratCalc.inform(df.iloc[1:])
else:
print("Creating and Updating " + self.tickerName + " at " +
datetime.fromtimestamp(time.time()).strftime('%H:%M'))
os.makedirs('./database/' + self.tickerName + '/')
columnNames = [
'Time Stamp', 'Strategy', 'Position', 'Stop Loss',
'Take Profit', 'Outcome', 'Points Gained/Lost'
]
frame = pd.DataFrame(columns=columnNames)
frame.to_csv('./database/' + self.tickerName + '/analysis.csv')
df.to_csv('./database/' + self.tickerName + '/query.csv')
df.to_csv('./database/' + self.tickerName + '/temp.csv')
df = pd.read_csv('./database/' + self.tickerName + '/temp.csv')
self.stratCalc.inform(df.iloc[1:])
def get_stock_data(symbol, indicators=None):
ticker = Ticker(symbol)
df_ = ticker.history(period='2y', interval='1d')
df_ = df_[['high', 'open', 'low', 'adjclose', 'volume']]
df_.rename(columns={'adjclose': 'close'}, inplace=True)
basic_cols = ['high', 'open', 'low', 'close', 'volume']
if indicators is not None and 'ttm-squeeze' in indicators:
df_ = ttm_squeeze_indicators(df_)
basic_cols += [
'lower_band',
'upper_band',
'lower_keltner',
'upper_keltner',
'linreg',
]
return df_[basic_cols]
def downloadDaily(ticker_symbols, cnxn, engine):
cursor = cnxn.cursor()
cursor.execute('EXEC spProcessDailyData')
cursor.commit()
cursor.close()
for symbol in ticker_symbols:
ticker = Ticker(symbol)
daily = ticker.history(period='1y', interval='1d')
print(f'Downloading {symbol}.')
# for single symbol dowload, add column symbol and date as indexes
daily['symbol'] = symbol
daily.reset_index(inplace=True)
daily.rename(columns={'index': 'date'}, inplace=True)
daily.set_index(['symbol', 'date'], inplace=True)
daily.to_sql('tmpDaily',
engine,
if_exists='append',
schema='dbo',
index=True)
#print('Saved to table daily')
df_options = ticker.option_chain
#check if it's string, if yes, there is no option chain
if isinstance(df_options, str) == False:
print(f'Downloading option chain {symbol}.')
df_options['createDate'] = datetime.date.today()
df_options.to_sql('Option',
engine,
if_exists='append',
schema='dbo',
index=True)
cursor = cnxn.cursor()
cursor.execute('EXEC spProcessDailyData')
cursor.commit()
cursor.close()
def get_all(symbols):
# %%
print(len(symbols))
# %%
all_tickers = Ticker(symbols)
df2 = all_tickers.history(period='2y', interval='1d')
if isinstance(df2, pd.core.frame.DataFrame) and not df2.empty:
pg_db.df_to_db(df2.reset_index()[DB_COLUMNS],
name='temp_yahoo_stock_data',
if_exists='replace',
index=False)
# %%
else:
final_df = pd.DataFrame()
for idx, (symbol, dataframe) in enumerate(df2.items(), start=1):
print(symbol)
if isinstance(dataframe,
pd.core.frame.DataFrame) and not dataframe.empty:
print(dataframe.head())
dataframe['symbol'] = symbol
dataframe.reset_index(inplace=True)
dataframe.rename(columns={'index': 'date'}, inplace=True)
final_df = pd.concat([final_df, dataframe])
if idx % 100 == 0 or idx == len(df2):
if_exists = 'replace' if idx == 100 else 'append'
try:
if if_exists == 'replace' and 'splits' not in final_df.columns:
final_df['splits'] = None
pg_db.df_to_db(final_df[DB_COLUMNS],
name='temp_yahoo_stock_data',
if_exists=if_exists,
index=False)
except AttributeError:
print(final_df)
print(f'completed {symbol}, {idx} of {len(df2)}')
def magic(ticket):
ticket = ticket.lower()
model = load_model(f'/Users/maximsurovtsev/Stocks prediction/{ticket}')
# ts = TimeSeries(key=ALPHA_VANTAGE_API_KEY, output_format='pandas')
ticker = Ticker(ticket, asynchronous=True)
new_data = ticker.history(period='5d', interval='1m')
# new_data, data_info = ts.get_intraday(ticket, outputsize='full', interval='5min')
# new_data = new_data[::-1].filter(['4. close'])
new_data = new_data.filter(['close'])
last_60 = new_data[-60:].values
scaler = MinMaxScaler(feature_range=(0, 1))
scaler.fit_transform(new_data)
last_60 = scaler.transform(last_60)
scaled = np.array([last_60])
scaled = np.reshape(scaled, (scaled.shape[0], scaled.shape[1], 1))
pred_price = scaler.inverse_transform(model.predict(scaled))
return round(float(pred_price[0][0]), 3)
