def send_head(self):
"""Common code for GET and HEAD commands.
This sends the response code and MIME headers.
Return value is either a file object (which has to be copied
to the outputfile by the caller unless the command was HEAD,
and must be closed by the caller under all circumstances), or
None, in which case the caller has nothing further to do.
"""
print self.path
request_path = self.path[1:]
ctype = 'application/octet-stream'
f = StringIO()
params = parse_qs(urlparse(request_path).query)
stock = params['s'][0]
month_begin = params['a'][0]
day_begin = params['b'][0]
year_begin = params['c'][0]
month_end = params['d'][0]
day_end = params['e'][0]
year_end = params['f'][0]
type = params['g'][0]
yf.pdr_override()
data_begin_str = year_begin + "-" + month_begin +"-" + day_begin
date_end_str = year_end + "-" + month_end +"-" + day_end
if(type == 'd'):
action_to_request = None
else:
action_to_request = 'only'
print stock, data_begin_str, date_end_str, action_to_request
pandas_data = yf.download(stock, start = data_begin_str, end = date_end_str, actions = action_to_request)
print pandas_data
if('d' == type):
data = pandas_data.to_csv(columns = ['Open','High','Low','Close','Volume','Adj Close'])
else:
data = pandas_data.to_csv(columns = ['action','value'])
f.write(data)
self.send_response(200)
length = f.tell()
f.seek(0)
self.send_header("Content-type", ctype)
self.send_header("Content-Length", str(length))
self.end_headers()
return f
def downloader(self):
startDate = datetime.date(2017,1,1)
self.last_downloaded = startDate
yf.pdr_override()
try:
print 'ILS'
self.download_currency_quotes(startDate)
print 'EUR'
self.download_currency_quotes(startDate, 'EUR')
self.last_downloaded = datetime.date.today()
except:
print 'not downloaded at: ' + str(datetime.datetime.now()) #try again later
while True:
self._downloader()
time.sleep(60*60)
def main():
# FinancialKey.creat_StockPriceProcess_file()
yf.pdr_override()
stock_id = take_stock_id_by_sql()
#-----------------------------------------------
i = 1
for stock in stock_id['stock_cid']:
print(str(i)+'/'+str(len(stock_id)) + ' : ' + stock)
self = crawler_new_stock_price(stock,stock_id)
self.main()
save_new_craw_process(stock)
i=i+1
# stock='0053'
#------------------------------------------------------
text = 'insert into StockPriceProcess (name,stockdate,time) values(%s,%s,%s)'
today = str( datetime.datetime.now().strftime("%Y-%m-%d") )
tem = str( datetime.datetime.now() )
time = re.split('\.',tem)[0]
value = ('StockPrice',today,time)
stock_sql.Update2Sql(host,user,password,
'python',text,value)
import pandas as pd
import pandas_datareader as pdr
import matplotlib.pyplot as plt
from fix_yahoo_finance import pdr_override
# fix cant get yahoo data
pdr_override()
START_DATE = '2014-06-01'
END_DATE = '2016-06-13'
# a = pdr.get_data_yahoo('AAL', START_DATE, END_DATE)
# print(a['Adj Close'])
pd.concat()
print('------- TASK 1 ------\n')
# LFL replace to ADR
symbols = ['AAL', 'ALK', 'AVH', 'CEA', 'ZNH', 'VLRS', 'CPA', 'DAL', 'GOL', 'LUV', 'UAL']
all_data = {symbol : pdr.get_data_yahoo(symbol, START_DATE, END_DATE) for symbol in symbols}
print(all_data['AAL'].head(2))
print('---------------------\n')
print('------- TASK 2 ------\n')
luvdf = pd.read_csv('LUV.csv', index_col='Date', parse_dates=True)
print(luvdf.head(2))
print('---------------------\n')
print('------- TASK 3 ------\n')
luvdf = luvdf[START_DATE : END_DATE]
print('---------------------\n')
def yahoo_finance_bridge():
"""
This function fixes problems w.r.t. fetching data from Yahoo Finance
:return: None
"""
pdr_override()
import pandas as pd
import numpy as np
# libraries to load underlying daily time series
from pandas_datareader import data as pdr
import warnings
warnings.filterwarnings("ignore")
warnings.simplefilter("ignore", category=PendingDeprecationWarning)
with warnings.catch_warnings():
warnings.filterwarnings("ignore",category=DeprecationWarning)
import fix_yahoo_finance as yf #https://github.com/ranaroussi/fix-yahoo-finance
yf.pdr_override() # fix
# TIPS: get cell value: #data.loc[data.index == '2017-06-29'].iloc[0]['Volatility']
class HelperFunctions(object):
def cleanParams(self, a):
ND = a[0]
FD = a[1]
NO = [str(np.round(i,2)) for i in a[2]]
FO = [str(np.round(i,2)) for i in a[3]]
return [ND,FD,NO,FO]
def printStrat(self, strategies, mode="print"):
simid = []; sim_pnl = [];wins = [];losses = [];trades = [];params = []; daysForward = []
for i in strategies.keys():
simid.append(i)
sim_pnl.append(strategies[i].get("Total PNL"))
wins.append(strategies[i].get("Win Trades"))
losses.append(strategies[i].get("Lose Trades"))
def mainfunc():
yf.pdr_override() # fix yahoo finance api
df = pdr.get_data_yahoo('0700.HK', start=ini_time, end=end_time)
print(df)
def crawler_history_stock_price(stock_info):
def upload_stock_price2sql(data,dataset_name):
dataset_name = dataset_name.replace('.','_')
conn = ( pymysql.connect(host = host,# SQL IP
port = 3306,
user = user,
password = password,
database='StockPrice',
charset="utf8") )
for j in range(len(data)):
( conn.cursor().execute( 'insert into ' + dataset_name +
'( Date ,stock_id ,Open ,High ,Low ,Close ,'+
' Adj_Close , Volume )'+' values(%s,%s,%s,%s,%s,%s,%s,%s)',
( data['Date'][j],data['stock_id'][j],
float( data['Open'][j] ),
float( data['High'][j] ),
float( data['Low'][j] ),
float( data['Close'][j] ),
float( data['Adj Close'][j] ),
int( data['Volume'][j] )
) ) )
conn.commit()
conn.close()
#----------------------------------------------------------------
yf.pdr_override() # <== that's all it takes :-) \
stock_id_log = []
len_data_log = []
now = datetime.datetime.now()
end = str( now.year ) + '-' + str( now.month )+ '-' +str( now.day+1 )
for i in range(len(stock_info)):
print(str(i)+'/'+str(len(stock_info)))
# stock_id = '1593'
stock_id = str( stock_info.stock_id[i] ) + '.TW'
stock_id2 = str( stock_info.stock_id[i] ) + '.TWO'
#print(stock_info.stock_id[i])
bo = 1
while( bo ):
data = pdr.get_data_yahoo(stock_id, start='1900-1-10', end=end)
data['stock_id'] = stock_id
dataset_name = '_'+stock_id
if len(data) == 0:
data = pdr.get_data_yahoo(stock_id2, start='1900-1-10', end=end)
data['stock_id'] = stock_id2
dataset_name = '_'+stock_id2
if len(data) != 0:
bo=0
#print(stock_id2)
#print('len(data) = ' + str( len(data) ) )
stock_id_log.append(stock_id)
len_data_log.append(len(data))
data['Date'] = data.index
data.index = range(len(data))
#data['stock_name'] = stock_name
data.Date = np.array( [ str(data.Date[i]).split(' ')[0] for i in range(len(data)) ] )
upload_stock_price2sql(data,dataset_name)
stock_log = pd.DataFrame({'stock_id_log':stock_id_log,
'len_data_log':len_data_log})
return stock_log
def calcStock(self):
tf.reset_default_graph()
tf.set_random_seed(777)
def data_standardization(x):
x_np = np.asarray(x)
return (x_np - x_np.mean()) / x_np.std()
def min_max_scaling(x):
x_np = np.asarray(x)
return (x_np - x_np.min()) / (x_np.max() - x_np.min() + 1e-7)
def reverse_min_max_scaling(org_x, x):
org_x_np = np.asarray(org_x)
x_np = np.asarray(x)
return (x_np * (org_x_np.max() - org_x_np.min() + 1e-7)) + org_x_np.min()
input_data_column_cnt = 6
output_data_column_cnt = 1
seq_length = 28
rnn_cell_hidden_dim = 20
forget_bias = 1.0
num_stacked_layers = 1
keep_prob = 1.0
epoch_num = 50
learning_rate = 0.01
yf.pdr_override()
start_date = '1996-05-06'
print(start_date)
print(self.comCode)
df = data.get_data_yahoo(self.comCode, start_date)
df.to_csv('./STOCK.csv', mode='w')
stock_file_name = 'STOCK.csv'
encoding = 'euc-kr'
names = ['Date','Open','High','Low','Close','Adj Close','Volume']
raw_dataframe = pd.read_csv(stock_file_name, names=names, encoding=encoding)
del raw_dataframe['Date']
stock_info = raw_dataframe.values[1:].astype(np.float)
price = stock_info[:,:-1]
norm_price = min_max_scaling(price)
volume = stock_info[:,-1:]
norm_volume = min_max_scaling(volume)
x = np.concatenate((norm_price, norm_volume), axis=1)
y = x[:, [-2]]
dataX = []
dataY = []
for i in range(0, len(y) - seq_length):
_x = x[i : i+seq_length]
_y = y[i + seq_length]
if i is 0:
print(_x, "->", _y)
dataX.append(_x)
dataY.append(_y)
train_size = int(len(dataY) * 0.7)
test_size = len(dataY) - train_size
trainX = np.array(dataX[0:train_size])
trainY = np.array(dataY[0:train_size])
testX = np.array(dataX[train_size:len(dataX)])
testY = np.array(dataY[train_size:len(dataY)])
X = tf.placeholder(tf.float32, [None, seq_length, input_data_column_cnt])
Y = tf.placeholder(tf.float32, [None, 1])
targets = tf.placeholder(tf.float32, [None, 1])
predictions = tf.placeholder(tf.float32, [None, 1])
def lstm_cell():
cell = tf.contrib.rnn.BasicLSTMCell(num_units=rnn_cell_hidden_dim,
forget_bias=forget_bias, state_is_tuple=True, activation=tf.nn.softsign)
if keep_prob < 1.0:
cell = tf.contrib.rnn.DropoutWrapper(cell, output_keep_prob=keep_prob)
return cell
stackedRNNs = [lstm_cell() for _ in range(num_stacked_layers)]
multi_cells = tf.contrib.rnn.MultiRNNCell(stackedRNNs, state_is_tuple=True) if num_stacked_layers > 1 else lstm_cell()
hypothesis, _states = tf.nn.dynamic_rnn(multi_cells, X, dtype=tf.float32)
print("hypothesis: ", hypothesis)
hypothesis = tf.contrib.layers.fully_connected(hypothesis[:, -1], output_data_column_cnt, activation_fn=tf.identity)
loss = tf.reduce_sum(tf.square(hypothesis - Y))
optimizer = tf.train.AdamOptimizer(learning_rate)
train = optimizer.minimize(loss)
rmse = tf.sqrt(tf.reduce_mean(tf.squared_difference(targets, predictions)))
train_error_summary = []
test_error_summary = []
test_predict = ''
sess = tf.Session()
sess.run(tf.global_variables_initializer())
for epoch in range(epoch_num):
_, _loss = sess.run([train, loss], feed_dict={X: trainX, Y: trainY})
if ((epoch+1) % 100 == 0) or (epoch == epoch_num-1):
train_predict = sess.run(hypothesis, feed_dict={X: trainX})
train_error = sess.run(rmse, feed_dict={targets: trainY, predictions: train_predict})
train_error_summary.append(train_error)
test_predict = sess.run(hypothesis, feed_dict={X: testX})
test_error = sess.run(rmse, feed_dict={targets: testY, predictions: test_predict})
test_error_summary.append(test_error)
recent_data = np.array([x[len(x)-seq_length : ]])
print("recent_data.shape:", recent_data.shape)
print("recent_data:", recent_data)
price_predict = sess.run(hypothesis, feed_dict={X: recent_data})
print("test_predict", test_predict[0])
print("--------------------------------------------------")
for i in range(10):
print(test_predict[0])
print("--------------------------------------------------")
price_predict = reverse_min_max_scaling(price,price_predict)
test_predict = reverse_min_max_scaling(price,test_predict)
testY = reverse_min_max_scaling(price,testY)
print("Tomorrow's stock price", price_predict[0])
return testY, test_predict, train_error_summary, test_error_summary, price_predict[0]
# 4. More stock manipulations
# resample()
import os
os.getcwd()
os.chdir(
'C:\\Users\\sxw17\\Desktop\\python learning\\Python for Finance\\Python_Programming_for_Finance'
)
import datetime as dt
import matplotlib.pyplot as plt
from matplotlib import style
import pandas as pd
import fix_yahoo_finance as fy
fy.pdr_override()
from pandas.api.types import is_list_like
import pandas as pd
pd.core.common.is_list_like = pd.api.types.is_list_like
import pandas_datareader.data as web
style.use('ggplot')
start = dt.datetime(2000, 1, 1)
end = dt.datetime(2019, 7, 5)
df = web.DataReader('TSLA', 'yahoo', start, end)
print(df.head())
def load_yhoo_data(symbol, symbol_id, vendor_id, conn):
"""
This will load stock data (date+OHLCV) and additional info to our daily_data table.
args:
symbol: stock ticker, type string.
symbol_id: stock id referenced in symbol(id) column, type integer.
vendor_id: data vendor id referenced in data_vendor(id) column, type integer.
conn: a Postgres DB connection object
return:
None
"""
cur = conn.cursor()
# generic start date should pull all data for a given symbol
start_dt = datetime.datetime(2004, 12, 30)
end_dt = datetime.datetime(2017, 12, 1)
yf.pdr_override()
try:
data = yf.download(symbol, start=start_dt, end=end_dt)
except:
MASTER_LIST_FAILED_SYMBOLS.append(symbol)
raise Exception('Failed to load {}'.format(symbol))
data['Date'] = data.index
# create new dataframe matching our table schema
# and re-arrange our dataframe to match our database table
columns_table_order = [
'data_vendor_id', 'stock_id', 'created_date', 'last_updated_date',
'date_price', 'open_price', 'high_price', 'low_price', 'close_price',
'adj_close_price', 'volume'
]
newDF = pd.DataFrame()
newDF['date_price'] = data['Date']
newDF['open_price'] = data['Open']
newDF['high_price'] = data['High']
newDF['low_price'] = data['Low']
newDF['close_price'] = data['Close']
newDF['adj_close_price'] = data['Adj Close']
newDF['volume'] = data['Volume']
newDF['stock_id'] = symbol_id
newDF['data_vendor_id'] = vendor_id
newDF['created_date'] = datetime.datetime.utcnow()
newDF['last_updated_date'] = datetime.datetime.utcnow()
newDF = newDF[columns_table_order]
# ensure our data is sorted by date
newDF = newDF.sort_values(by=['date_price'], ascending=True)
# convert our dataframe to a list
list_of_lists = newDF.values.tolist()
# convert our list to a list of tuples
tuples_mkt_data = [tuple(x) for x in list_of_lists]
# WRITE DATA TO DB
insert_query = """
INSERT INTO daily_data (data_vendor_id, stock_id, created_date,
last_updated_date, date_price, open_price, high_price, low_price, close_price,
adj_close_price, volume)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
"""
cur.executemany(insert_query, tuples_mkt_data)
conn.commit()
print('{} complete!'.format(symbol))
def create_shifted_orderbook_more_feature(ticker,
start_date,
end_date,
lag_period=5,
pred_period=7):
"""
Shifts order book data. Determines stock movement direction. Incorporates technical indicators as training features.
:param ticker: stock ticker
:param start_date: start date for stock data collection period
:param end_date: end date for stock data collection period
:param lag_period: number of previous prices trained on
:param pred_period: number of days forecast
:return:
stock_data: the price/volume info for a stock
stock_returns: percent change between days and lagging percent changes (i.e. previous days' changes)
stock_lag: stock price and lagging stock price
stock_movement: stock movement direction (+1: increase, -1: decrease)
"""
# Retrieve the Nifty data from Yahoo finance:
format = '%Y-%m-%d' # Formatting directives
start = start_date.strftime(format)
end = end_date.strftime(format)
yf.pdr_override() # <== that's all it takes :-)
stock_data = pdr.get_data_yahoo(ticker, start=start, end=end)
# Creates stock lag
stock_data.dropna()
stock_lag = pd.DataFrame(data=stock_data, index=stock_data.index)
stock_returns = pd.DataFrame(data=stock_data, index=stock_data.index)
# Initializes dataframe values and smooths the closing price data
stock_data_smooth = stock_data['Adj Close']
exponential_smoothing(
0.7, stock_data_smooth) #so the stock_data_smooth is smoothing
#stock_lag['Volume'] = stock_returns['Volume'] = stock_data['Volume']
stock_lag[
"Close"] = stock_data_smooth #so, now the stock_lag["Close"] is derive from Adj Close + smoothing.
#print stock_lag["Close"]
# Sets lagging price data (previous days' price data as feature inputs)
for i in range(0, lag_period):
column_label = 'Lag{:d}'.format(i)
stock_lag[column_label] = stock_lag['Close'].shift(1 + i)
# EMA- Momentum
#stock_lag['EMA'] = talib.EMA(close, timeperiod = 30)
ndays = 30
name_EWMA = 'EWMA_' + str(ndays)
stock_lag['EWMA_'] = EWMA(stock_lag, ndays)[name_EWMA]
# Bollinger Bands
#stock_lag['upperband'], stock_lag['middleband'], stock_lag['lowerband'] = talib.BBANDS(close, timeperiod=5, nbdevup=2, nbdevdn=2, matype=0)
aa = BBANDS(stock_lag, ndays=30)
stock_lag['upperband'] = aa['Upper BollingerBand']
stock_lag['lowerband'] = aa['Lower BollingerBand']
# StochK
#stock_lag['slowk'], stock_lag['slowd'] = talib.STOCH(high, low, close, fastk_period=14, slowk_period=3, slowk_matype=0, slowd_period=3,
# slowd_matype=0)
n = 30
name_slowk = 'SO%k'
name_slowd = 'SO%d_' + str(n)
stock_lag['slowk'] = STOK(stock_lag)[name_slowk]
stock_lag['slowd'] = STO(stock_lag, n)[name_slowd]
# MACD- Momentum
#macd, macdsignal, stock_lag['macdhist'] = talib.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
n_fast = 12
n_slow = 26
name_macd = 'MACD_' + str(n_fast) + '_' + str(n_slow)
name_macdsignal = 'MACDsign_' + str(n_fast) + '_' + str(n_slow)
name_macdhist = 'MACDdiff_' + str(n_fast) + '_' + str(n_slow)
macd = MACD(stock_lag, n_fast, n_slow)[name_macd]
macdsignal = MACD(stock_lag, n_fast, n_slow)[name_macdsignal]
stock_lag['macdhist'] = MACD(stock_lag, n_fast, n_slow)[name_macdhist]
# CCI- Momentum
#stock_lag['CCI'] = talib.CCI(high, low, close)
stock_lag['CCI'] = CCI(stock_lag, ndays=30)["CCI"]
#print stock_lag['CCI']
# # RSI- Momentum
# #stock_lag['RSI'] = talib.RSI(close, timeperiod=14)
# ndays = 14
# name_RSI = 'RSI_' + str(ndays)
# stock_lag['RSI'] = RSI(stock_lag, n = ndays)[name_RSI]
# #print stock_lag['RSI']
# Chaikin- Volume
#stock_lag['Chaikin'] = talib.ADOSC(high, low, close, volume, fastperiod=3, slowperiod=10)
stock_lag['Chaikin'] = Chaikin(stock_lag)['Chaikin']
#print stock_lag['Chaikin']
stock_returns['Day Returns'] = stock_data['Adj Close'].pct_change() * 100
# Sets lagging percent change data
for i in range(0, lag_period):
column_label = 'Lag{:d}'.format(i)
stock_returns[column_label] = stock_lag[column_label].pct_change(
) * 100
# Remove NaN's from stock lag
print "shape of stock_lag before dropna: ", stock_lag.shape[0]
stock_lag = stock_lag.dropna(axis=0, how='any')
print "shape of stock_lag before dropna: ", stock_lag.shape[0]
print "shape of stock_returns before dropna: ", stock_returns.shape[0]
# Adjusts stock_return data to same length as stock_lag
stock_returns = stock_returns.tail(stock_lag.shape[0])
print "shape of stock_returns after dropna: ", stock_returns.shape[0]
# Determine stock movement direction and lagging movement
stock_movement = pd.DataFrame(index=stock_returns.index)
stock_movement['Movement_0'] = np.sign(stock_returns['Day Returns'])
stock_movement['Movement_0'][0] = 1
for i in range(0, pred_period):
column_label = 'Movement_{:d}'.format(i + 1)
stock_movement[column_label] = stock_movement['Movement_0'].shift(i +
1)
# Removes NaNs from 'stock_movement' and resizes 'stocks_returns' and 'stock_lag' accordingly
print "shape of stock_movement before dropna: ", stock_movement.shape[0]
stock_movement = stock_movement.dropna(axis=0, how='any')
print "shape of stock_movement after dropna: ", stock_movement.shape[0]
stock_returns = stock_returns[stock_returns.index <= stock_movement.index[
stock_movement.index.__len__() - 1]]
stock_returns = stock_returns.tail(stock_movement.shape[0])
stock_lag = stock_lag[stock_lag.index <= stock_movement.index[
stock_movement.index.__len__() - 1]]
stock_lag = stock_lag.tail(stock_movement.shape[0])
return stock_data, stock_returns, stock_lag, stock_movement
def plot():
from pandas_datareader import data
import datetime
import fix_yahoo_finance as yf
yf.pdr_override()
from bokeh.plotting import figure, show, output_file
from bokeh.embed import components
from bokeh.resources import CDN
start = datetime.datetime(2015, 11, 1)
end = datetime.datetime(2016, 3, 10)
yf.pdr_override()
df = data.get_data_yahoo(tickers="GOOG", start=start, end=end)
# criando uma nova coluna pra armazenar se o dia teve fechamento peositivo ou negativo
def inc_dec(c, o):
if c > o:
value = "Increase"
elif c < o:
value = "Decrease"
else:
value = "Equal"
return value
df["Status"] = [inc_dec(c, o) for c, o in zip(df.Close, df.Open)]
# criando colunas aux para plotar os gráficos
df["Middle"] = (df.Open + df.Close) / 2
df["Height"] = abs(df.Close - df.Open)
date_increase = df.index[df.Close > df.Open]
date_decrease = df.index[df.Close < df.Open]
p = figure(x_axis_type="datetime", width=1000, height=300)
p.title.text = "Candlestick Chart"
p.grid.grid_line_alpha = 0.3
hours_12 = 12 * 60 * 60 * 1000
# cria as linhas do plot
p.segment(df.index, df.High, df.index, df.Low, color="Black")
# caso o dia tenha fechado em alta
p.rect(df.index[df.Status == "Increase"],
df.Middle[df.Status == "Increase"],
hours_12,
df.Height[df.Status == "Increase"],
fill_color='green',
line_color="black")
# caso o dia tenha fechado em baixa
p.rect(df.index[df.Status == "Decrease"],
df.Middle[df.Status == "Decrease"],
hours_12,
df.Height[df.Status == "Decrease"],
fill_color='red',
line_color="black")
script1, div1 = components(p)
cdn_js = CDN.js_files[0]
cdn_css = CDN.css_files[0]
return render_template("plot.html",
script1=script1,
div1=div1,
cdn_css=cdn_css,
cdn_js=cdn_js)
# In[ ]:
#Initialize and set debugging level to `debug` to track progress.
# In[ ]:
get_ipython().magic('matplotlib inline')
import numpy as np
import pandas as pd
from pandas_datareader import data as pdr
# data reader now seperated to new package. pip install pandas-datareader
#from pandas.io.data import DataReader
import fix_yahoo_finance as yf
yf.pdr_override() # <== that's all it takes :-)
from datetime import datetime
import six
import universal as up
from universal import tools
from universal import algos
import logging
# we would like to see algos progress
logging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG)
import matplotlib as mpl
import matplotlib.pyplot as plt
# we need 14 colors for the plot
#n_lines = 14
import csv
import pandas as pd
pd.core.common.is_list_like = pd.api.types.is_list_like
from pandas_datareader import data
import fix_yahoo_finance
fix_yahoo_finance.pdr_override()
chdata = data.get_data_yahoo(
# tickers list (single tickers accepts a string as well)
tickers="SPY",
# start date (YYYY-MM-DD / datetime.datetime object)
# (optional, defaults is 1950-01-01)
start="2017-01-01",
# end date (YYYY-MM-DD / datetime.datetime object)
# (optional, defaults is Today)
end="2017-12-31",
# return a multi-index dataframe
# (optional, default is Panel, which is deprecated)
as_panel=False,
# group by ticker (to access via data['SPY'])
# (optional, default is 'column')
group_by='ticker',
# adjust all OHLC automatically
# (optional, default is False)
auto_adjust=True,
import pandas as pd from pandas_datareader import data, wb import fix_yahoo_finance as yf yf.pdr_override() import datetime import numpy as np from datetime import timedelta from sqlalchemy import create_engine #To get data: ticker = ['IBM', 'ICE', 'IDXX', 'IFF', 'ILMN', 'INCY', 'INFO', 'INTC', 'INTU', 'IP', 'IPG', 'IQV', 'IR', 'IRM', 'ISRG', 'IT', 'ITW', 'IVZ',
import pandas_datareader.data as pdr
import fix_yahoo_finance as fix
import numpy as np
fix.pdr_override()
def back_test(strategy, seq_len, ticker, start_date, end_date, dim):
"""
A simple back test for a given date period
:param strategy: the chosen strategy. Note to have already formed the model, and fitted with training data.
:param seq_len: length of the days used for prediction
:param ticker: company ticker
:param start_date: starting date
:type start_date: "YYYY-mm-dd"
:param end_date: ending date
:type end_date: "YYYY-mm-dd"
:param dim: dimension required for strategy: 3dim for LSTM and 2dim for MLP
:type dim: tuple
:return: Percentage errors array that gives the errors for every test in the given date range
"""
data = pdr.get_data_yahoo(ticker, start_date, end_date)
stock_data = data["Adj Close"]
errors = []
for i in range((len(stock_data)//10)*10 - seq_len - 1):
x = np.array(stock_data.iloc[i: i + seq_len, 1]).reshape(dim) / 200
y = np.array(stock_data.iloc[i + seq_len + 1, 1]) / 200
predict = strategy.predict(x)
while predict == 0:
predict = strategy.predict(x)
error = (predict - y) / 100
errors.append(error)
def __init__(self,stock,stock_id):
yf.pdr_override()
self.stock = str( stock )
self.stock_id = stock_id
import pandas as pd
pd.core.common.is_list_like = pd.api.types.is_list_like
import fix_yahoo_finance as fyf
from pandas_datareader import data as pdr
import numpy as np
import datetime
import xlrd
fyf.pdr_override()
# We will look at stock prices over the past year, starting at January 1, 2016
#startd = datetime.datetime(2016,1,1)
#endd = datetime.date.today()
#BABA = pdr.get_data_yahoo("BABA", start=startd, end=endd)
#BABA = pdr.get_data_yahoo("BABA", start=endd, end=endd)
#BABA_np = np.array(BABA)
#type(BABA)
#print(BABA_np)
df = pd.read_excel("ipo.xlsx")
df_np = np.array(df)
print(df_np.shape)
print(df_np[1])
import datetime
import time
from pandas_datareader import data as pdr
import fix_yahoo_finance as yf
yf.pdr_override() # <== that's all it takes :-)
end_date = datetime.datetime.now().strftime('%Y-%m-%d')
start_date = (datetime.datetime.now()- datetime.timedelta(days=5*365)).strftime('%Y-%m-%d')
# n 年的資料
SID = "HYG"
out_file = "HYG.csv"
def true_val(current_date, current_val, dividend_dataframe):
# return current_val # 不還原權值滿
ret = current_val
for idx, dividend_date in enumerate(dividend_dataframe.index.values):
if dividend_date <= current_date:
ret = ret + dividend_dataframe.iloc[idx][0]
return ret
# 分紅資料
dividend_dataframe = pdr.get_data_yahoo(SID, start=start_date, end=end_date,actions='only')
print(dividend_dataframe)
time.sleep(5)
# 日K 資料
data = pdr.get_data_yahoo(SID, start=start_date, end=end_date)
for idx, current_date in enumerate(data.index.values):
#!/usr/bin/env python
import fix_yahoo_finance as y
import matplotlib.pyplot as plt
from pandas_datareader import data as pdr
y.pdr_override()
class Company:
def __init__(self, name):
self.name = name
def sort_data(data):
data = data.split('\n')
data_dict = {}
dates = []
open_prices = []
high_prices = []
low_prices = []
close_prices = []
adj_close_prices = []
vol_prices = []
for i in data[1:]:
l = i.split(',')
if len(l) != 7:
continue
dates.append(l[0])
open_prices.append(float(l[1]))
high_prices.append(float(l[2]))
import argh
import pandas as pd
import time
import glob
import os
import mylib.io
import pyarrow as pa
import pyarrow.parquet as pq
import shutil
import dask.bag as db
from joblib import Memory
from pandas_datareader import data as pdr
import fix_yahoo_finance as yf
yf.pdr_override()
_mydir = os.path.dirname(os.path.realpath(__file__))
cachedir = os.path.join(_mydir, 'joblib_cache')
memory = Memory(cachedir, verbose=1)
# WARNING: persistant state here, clear if worried
_period_seconds = 1
@memory.cache
@sleep_and_retry
@limits(calls=1, period=_period_seconds)
def _get_data_yahoo(names, start, end):
return pdr.get_data_yahoo(names, start=start, end=end)
def get_data_yahoo(names, start, end):
from django.http import HttpResponse, FileResponse
from django.shortcuts import render
from pandas_datareader import data as pdr
# pip install multitasking
# pip install fix_yahoo_finance
import fix_yahoo_finance as yf
import tushare as ts
import pandas as pd
import numpy as np
from pandas_datareader import data, wb
import matplotlib.pyplot as plt
from sklearn.svm import SVR
from flower.models import AllStockBasic, RealTimePens, HISData
yf.pdr_override() #需要调用这个函数
# 获取数据
PATH = r"flower/flowerData/stock/"
FILENAME = r"stock.csv"
FILENAME2 = r"wu.csv"
FILENAME3 = r"wu1.csv"
def index(request):
return render(request, "stock.html")
def showStock(request):
data = RealTimePens.objects.all()
context = {"data": data}
return render(request, "ajax/ajax_stock.html", context)
