dbutils.library.restartPython() dbutils.library.list() # COMMAND ---------- import yfinance as data import matplotlib.pyplot as plt import pandas as pd import datetime start_date = '2014-08-31' end_date = '2019-08-31' from pandas_datareader import data as pdr import yfinance as yf yf.pdr_override( ) # <== that's all it takes :-) #data = yf.download("SPY AAPL MSFT", start="2018-01-01", end="2018-04-30",group_by="ticker") # download dataframe and Use pandas_reader.data.DataReader to load the desired data. As simple as that. appleData = pdr.get_data_yahoo("AAPL", start_date, end_date, group_by="ticker") #spyData = pdr.get_data_yahoo("SPY",start_date, end_date,group_by="ticker") # COMMAND ---------- appleData.head(5) # COMMAND ---------- #appleData.shape[1] #appleData.shape[1] #appleData.iloc[0][1] appleData.head(5) appleData.describe
def prediction(): #db연동 stock_db = pymysql.connect( host='127.0.0.1', user='******', passwd='', #자신비밀번호 db='stock', charset='utf8') cursor = stock_db.cursor(pymysql.cursors.DictCursor) sql = "SELECT * FROM stock_item;" #select쿼리 cursor.execute(sql) result = cursor.fetchall() #원래코드 #result = [cursor.fetchone()]#한개만 가져옴#test용 print(result) for i in result: stock_name = i['stock_name'] tf.reset_default_graph() yf.pdr_override() tf.set_random_seed(777) start_date = '2010-01-01' name = i['stock_code'] stock_code = name stock = data.get_data_yahoo(name, start_date) stock = stock[:-1] #stock:주가 데이터들 저장 # 정규화 def min_max_scaling(x): x_np = np.asarray(x) return (x_np - x_np.min()) / (x_np.max() - x_np.min() + 1e-7 ) # 1e-7은 0으로 나누는 오류 예방차 # 역정규화 : 정규화된 값을 원래의 값으로 되돌림 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_dcm_cnt = 6 #입력데이터의 컬럼 개수 output_dcm_cnt = 1 #결과데이터의 컬럼 개수 seq_length = 28 #1개 시퀸스의 길이(시계열데이터 입력 개수) rnn_cell_hidden_dim = 20 #각 셀의 히든 출력 크기 forget_bias = 1.0 #망각편향(기본값 1.0) num_stacked_layers = 1 #Stacked LSTM Layers 개수 keep_prob = 1.0 #Dropout 할때 Keep할 비율 epoch_num = 1000 #에포크 횟수 (몇회 반복 학습) learning_rate = 0.01 #학습률 stock_info = stock.values[1:].astype(np.float) price = stock_info[:, :-1] # <- here norm_price = min_max_scaling(price) volume = stock_info[:, -1:] # <- here 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] dataX.append(_x) dataY.append(_y) train_size = int(len(dataY) * 0.7) test_size = len(dataY) - train_size 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_dcm_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) ] #Stacked LSTM Layers 개수 1 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) hypothesis = tf.contrib.layers.fully_connected( hypothesis[:, -1], output_dcm_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()) #학습 start_time = datetime.datetime.now() print('학습 시작...') 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): # 100번째마다 또는 마지막 epoch인 경우 # 학습용데이터로 rmse오차를 구한다 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) # 테스트용데이터로 rmse오차를 구한다 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) print( "epoch: {}, train_error(A): {}, test_error(B): {}, B-A: {}" .format(epoch + 1, train_error, test_error, test_error - train_error)) end_time = datetime.datetime.now() #종료시간을 기록 elapsed_time = end_time - start_time # 경과시간을 구한다 # 결과 그래프 출력 plt.figure(1) plt.plot(train_error_summary, 'gold') plt.plot(test_error_summary, 'b') plt.xlabel('Epoch(x100)') plt.ylabel('Root Mean Square Error') plt.figure(2) plt.plot(testY, 'r') plt.plot(test_predict, 'b') plt.xlabel('Time Period') plt.ylabel('Stock Price') #plt.show() recent_data = np.array([x[len(x) - seq_length:]]) pre_price = int(price[-1][-1]) test_predict = sess.run(hypothesis, feed_dict={X: recent_data}) test_predict = reverse_min_max_scaling(price, test_predict) tom_price = int(test_predict) stock_percent = ( (test_predict[0] - price[-1][-1]) / price[-1][-1]) * 100 stock_percent = round(float(stock_percent), 3) #db에 예측결과들을 저장함 sql = 'REPLACE INTO stock_info (name, code, pre_price, tom_price, percent) VALUES (%s, %s, %s, %s, %s);' #insert쿼리 cursor.execute(sql, (stock_name, stock_code, pre_price, tom_price, stock_percent)) #쿼리실행 stock_db.commit() #db에 반영 stock_db.close()
# Imports from pandas_datareader import data as pdr from yahoo_fin import stock_info as si from pandas import ExcelWriter import yfinance as yf import pandas as pd import datetime import time yf.pdr_override() # Variables tickers = si.tickers_sp500() tickers = [item.replace(".", "-") for item in tickers] # Yahoo Finance uses dashes instead of dots index_name = '^GSPC' # S&P 500 start_date = datetime.datetime.now() - datetime.timedelta(days=365) end_date = datetime.date.today() exportList = pd.DataFrame(columns=[ 'Stock', "RS_Rating", "50 Day MA", "150 Day Ma", "200 Day MA", "52 Week Low", "52 week High" ]) returns_multiples = [] # Index Returns index_df = pdr.get_data_yahoo(index_name, start_date, end_date) index_df['Percent Change'] = index_df['Adj Close'].pct_change() index_return = (index_df['Percent Change'] + 1).cumprod()[-1] # Find top 30% performing stocks (relative to the S&P 500) for ticker in tickers:
def my_view(request, *args, **kwargs): yf.pdr_override() utc = pytz.utc utc_dt = dt.datetime.now() # eastern = pytz.timezone('US/Eastern') # loc_dt = utc_dt.astimezone(eastern) # fmt = '%Y-%m-%d %H:%M:%S %Z%z' # loc_dt.strftime(fmt) day = dt.timedelta(400) start = utc_dt - day url = 'https://en.wikipedia.org/wiki/List_of_S%26P_500_companies' # Create a handle, page, to handle the contents of the website page = requests.get(url) # Store the contents of the website under doc doc = lh.fromstring(page.content) # Parse data that are stored between <tr>..</tr> of HTML tr_elements = doc.xpath('//tr') # Create empty list col = [] i = 0 # For each row, store each first element (header) and an empty list for t in tr_elements[1]: i += 1 name = t.text_content() col.append((name, [])) for j in range(2, len(tr_elements)): # T is our j'th row T = tr_elements[j] # If row is not of size 10, the //tr data is not from our table if len(T) != 9: break # i is the index of our column i = 0 # Iterate through each element of the row for t in T.iterchildren(): data = t.text_content() # Check if row is empty if i > 0: # Convert any numerical value to integers try: data = int(data) except: pass # Append the data to the empty list of the i'th column col[i][1].append(data) # Increment i for the next column i += 1 [len(C) for (title, C) in col] Dict = {title: column for (title, column) in col} df = pd.DataFrame(Dict) col_one_list = df["Symbol\n"].tolist() splist = [] for element in col_one_list: splist.append(element.strip()) for i in range(len(splist)): if '.' in splist[i]: splist[i] = splist[i].replace(".", "-") count = 0 count1 = 0 for i in range(len(splist)): stock = splist[i] print(stock) print(start, utc_dt) df = pdr.get_data_yahoo(stock, start, utc_dt) isempty = df.empty if (isempty != True): df['200 dma'] = df['Adj Close'].rolling(200).mean().round(5) df['50 dma'] = df['Adj Close'].rolling(50).mean().round(5) df['over200'] = df['Adj Close'] > df[ '200 dma'] # Check if close > 200 day moving avg across all dates df['over50'] = df['Adj Close'] > df[ '50 dma'] # Check if close > 50 day moving avg across all dates if (df['over200'].iloc[-1] == True): count = count + 1 # check if the last 'over200' value is True. If so, increase count if (df['over50'].iloc[-1] == True): count1 = count1 + 1 # check if the last 'over50' value is True. If so, increase count print(count) print(len(splist)) print(count1) SPabove200 = round((float(count) / float(len(splist))) * 100, 1) print(count) print(float(count) / float(len(splist))) print(SPabove200) SPabove50 = round((float(count1) / float(len(splist))) * 100, 1) stock1 = '^GSPC' today = dt.datetime.now() yesterday = today - dt.timedelta(days=1) df = yf.download(stock1, period="1d", interval="1d") fdtest = df.tail(1) sp = fdtest.index[0] yesterday1 = sp.strftime("%m/%d/%Y") sp500_ret = round(fdtest['Adj Close'].iloc[-1], 2) #sheetlastdate = sheet200.cell(curentrow200 - 1, 1).value # yesterday1 = yesterday.strftime("%m/%d/%Y") row200 = [yesterday1, sp500_ret, SPabove200] row50 = [yesterday1, sp500_ret, SPabove50] date = pd.to_datetime(yesterday1, infer_datetime_format=True) #if (yesterday1 != sheetlastdate): #SpNasdaqDmaData.objects.create(date=yesterday1, sp500=sp500_ret, dma50=SPabove200) #SpNasdaqDmaData.objects.create(date = date, sp500 = sp500_ret, dma50 = SPabove50) #sp500 = 336 #dma50 = 54.02 # Iterate through all the data items #for i in range(len(date)): # Insert in the database #SpNasdaqDmaData.objects.create(date = date, sp500 = sp500, dma50 = dma50) # Getting all the stuff from database query_results = SpNasdaqDmaData.objects.all() # Creating a dictionary to pass as an argument context = {'query_results': query_results} print("Database Updated") # Returning the rendered html return render(request, "home.html", context)
#!/usr/bin/env python3 import os import pandas_datareader as pdr import yfinance as fix import dataMiner as D err_arrsy = [] fix.pdr_override() def loadfile(ticker_type, ticker, datapath, startdate, enddate): """ :param ticker_type: :param ticker: :param datapath: :param startdate: :param enddate: :return: """ err_arrsy = [] if ticker_type == 'en': print("Load data from Yahoo, ticker:", ticker) print("From %s date" % startdate) print("Till %s date" % enddate) try: __raw_data = pdr.get_data_yahoo(ticker, startdate, enddate) __write_to_file(ticker, __raw_data)
import yfinance as yf import pandas as pd from pandas_datareader import data from datetime import datetime yf.pdr_override() #以pandasreader常用的格式覆寫 target_stock = 'TLSA' #股票代號變數 start_date = datetime(2010, 1, 1) end_date = datetime(2020, 6, 30) #設定資料起訖日期 df = data.get_data_yahoo([target_stock], start_date, end_date) #將資料放到Dataframe裡面 filename = f'./data/{target_stock}.csv' #以股票名稱命名檔案,放在data資料夾下面 df.to_csv(filename) #將df轉成CSV保存
def loadPrice(tokens): import pandas_datareader.data as web import yfinance as yf yf.pdr_override() print('Carregando cotações') return web.get_data_yahoo(tokens)['Adj Close'].iloc[-1]
import requests import bs4 # Importing data management packages: import pandas as pd import pandas_datareader as pdr import yfinance as yf import datetime from datetime import timedelta import time import numpy as np # Importing data vizualization packages: import matplotlib.pyplot as plt import seaborn as sns sns.set() # Setting all charts to seaborn style yf.pdr_override() # overiding pdr with yfinance packages class Security(object): ''' The Security object contains descriptive variables for each Security instance as well as the methods to retrive said variables from the web. Data is collected via the pandas_datareader package augmented with the yfinance package to allow data to be pulled directly from yahoo finance. If the Security is an Exchange Traded fund then holdings data is pulled from etfdb.com Parameters ---------- ticker : str The string variable representing the ticker symbol for the Security. This string is the argument that is passed to all the data aggregation methods
def lstm(symbol, start_date, end_date): yf.pdr_override() df_X = data.DataReader(symbol, start=start_date, end=end_date, data_source='yahoo') df_y = df_X[:1500]['Close'] df_X.drop(df_X.columns[len(df_X.columns) - 1], axis=1, inplace=True) df_X['TradeDate'] = df_X.index #fig = df_X.plot(x='TradeDate', y='Close', kind='line', figsize=(20,6), rot=20) #st.pyplot(fig) # Extracting the closing prices of each day FullData = df_X[['Close']].values #print(FullData[0:5]) # Feature Scaling for fast training of neural networks from sklearn.preprocessing import StandardScaler, MinMaxScaler # Choosing between Standardization or normalization #sc = StandardScaler() sc = MinMaxScaler() DataScaler = sc.fit(FullData) X = DataScaler.transform(FullData) # split into samples X_samples = list() y_samples = list() NumerOfRows = len(X) TimeSteps = 10 # next day's Price Prediction is based on last how many past day's prices # Iterate thru the values to create combinations for i in range(TimeSteps, NumerOfRows, 1): x_sample = X[i - TimeSteps:i] y_sample = X[i] X_samples.append(x_sample) y_samples.append(y_sample) ################################################ # Reshape the Input as a 3D (number of samples, Time Steps, Features) X_data = np.array(X_samples) X_data = X_data.reshape(X_data.shape[0], X_data.shape[1], 1) #print('\n#### Input Data shape ####') #print(X_data.shape) # We do not reshape y as a 3D data as it is supposed to be a single column only y_data = np.array(y_samples) y_data = y_data.reshape(y_data.shape[0], 1) # Choosing the number of testing data records TestingRecords = 5 # Splitting the data into train and test X_train = X_data[:-TestingRecords] X_test = X_data[-TestingRecords:] y_train = y_data[:-TestingRecords] y_test = y_data[-TestingRecords:] # Defining Input shapes for LSTM TimeSteps = X_train.shape[1] TotalFeatures = X_train.shape[2] # Importing the Keras libraries and packages from keras.models import Sequential from keras.layers import Dense from keras.layers import LSTM # Initialising the RNN regressor = Sequential() # Adding the First input hidden layer and the LSTM layer # return_sequences = True, means the output of every time step to be shared with hidden next layer regressor.add( LSTM(units=10, activation='relu', input_shape=(TimeSteps, TotalFeatures), return_sequences=True)) # Adding the Second Second hidden layer and the LSTM layer regressor.add( LSTM(units=5, activation='relu', input_shape=(TimeSteps, TotalFeatures), return_sequences=True)) # Adding the Second Third hidden layer and the LSTM layer regressor.add(LSTM(units=5, activation='relu', return_sequences=False)) # Adding the output layer regressor.add(Dense(units=1)) # Compiling the RNN regressor.compile(optimizer='adam', loss='mean_squared_error') ################################################## import time # Measuring the time taken by the model to train StartTime = time.time() # Fitting the RNN to the Training set regressor.fit(X_train, y_train, batch_size=5, epochs=100) EndTime = time.time() st.write("## Total Time Taken: ", round((EndTime - StartTime) / 60), 'Minutes ##') # Making predictions on test data predicted_Price = regressor.predict(X_test) predicted_Price = DataScaler.inverse_transform(predicted_Price) # Getting the original price values for testing data orig = y_test orig = DataScaler.inverse_transform(y_test) # Accuracy of the predictions st.write('Accuracy:', 100 - (100 * (abs(orig - predicted_Price) / orig)).mean()) # Visualising the results import matplotlib.pyplot as plt plt.plot(predicted_Price, color='blue', label='Predicted Volume') plt.plot(orig, color='lightblue', label='Original Volume') plt.title('Stock Price Predictions') plt.xlabel('Trading Date') plt.xticks(range(TestingRecords), df_X.tail(TestingRecords)['TradeDate']) plt.ylabel('Stock Price') plt.legend() fig1 = plt.gcf() fig1.set_figwidth(20) fig1.set_figheight(6) st.pyplot(fig1) #fig1.savefig("predit5.png") #from PIL import Image #image = Image.open('predit5.png') #st.image(image, caption='Predition on Testing Set') # Generating predictions on full data TrainPredictions = DataScaler.inverse_transform(regressor.predict(X_train)) TestPredictions = DataScaler.inverse_transform(regressor.predict(X_test)) FullDataPredictions = np.append(TrainPredictions, TestPredictions) FullDataOrig = FullData[TimeSteps:] # plotting the full data plt.plot(FullDataPredictions, color='blue', label='Predicted Price') plt.plot(FullDataOrig, color='lightblue', label='Original Price') plt.title('Stock Price Predictions') plt.xlabel('Trading Date') plt.ylabel('Stock Price') plt.legend() fig = plt.gcf() fig.set_figwidth(20) fig.set_figheight(8) st.pyplot(fig) #plt.show() #fig.savefig("preditfull.png") #from PIL import Image #image = Image.open('preditfull.png') #st.image(image, caption='Predition for the whole period') # Last 10 days prices Last10Days = df_X['Close'].tail(10).to_numpy() # Normalizing the data just like we did for training the model Last10Days = DataScaler.transform(Last10Days.reshape(-1, 1)) # Changing the shape of the data to 3D # Choosing TimeSteps as 10 because we have used the same for training NumSamples = 1 TimeSteps = 10 NumFeatures = 1 Last10Days = Last10Days.reshape(NumSamples, TimeSteps, NumFeatures) ############################# # Making predictions on data import sys predicted_Price = regressor.predict(Last10Days) predicted_Price = DataScaler.inverse_transform(predicted_Price) #final_predit = np.savetxt(sys.stdout, predicted_Price, fmt="%.3f") final_predit = "".join(str(x) for x in predicted_Price) st.write("The next day price prediction for our LSTM Model is: ", final_predit)
def get(self, request): messages.success(request, 'Please wait') yf.pdr_override() sp_500 = pd.read_html( 'https://en.wikipedia.org/wiki/List_of_S%26P_500_companies' )[0].filter(['Symbol', 'Security'], axis=1) active_df = pd.read_html('https://finance.yahoo.com/most-active')[0] active_tickers = active_df['Symbol'].to_list() active_df = active_df.set_index('Symbol') active_stats = active_df.to_dict() stock_stats = {} stock_screen = {} for row in sp_500.itertuples(): stock_stats[row[1]] = {} # active_tickers = active_tickers[0:5] start = dt.datetime.now() - dt.timedelta(days=20) now = dt.datetime.now() for sym in active_tickers: try: print(f"Analysis for {sym}") # time.sleep(5) stock_screen[sym] = {} stock_screen[sym]['Name'] = active_stats['Name'][sym] stock_screen[sym]['Ticker'] = sym stock_screen[sym]['% Change'] = round( float(active_stats['% Change'][sym].replace( '%', '').replace('+', '')), 2) stock_screen[sym]['Price (Intraday)'] = round( float(active_stats['Price (Intraday)'][sym]), 2) stock_screen[sym]['Market Cap'] = active_stats['Market Cap'][ sym] if sym in stock_stats.keys(): stock_screen[sym]['SP500'] = 'YES' else: stock_screen[sym]['SP500'] = 'NO' stock_screen[sym]['TREND'], stock_screen[sym][ 'VOL_TREND'], stock_screen[sym][ 'price_per_change'], stock_screen[sym][ 'vol_per_change'] = get_trend(sym, start, now) urls = [ 'https://sg.finance.yahoo.com/quote/{0}/key-statistics?p={0}', 'https://finance.yahoo.com/quote/{0}?p={0}' ] for url in urls: stock_url = url.format(sym) df_list = pd.read_html(stock_url) for df in df_list: for item in df.to_dict('records'): stock_screen[sym][item[0]] = item[1] stock_screen[sym]['Volume'] = int(stock_screen[sym]['Volume']) stock_screen[sym]['%50MVA'] = get_per_value( stock_screen[sym]['Price (Intraday)'], stock_screen[sym]['50-day moving average 3']) stock_screen[sym]['%200MVA'] = get_per_value( stock_screen[sym]['Price (Intraday)'], stock_screen[sym]['200-day moving average 3']) stock_screen[sym]['%52LOW'] = get_per_value( stock_screen[sym]['Price (Intraday)'], stock_screen[sym]['52-week low 3']) stock_screen[sym]['%52HIGH'] = get_per_value( stock_screen[sym]['Price (Intraday)'], stock_screen[sym]['52-week high 3']) except: print(f"exception for {sym}") print( f"{sys.exc_info()[0]},{sys.exc_info()[1]},{traceback.format_tb(sys.exc_info()[2])} " ) del stock_screen[sym] continue return render( request, 'stocks/active.html', dump_to_db(StockTicker, stock_screen, "stocks_stockticker"))
import datetime import pandas as pd from pandas import DataFrame import numpy as np import math import matplotlib.pyplot as plt # Biblioteca para gerar os gráficos - https://matplotlib.org/ ################################### # TRACKER ################################### #Definir data de inicio e fim start_sp = datetime.datetime(2000, 7, 12) end_sp = datetime.datetime(2019, 7, 12) yf.pdr_override() # arredondando dados para duas casas decimais # Definindo ativo para gerar base de dados sp500 = pdr.get_data_yahoo('SPY', start_sp, end_sp) df = DataFrame(sp500) # Definindo DataFrame ######################################### # Calculate Relative Strength Index(RSI) # ######################################### n = 9 prices = df.iloc[:, 3] deltas = np.diff(prices.T) seed = deltas[:n + 1]
import yfinance as yf yf.pdr_override() # Fix for yahoo finance def deadCat_search(stock): rating = 1 status = False up_percentage = 20 down_percentage = -5 ticker = yf.Ticker(stock) hist = ticker.history(period='7d', interval='1d') hist['Percent Change'] = hist['Close'].pct_change() # stock_return = hist['Percent Change'].sum() * 100 # try: # if ( (hist['Percent Change'][-3] > up_percentage or hist['Percent Change'][-2] > up_percentage) and # (hist['Percent Change'][-2] < down_percentage or hist['Percent Change'][-1] < down_percentage)): # status = True # except Exception as e: # print(e) # print("deadCat_search - No data on " + stock) return stock, status, 'Dead Cat', rating
def plot(): from pandas_datareader import data import yfinance as yf import datetime as dt from bokeh.plotting import figure, show, output_file from bokeh.embed import components from bokeh.resources import CDN, INLINE yf.pdr_override() start = dt.datetime(2019, 11, 2) end = dt.datetime(2020, 8, 11) hours_12 = 12 * 60 * 60 * 1000 df = data.get_data_yahoo(tickers="TSLA", start=start, end=end) def status(open, close): if open < close: value = "Profit" elif open > close: value = "Loss" else: value = "Equal" return value df['Status'] = [ status(open, close) for open, close in zip(df.Open, df.Close) ] df['Middle_y'] = (df.Open + df.Close) / 2 df['Height'] = abs(df.Close - df.Open) #df p = figure(x_axis_type='datetime', width=1000, height=400, title="CandleStick Chart", sizing_mode="scale_width") p.grid.grid_line_alpha = 0.3 p.segment(df.index, df.High, df.index, df.Low, color="black") p.rect(x=df.index[df.Status == "Profit"], y=df.Middle_y[df.Status == 'Profit'], width=hours_12, height=df.Height[df.Status == "Profit"], fill_color="#99FF99", line_color="white") p.rect(x=df.index[df.Status == "Loss"], y=df.Middle_y[df.Status == 'Loss'], width=hours_12, height=df.Height[df.Status == "Loss"], fill_color="#CC0000", line_color="white") # output_file("cs.html") #show(p) script1, div1 = components(p) cdn_js = CDN.js_files cdn_css = CDN.css_files return render_template("plot.html", script1=script1, div1=div1, cdn_js=cdn_js[0], cdn_css=cdn_css)
def yf(ticker: str, **kwargs): """yf - yfinance wrapper It retrieves market data (ohlcv) from Yahoo Finance using yfinance. To install yfinance. (pip install yfinance) This method can also pull additional data using the 'kind' kwarg. By default kind=None and retrieves Historical Chart Data. Other options of 'kind' include: * All: "all" - Prints everything below but only returns Chart History to Pandas TA * Company Information: "info" * Institutional Holders: "institutional_holders" or "ih" * Major Holders: "major_holders" or "mh" * Mutual Fund Holders: "mutualfund_holders" or "mfh" * Recommendations (YTD): "recommendations" or "rec" * Earnings Calendar: "calendar" or "cal" * Earnings: "earnings" or "earn" * Sustainability/ESG Scores: "sustainability", "sus" or "esg" * Financials: "financials" or "fin" - Returns in order: Income Statement, Balance Sheet and Cash Flow * Option Chain: "option_chain" or "oc" - Uses the nearest expiration date by default - Change the expiration date using kwarg "exp" - Show ITM options, set kwarg "itm" to True. Or OTM options, set kwarg "itm" to False. * Chart History: - The only data returned to Pandas TA. Args: ticker (str): Any string for a ticker you would use with yfinance. Default: "SPY" Kwargs: calls (bool): When True, prints only Option Calls for the Option Chain. Default: None desc (bool): Will print Company Description when printing Company Information. Default: False exp (str): Used to print other Option Chains for the given Expiration Date. Default: Nearest Expiration Date for the Option Chains interval (str): A yfinance argument. Default: "1d" itm (bool): When printing Option Chains, shows ITM Options when True. When False, it shows OTM Options: Default: None kind (str): Options see above. Default: None period (str): A yfinance argument. Default: "max" proxy (dict): Proxy for yfinance to use. Default: {} puts (bool): When True, prints only Option Puts for the Option Chain. Default: None show (int > 0): How many last rows of Chart History to show. Default: None snd (int): How many recent Splits and Dividends to show in Company Information. Default: 5 verbose (bool): Prints Company Information "info" and a Chart History header to the screen. Default: False Returns: Exits if the DataFrame is empty or None Otherwise it returns a DataFrame of the Chart History """ verbose = kwargs.pop("verbose", False) if ticker is not None and isinstance(ticker, str) and len(ticker): ticker = ticker.upper() else: ticker = "SPY" kind = kwargs.pop("kind", None) if kind is not None and isinstance(kind, str) and len(kind): kind = kind.lower() period = kwargs.pop("period", "max") interval = kwargs.pop("interval", "1d") proxy = kwargs.pop("proxy", {}) show = kwargs.pop("show", None) if not Imports["yfinance"]: print( f"[X] Please install yfinance to use this method. (pip install yfinance)" ) return if Imports["yfinance"] and ticker is not None: import yfinance as yfra yfra.pdr_override() # Ticker Info & Chart History yfd = yfra.Ticker(ticker) df = yfd.history(period=period, interval=interval, proxy=proxy, **kwargs) print(f"[X] df[{type(df)}:{df.empty}]\n{df}\n") if df.empty: return df.name = ticker try: ticker_info = yfd.info except KeyError as ke: print(f"[X] Ticker '{ticker}' not found.") return print( f"[X] ticker_info[{type(ticker_info)}:{len(ticker_info.keys())}]\n{ticker_info}\n" ) try: infodf = DataFrame.from_dict(ticker_info, orient="index") except TypeError as te: print(f"[X] TypeError: {te}") # else: # infodf = DataFrame(ticker_info) print(f"[X] infodf.empty: {infodf.empty}") if infodf.empty: return print(f"[X] infodf[{type(infodf)}:{len(infodf.keys())}]\n{infodf}\n") infodf.name, infodf.columns = ticker, [ticker] # Dividends and Splits dividends, splits = yfd.splits, yfd.dividends _all, div = ["all"], "=" * 53 # Max div width is 80 if kind in _all + ["info"] or verbose: description = kwargs.pop("desc", False) snd_length = kwargs.pop("snd", 5) [print(f"{_[0]}: {_[1]}") for _ in sorted(ticker_info.items())] print() print("\n==== Company Information " + div) print( f"{ticker_info['longName']} ({ticker_info['shortName']}) [{ticker_info['symbol']}]" ) print( f"[i] {type(ticker_info['longBusinessSummary'])}: {ticker_info['longBusinessSummary']}" ) if description: print(f"{ticker_info['longBusinessSummary']}\n") if "address1" in ticker_info and len(ticker_info["address1"]): if "address2" in ticker_info and len(ticker_info["address2"]): print( f"{ticker_info['address1']} {ticker_info['address2']}") else: print(f"{ticker_info['address1']}") if "city" in ticker_info and len(ticker_info["city"]) and "state" in ticker_info and len(ticker_info["state"]) \ and "zip" in ticker_info and len(ticker_info["zip"]) and "country" in ticker_info and len(ticker_info["country"]): print( f"{ticker_info['city']}, {ticker_info['state']} {ticker_info['zip']}, {ticker_info['country']}" ) else: print( f"{ticker_info['state']} {ticker_info['zip']}, {ticker_info['country']}" ) print( f"Phone (Fax): {ticker_info['phone']} ({ticker_info['fax'] if 'fax' in ticker_info else 'N/A'})" ) if "website" in ticker_info and len(ticker_info['website']): s = f"Website: {ticker_info['website']}".ljust(40) if "fullTimeEmployees" in ticker_info: s += f"FT Employees: {ticker_info['fullTimeEmployees']:,}".rjust( 40) print(s) elif "fullTimeEmployees" in ticker_info: print(f"FT Employees: {ticker_info['fullTimeEmployees']:,}") if "companyOfficers" in ticker_info and len( ticker_info['companyOfficers']): print( f"Company Officers: {', '.join(ticker_info['companyOfficers'])}" .ljust(40)) if "sector" in ticker_info and len( ticker_info["sector"] ) and "industry" in ticker_info and len(ticker_info["industry"]): # print(f"Sector: {ticker_info['sector']}".ljust(39), f"Industry: {ticker_info['industry']}".rjust(40)) print( f"Sector | Industry".ljust(29), f"{ticker_info['sector']} | {ticker_info['industry']}". rjust(50)) print("\n==== Market Information " + div) _category = f" | {ticker_info['category']}" if "category" in ticker_info and ticker_info[ "category"] is not None else "" print( f"Market | Exchange | Symbol{' | Category' if 'category' in ticker_info and ticker_info['category'] is not None else ''}" .ljust(39), f"{ticker_info['market'].split('_')[0].upper()} | {ticker_info['exchange']} | {ticker_info['symbol']}{_category}" .rjust(40)) print() if "marketCap" in ticker_info and ticker_info[ "marketCap"] is not None: print( f"Market Cap.".ljust(39), f"{ticker_info['marketCap']:,} ({ticker_info['marketCap']/1000000:,.2f} MM)" .rjust(40)) if "navPrice" in ticker_info and ticker_info[ "navPrice"] is not None or "yield" in ticker_info and ticker_info[ "yield"] is not None: print( f"NAV | Yield".ljust(39), f"{ticker_info['navPrice']} | {100 * ticker_info['yield']:.4f}%" .rjust(40)) if "sharesOutstanding" in ticker_info and ticker_info[ "sharesOutstanding"] is not None and "floatShares" in ticker_info and ticker_info[ "floatShares"] is not None: print( f"Shares Outstanding | Float".ljust(39), f"{ticker_info['sharesOutstanding']:,} | {ticker_info['floatShares']:,}" .rjust(40)) if "impliedSharesOutstanding" in ticker_info and ticker_info[ "impliedSharesOutstanding"] is not None: print(f"Implied Shares Outstanding".ljust(39), f"{ticker_info['impliedSharesOutstanding']:,}".rjust(40)) if "sharesShort" in ticker_info and "shortRatio" in ticker_info and ticker_info[ "sharesShort"] is not None and ticker_info[ "shortRatio"] is not None: print( f"Shares Short | Ratio".ljust(39), f"{ticker_info['sharesShort']:,} | {ticker_info['shortRatio']:,}" .rjust(40)) if "shortPercentOfFloat" in ticker_info and ticker_info[ 'shortPercentOfFloat'] is not None and "sharesShortPriorMonth" in ticker_info and ticker_info[ 'sharesShortPriorMonth'] is not None: print( f"Short % of Float | Short prior Month".ljust(39), f"{100 * ticker_info['shortPercentOfFloat']:.4f}% | {ticker_info['sharesShortPriorMonth']:,}" .rjust(40)) if "heldPercentInstitutions" in ticker_info and ticker_info[ 'heldPercentInstitutions'] is not None or "heldPercentInsiders" in ticker_info and ticker_info[ 'heldPercentInsiders'] is not None: print( f"Insiders % | Institution %".ljust(39), f"{100 * ticker_info['heldPercentInsiders']:.4f}% | {100 * ticker_info['heldPercentInstitutions']:.4f}" .rjust(40)) print() if "bookValue" in ticker_info and ticker_info[ 'bookValue'] is not None or "priceToBook" in ticker_info and ticker_info[ 'priceToBook'] is not None or "pegRatio" in ticker_info and ticker_info[ 'pegRatio'] is not None: print( f"Book Value | Price to Book | Peg Ratio".ljust(39), f"{ticker_info['priceToBook']} | {ticker_info['priceToBook']} | {ticker_info['pegRatio']}" .rjust(40)) if "forwardPE" in ticker_info and ticker_info[ 'forwardPE'] is not None: print(f"Forward PE".ljust(39), f"{ticker_info['forwardPE']}".rjust(40)) if "forwardEps" in ticker_info and ticker_info[ 'forwardEps'] is not None or "trailingEps" in ticker_info and ticker_info[ 'trailingEps'] is not None: print( f"Forward EPS | Trailing EPS".ljust(39), f"{ticker_info['forwardEps']} | {ticker_info['trailingEps']}" .rjust(40)) if "enterpriseValue" in ticker_info and ticker_info[ 'enterpriseValue'] is not None: print(f"Enterprise Value".ljust(39), f"{ticker_info['enterpriseValue']:,}".rjust(40)) if "enterpriseToRevenue" in ticker_info and ticker_info[ 'enterpriseToRevenue'] is not None or "enterpriseToEbitda" in ticker_info and ticker_info[ 'enterpriseToEbitda'] is not None: print( f"Enterprise to Revenue | to EBITDA".ljust(39), f"{ticker_info['enterpriseToRevenue']} | {ticker_info['enterpriseToEbitda']}" .rjust(40)) print() if "netIncomeToCommon" in ticker_info and ticker_info[ 'netIncomeToCommon'] is not None: print(f"Net Income to Common".ljust(39), f"{ticker_info['netIncomeToCommon']:,}".rjust(40)) if "revenueQuarterlyGrowth" in ticker_info and ticker_info[ 'revenueQuarterlyGrowth'] is not None: print(f"Revenue Quarterly Growth".ljust(39), f"{ticker_info['revenueQuarterlyGrowth']}".rjust(40)) if "profitMargins" in ticker_info and ticker_info[ 'profitMargins'] is not None: print(f"Profit Margins".ljust(39), f"{100 * ticker_info['profitMargins']:.4f}%".rjust(40)) if "earningsQuarterlyGrowth" in ticker_info and ticker_info[ 'earningsQuarterlyGrowth'] is not None: print(f"Quarterly Earnings Growth".ljust(39), f"{ticker_info['earningsQuarterlyGrowth']}".rjust(40)) if "annualReportExpenseRatio" in ticker_info and ticker_info[ 'annualReportExpenseRatio'] is not None: print(f"Annual Expense Ratio".ljust(39), f"{ticker_info['annualReportExpenseRatio']}".rjust(40)) print("\n==== Price Information " + div) _o, _h, _l, _c, _v = ticker_info['open'], ticker_info[ 'dayHigh'], ticker_info['dayLow'], ticker_info[ 'regularMarketPrice'], ticker_info['regularMarketVolume'] print(f"Open High Low Close".ljust(39), f"{_o:.4f}, {_o:.4f}, {_l:.4f}, {_c:.4f}".rjust(40)) print( f"HL2 | HLC3 | OHLC4 | C - OHLC4".ljust(39), f"{0.5 * (_h + _l):.4f}, {(_h + _l + _c) / 3.:.4f}, {0.25 * (_o + _h + _l + _c):.4f}, {_c - 0.25 * (_o + _h + _l + _c):.4f}" .rjust(40)) print( f"Change (%)".ljust(39), f"{_c - ticker_info['previousClose']:.4f} ({100 * ((_c / ticker_info['previousClose']) - 1):.4f}%)" .rjust(40)) print( f"Volume | Avg Vol (10Day)".ljust(39), f"{ticker_info['volume']:,} | {ticker_info['averageVolume']:,} ({ticker_info['averageDailyVolume10Day']:,})" .rjust(40)) print( f"Bid | Ask | Spread".ljust(39), f"{ticker_info['bid']} x {ticker_info['bidSize']} | {ticker_info['ask']} x {ticker_info['askSize']} | {ticker_info['ask'] - ticker_info['bid']:.4f}" .rjust(40)) print() if "52WeekChange" in ticker_info and ticker_info[ '52WeekChange'] is not None: print(f"52Wk % Change".ljust(39), f"{100 * ticker_info['52WeekChange']:.4f}%".rjust(40)) if "SandP52WeekChange" in ticker_info and ticker_info[ 'SandP52WeekChange'] is not None: print( f"52Wk % Change vs S&P500".ljust(39), f"{100 *ticker_info['SandP52WeekChange']:.4f}%".rjust(40)) if "fiftyTwoWeekHigh" in ticker_info and "fiftyTwoWeekLow" in ticker_info and "previousClose" in ticker_info: # or 'regularMarketPrice' print( f"52Wk Range (% from 52Wk Low)".ljust(39), f"{ticker_info['fiftyTwoWeekLow']} - {ticker_info['fiftyTwoWeekHigh']} : {ticker_info['fiftyTwoWeekHigh'] - ticker_info['fiftyTwoWeekLow']:.4f} ({100 * (ticker_info['regularMarketPrice'] / ticker_info['fiftyTwoWeekLow'] - 1):.4f}%)" .rjust(40)) avg50 = "fiftyDayAverage" in ticker_info and ticker_info[ 'fiftyDayAverage'] is not None avg200 = "twoHundredDayAverage" in ticker_info and ticker_info[ 'twoHundredDayAverage'] is not None if avg50 and avg200: print( f"SMA 50 | SMA 200".ljust(39), f"{ticker_info['fiftyDayAverage']:.4f} | {ticker_info['twoHundredDayAverage']:.4f}" .rjust(40)) elif avg50: print(f"SMA 50".ljust(39), f"{ticker_info['fiftyDayAverage']:.4f}".rjust(40)) elif avg200: print(f"SMA 200".ljust(39), f"{ticker_info['twoHundredDayAverage']:.4f}".rjust(40)) if "beta" in ticker_info and ticker_info['beta'] is not None: print( f"Beta | 3Yr".ljust(39), f"{ticker_info['beta']} | {ticker_info['beta3Year']}". rjust(40)) if "threeYearAverageReturn" in ticker_info and ticker_info[ 'threeYearAverageReturn'] is not None or "fiveYearAverageReturn" in ticker_info and ticker_info[ 'fiveYearAverageReturn'] is not None: print( f"Avg. Return 3Yr | 5Yr".ljust(39), f"{100 * ticker_info['threeYearAverageReturn']:.4f}% | {100 * ticker_info['fiveYearAverageReturn']:.4f}%" .rjust(40)) # Dividends and Splits if not dividends.empty or not splits.empty: print("\n==== Dividends / Splits " + div) if "dividendRate" in ticker_info and ticker_info[ 'dividendRate'] is not None and "dividendYield" in ticker_info and ticker_info[ 'dividendYield'] is not None and "payoutRatio" in ticker_info and ticker_info[ 'payoutRatio'] is not None: print( f"Rate | Yield | Payout Ratio".ljust(39), f"{ticker_info['dividendRate']} | {100 * ticker_info['dividendYield']:.4f}% | {ticker_info['payoutRatio']}" .rjust(40)) if "trailingAnnualDividendRate" in ticker_info and ticker_info[ 'trailingAnnualDividendRate'] is not None and "trailingAnnualDividendYield" in ticker_info and ticker_info[ 'trailingAnnualDividendYield'] is not None: print( f"Trailing Annual Dividend Rate | Yield".ljust(40), f"{ticker_info['trailingAnnualDividendRate']} | {100 * ticker_info['trailingAnnualDividendYield']:.4f}%\n" .rjust(40)) if not dividends.empty: dividends.name = "Value" total_dividends = dividends.size dividendsdf = DataFrame(dividends.tail(snd_length)[::-1]).T print( f"Dividends (Last {snd_length} of {total_dividends}):\n{dividendsdf}" ) if not splits.empty: splits.name = "Ratio" total_splits = splits.size splitsdf = DataFrame(splits.tail(snd_length)[::-1]).T print( f"\nStock Splits (Last {snd_length} of {total_splits}):\n{splitsdf}" ) if kind in _all + ["institutional_holders", "ih"]: ihdf = yfd.institutional_holders if ihdf is not None and "Date Reported" in ihdf.columns: ihdf.set_index("Date Reported", inplace=True) ihdf["Shares"] = ihdf.apply(lambda x: f"{x['Shares']:,}", axis=1) ihdf["Value"] = ihdf.apply(lambda x: f"{x['Value']:,}", axis=1) if kind not in _all: print(f"\n{ticker_info['symbol']}") print("\n==== Instl. Holders " + div + f"\n{ihdf}") if kind in _all + ["major_holders", "mh"]: mhdf = yfd.major_holders if mhdf is not None and "Major Holders" in mhdf.columns: mhdf.columns = ["Percentage", "Major Holders"] mhdf.set_index("Major Holders", inplace=True) mhdf["Shares"] = mhdf.apply(lambda x: f"{x['Shares']:,}", axis=1) mhdf["Value"] = mhdf.apply(lambda x: f"{x['Value']:,}", axis=1) if kind not in _all: print(f"\n{ticker_info['symbol']}") print("\n==== Major Holders " + div + f"\n{mhdf}") if kind in _all + ["mutualfund_holders", "mfh"]: mfhdf = yfd.get_mutualfund_holders() if mfhdf is not None and "Holder" in mfhdf.columns: mfhdf.set_index("Date Reported", inplace=True) mfhdf["Shares"] = mfhdf.apply(lambda x: f"{x['Shares']:,}", axis=1) mfhdf["Value"] = mfhdf.apply(lambda x: f"{x['Value']:,}", axis=1) if kind not in _all: print(f"\n{ticker_info['symbol']}") print("\n==== Mutual Fund Holders " + div + f"\n{mfhdf}") if kind in _all + ["recommendations", "rec"]: recdf = yfd.recommendations if recdf is not None: recdf = ytd_df(recdf) # recdf_grade = recdf["To Grade"].value_counts().T # recdf_grade.name = "Grades" if kind not in _all: print(f"\n{ticker_info['symbol']}") print("\n==== Recommendation(YTD) " + div + f"\n{recdf}") if kind in _all + ["calendar", "cal"]: caldf = yfd.calendar if caldf is not None and "Earnings Date" in caldf.columns: caldf.set_index("Earnings Date", inplace=True) if kind not in _all: print(f"\n{ticker_info['symbol']}") print("\n==== Earnings Calendar " + div + f"\n{caldf}") if kind in _all + ["earnings", "earn"]: earndf = yfd.earnings if not earndf.empty: earndf["Revenue"] = earndf.apply(lambda x: f"{x['Revenue']:,}", axis=1) earndf["Earnings"] = earndf.apply( lambda x: f"{x['Earnings']:,}", axis=1) if kind not in _all: print(f"\n{ticker_info['symbol']}") print("\n==== Earnings " + div + f"\n{earndf}") if kind in _all + ["sustainability", "sus", "esg"]: susdf = yfd.sustainability if susdf is not None: susdf.replace({None: False}, inplace=True) susdf.columns = ["Score"] susdf.drop(susdf[susdf["Score"] == False].index, inplace=True) susdf.rename(index=_camelCase2Title, errors="ignore", inplace=True) susdf.index.name = "Source" if kind not in _all: print(f"\n{ticker_info['symbol']}") print("\n==== Sustainability/ESG " + div + f"\n{susdf}") if kind in _all + ["financials", "fin"]: icdf = yfd.financials bsdf = yfd.balance_sheet cfdf = yfd.cashflow if icdf.empty or bsdf.empty or cfdf.empty: if yfra.__version__ <= "0.1.54": print( f"[!] Best choice: update yfinance to the latest version." ) print( f"[!] Ignore if aleady patched. Some tickers do not have financials." ) print( f"[!] Otherwise to enable Company Financials, see yfinance Issue #517 patch." ) print( f"[!] https://github.com/ranaroussi/yfinance/pull/517/files" ) else: print("\n==== Company Financials " + div) if not icdf.empty: print(f"Income Statement:\n{icdf}\n") if not bsdf.empty: print(f"Balance Sheet:\n{bsdf}\n") if not cfdf.empty: print(f"Cash Flow:\n{cfdf}\n") if kind in _all + ["option_chain", "oc"]: try: yfd_options = yfd.options except IndexError as ie: yfd_options = None if yfd_options is not None: opt_expirations = list(yfd_options) just_calls = kwargs.pop("calls", None) just_puts = kwargs.pop("puts", None) itm = kwargs.pop("itm", None) opt_date = kwargs.pop("exp", opt_expirations[0]) opt_expirations_str = f"{ticker} Option Expirations:\n\t{', '.join(opt_expirations)}\n" if kind not in _all: print(f"\n{ticker_info['symbol']}") if isinstance(itm, bool) and itm: print("\n==== ITM Option Chains " + div) elif isinstance(itm, bool) and not itm: print("\n==== OTM Option Chains " + div) else: print("\n==== Option Chains " + div) print(opt_expirations_str) if opt_date not in opt_expirations: print( f"[X] No Options for {ticker_info['quoteType']} {ticker_info['symbol']}" ) else: option_columns = [ "Contract", "Last Trade", "Strike", "Price", "Bid", "Ask", "Change", "Percent Change", "Volume", "OI", "IV", "ITM", "Size", "Currency" ] cp_chain = yfd.option_chain(proxy=proxy) calls, puts = cp_chain.calls, cp_chain.puts calls.columns = puts.columns = option_columns calls.set_index("Contract", inplace=True) puts.set_index("Contract", inplace=True) calls.name = f"{ticker} Calls for {opt_date}" puts.name = f"{ticker} Puts for {opt_date}" if isinstance(itm, bool): in_or_out = "ITM" if itm else "OTM" calls.name, puts.name = f"{calls.name} {in_or_out}", f"{puts.name} {in_or_out}" itm_calls = f"{calls.name}\n{calls[calls['ITM'] == itm]}" itm_puts = f"{puts.name}\n{puts[puts['ITM'] == itm]}" if just_calls: print(itm_calls) elif just_puts: print(itm_puts) else: print(f"{itm_calls}\n\n{itm_puts}") else: all_calls, all_puts = f"{calls.name}\n{calls}", f"{puts.name}\n{puts}" if just_calls: print(all_calls) elif just_puts: print(all_puts) else: print(f"{all_calls}\n\n{all_puts}") if verbose: print("\n==== Chart History " + div + f"\n[*] Pandas TA v{version} & yfinance v{yfra.__version__}") print( f"[+] Downloading {ticker}[{interval}:{period}] from Yahoo Finance" ) if show is not None and isinstance(show, int) and show > 0: print(f"\n{df.name}\n{df.tail(show)}\n") if verbose: print("=" * 80 + "\n") else: print() return df else: return DataFrame()
import yfinance as fyf from pandas_datareader import data as pdr fyf.pdr_override() apple = pdr.get_data_yahoo("AAPL", start='2017-01-01') stock_apple = apple['Close'] stock_apple.head()
def stock_screener( index_tinker_name='S&P500', min_vol=5e6, min_price=0, days=365, min_rs_rating=70, ): # help(si) ## fix for yahoo_fin start_date, end_date = period(days) yf.pdr_override() index_tinker = {'DOW': 'DOW', 'NASDAQ': '^IXIC', "S&P500": '^GSPC'} index_list = { 'DOW': si.tickers_sp500(), 'NASDAQ': si.tickers_nasdaq(), "S&P500": si.tickers_sp500() } st.header(f'Stock Screener {index_tinker_name}') # stocklist = si.tickers_sp500() min_volume = min_vol # index_name = '^GSPC' # SPY or S&P 500 stocklist = index_list.get(index_tinker_name)[:] index_rs_strange_value = calc_relative_strength( get_stock(index_tinker[index_tinker_name], days)) final = [] index = [] exclude_list = [] all_data = [] latest_iteration = st.empty() having_break = st.empty() bar = st.progress(0) total = len(stocklist) for num, stock_name in enumerate(stocklist): print(f"checking {num}:{stock_name}") if stock_name in exclude_list: continue FAILED = False df = get_stock(stock_name) # print('**',df) if df is False: print(f'SKIPPED to download {stock_name} {num}') continue stock_meta = Moving_avg(stock_name, df, index_rs_strange_value, min_rs_rating) time.sleep(0.2) if stock_meta.all_conditions(): print(f'Passed conditions: {stock_name}') final.append(stock_meta.as_dict()) else: print(f'Failed conditions: {stock_name}') # all_data.append(stock_meta.as_dict()) latest_iteration.text(f'Stocks Processed: {(num+1)}/{total}') bar.progress((num + 1) / total) if num == 0: continue if num % 10 == 0: for i in list(range(5))[::-1]: having_break.text(f'waiting for {i}sec') time.sleep(1) # having_break = st.empty() if num % 100 == 0: for i in list(range(3))[::-1]: having_break.text(f'waiting for {i}min') time.sleep(60) # having_break = st.empty() # time.sleep(5*60) final_df = pd.DataFrame(final) # all_data_df = pd.DataFrame(all_data) return final_df
def getData(startDate, endDate, cur): yf.pdr_override() data = pdr.get_data_yahoo(cur, startDate, endDate) curv = pd.DataFrame(data) return curv
def calculate_protfolio(list_of_ticks, img_name, type): #Select stocks, start year and end year, stock number has no known limit ## Insert Parmater start_year = '2009-1-1' end_year = '2021-04-01' Num_porSimulation = 100000 # Number of Portfolio that will build for simulator ## End Insert Parameter #Select stocks, start year and end year, stock number has no known limit #Building the DataBase yf.pdr_override() frame = {} for stock in list_of_ticks: data_var = pdr.get_data_yahoo(stock, start_year, end_year)['Adj Close'] data_var.to_frame() frame.update({stock: data_var}) # End Insert Adj Close To DataBase import pandas as pd #Mathematical calculations Return Daily And annualy, creation of Number portfolios, table = pd.DataFrame(frame) returns_daily = table.pct_change() returns_annual = ((1 + returns_daily.mean())**250) - 1 # get daily and covariance of returns of the stock cov_daily = returns_daily.cov() cov_annual = cov_daily * 250 # empty lists to store returns, volatility and weights of imiginary portfolios port_returns = [] port_volatility = [] sharpe_ratio = [] stock_weights = [] # set the number of combinations for imaginary portfolios num_assets = len(list_of_ticks) num_portfolios = Num_porSimulation # Change porfolio numbers here #set random seed for reproduction's sake np.random.seed(101) # populate the empty lists with each portfolios returns,risk and weights for single_portfolio in range(num_portfolios): weights = np.random.random(num_assets) weights /= np.sum(weights) returns = np.dot(weights, returns_annual) # calculation the Standard Deviation of portfolio. volatility = np.sqrt(np.dot(weights.T, np.dot(cov_annual, weights))) # calculation the sharpe of portfolio. sharpe = returns / volatility sharpe_ratio.append(sharpe) # Percent Conversion port_returns.append(returns * 100) port_volatility.append(volatility * 100) stock_weights.append(weights) # a dictionary for Returns and Risk values of each portfolio portfolio = { 'Returns': port_returns, 'Volatility': port_volatility, 'Sharpe Ratio': sharpe_ratio } # extend original dictionary to accomodate each ticker and weight in the portfolio for counter, symbol in enumerate(list_of_ticks): portfolio[symbol + ' Weight'] = [Weight[counter] for Weight in stock_weights] # make a nice dataframe of the extended dictionary df = pd.DataFrame(portfolio) # get better labels for desired arrangement of columns column_order = ['Returns', 'Volatility', 'Sharpe Ratio' ] + [stock + ' Weight' for stock in list_of_ticks] # reorder dataframe columns df = df[column_order] # plot frontier, max sharpe & min Volatility values with a scatterplot # find min Volatility & max sharpe values in the dataframe (df) min_volatility = df['Volatility'].min() #min_volatility1 = df['Volatility'].min()+1 max_sharpe = df['Sharpe Ratio'].max() max_return = df['Returns'].max() max_vol = df['Volatility'].max() # use the min, max values to locate and create the two special portfolios sharpe_portfolio = df.loc[df['Sharpe Ratio'] == max_sharpe] min_variance_port = df.loc[df['Volatility'] == min_volatility] max_returns = df.loc[df['Returns'] == max_return] max_vols = df.loc[df['Volatility'] == max_vol] # plot frontier, max sharpe & min Volatility values with a scatterplot plt.style.use('seaborn-dark') df.plot.scatter(x='Volatility', y='Returns', c='Sharpe Ratio', cmap='RdYlGn', edgecolors='black', figsize=(10, 8), grid=True) plt.scatter(x=sharpe_portfolio['Volatility'], y=sharpe_portfolio['Returns'], c='green', marker='D', s=200) plt.scatter(x=min_variance_port['Volatility'], y=min_variance_port['Returns'], c='orange', marker='D', s=200) plt.scatter(x=max_vols['Volatility'], y=max_returns['Returns'], c='red', marker='D', s=200) plt.style.use('seaborn-dark') plt.xlabel('Volatility (Std. Deviation) Percentage %') plt.ylabel('Expected Returns Percentage %') plt.title(type) plt.subplots_adjust(bottom=0.4) # ------------------ Pritning 3 optimal Protfolios ----------------------- #Setting max_X, max_Y to act as relative border for window size red_num = df.index[df["Returns"] == max_return] yellow_num = df.index[df['Volatility'] == min_volatility] green_num = df.index[df['Sharpe Ratio'] == max_sharpe] multseries = pd.Series([1, 1, 1] + [100 for stock in list_of_ticks], index=['Returns', 'Volatility', 'Sharpe Ratio'] + [stock + ' Weight' for stock in list_of_ticks]) with pd.option_context('display.float_format', '%{:,.2f}'.format): plt.figtext(0.2, 0.15, "Max returns Porfolio: \n" + df.loc[red_num[0]].multiply(multseries).to_string(), bbox=dict(facecolor='red', alpha=0.5), fontsize=11, style='oblique', ha='center', va='center', wrap=True) plt.figtext(0.45, 0.15, "Safest Portfolio: \n" + df.loc[yellow_num[0]].multiply(multseries).to_string(), bbox=dict(facecolor='yellow', alpha=0.5), fontsize=11, style='oblique', ha='center', va='center', wrap=True) plt.figtext(0.7, 0.15, "Sharpe Portfolio: \n" + df.loc[green_num[0]].multiply(multseries).to_string(), bbox=dict(facecolor='green', alpha=0.5), fontsize=11, style='oblique', ha='center', va='center', wrap=True) plt.savefig(str(img_name) + '.png')
def analysis(self): # Activating Yahoo finance yf.pdr_override() # Creating data frame with ticker data df = pdr.get_data_yahoo(self.ticker, self.start, self.today) # Moving Averages mas = [2, 3, 5, 8, 10, 20, 30, 40, 50, 60] for x in mas: df["MA"+str(x)] = round(df.iloc[:, 5].ewm(span=x, adjust=False).mean(), 2) pos = 0 num = 0 percentchange = [] date = [] # Conducting trades for i in df.index: cmin = min(df["MA2"][i], df["MA3"][i], df["MA5"][i], df["MA8"][i], df["MA10"][i]) cmax = max(df["MA20"][i], df["MA30"][i], df["MA40"][i], df["MA50"][i], df["MA60"][i]) close = df["Adj Close"][i] if cmin > cmax: # RWB if pos == 0: bp = close pos = 1 # BUY elif cmin < cmax: # BWR if pos == 1: pos = 0 sp = close # SELL pc = (sp / bp - 1) * 100 percentchange.append(float(pc)) date.append(i) if num == df["Adj Close"].count() - 1 and pos == 1: pos = 0 sp = close # SELL pc = (sp / bp - 1) * 100 percentchange.append(float(pc)) date.append(i) num += 1 gains = 0 ng = 0 losses = 0 nl = 0 total_return = 1 for i in percentchange: if i > 0: gains += i ng += 1 else: losses += i nl += 1 total_return = total_return * ((i / 100) + 1) total_return = round((total_return - 1) * 100, 2) if ng > 0: avg_gain = round((gains / ng), 2) max_return = (round(max(percentchange), 2)) else: avg_gain = 0 max_return = "undefined" if nl > 0: avg_loss = round((losses / nl), 2) max_loss = (round(min(percentchange), 2)) ratio = (round((-avg_gain / avg_loss), 2)) else: avg_loss = 0 max_loss = "undefined" ratio = "inf" # Results x = [ng + nl, ratio, avg_gain, avg_loss, max_return, max_loss, total_return] returns = list(itertools.repeat(float(1), len(df.index))) for i in range(len(df.index)): for j in range(len(date)): if df.index[i] == date[j]: returns[i] = (percentchange[j]/100)+1 for i in range(len(df.index)): if i == df.index[0]: returns[0] = 1 else: temp = returns[i-1] returns[i] = temp * returns[i] return x, returns
* **volume** int * Number of shares traded during trading hours. The primary key of this table is (mkt\_date, ticker). ### Importing libraries First of all, we have to import all of the necessary libraries. We will be using pandas, pandas datareader, datetime, yfinance, and sqlite3. Then, as usual, we connect to the database using sqlite3. from pandas_datareader import data as pdr from datetime import datetime, date, timedelta import yfinance as yf yf.pdr_override() # overrides yfinance to expect pandas datareader import pandas as pd import sqlite3 con = sqlite3.connect("../data/invest_tracker.db") cur = con.cursor() ### Calling the API Now, we will build a simple function to download today's stock market prices from the given ticker. Thankfully, YFinance does all of the hard work for us, so weonly need to make a single API call. The get\_data\_yahoo call on pandas datareader automatically queries the API, downloads data on the given ticker and date range, and writes it to a dataframe. Since we are only querying a single day, the returned dataframe will only contain a single row. today = date.today() yesterday = today - timedelta(days=1) tomorrow = today + timedelta(days=1)
import yfinance from pandas_datareader import data as pdr yfinance.pdr_override() def fetch_from_yahoo(all_symbols): symbols_str = " ".join(all_symbols) data = pdr.get_data_yahoo( symbols_str, period="5d", interval="30m").fillna(method='ffill').fillna(method='bfill') return data.swaplevel(axis=1) if len(all_symbols) > 1 else data
import pandas as pd pd.core.common.is_list_like = pd.api.types.is_list_like import pandas_datareader.data as web import numpy as np import matplotlib.pyplot as plt import seaborn as sns import datetime import time import yfinance as yahoo_finance yahoo_finance.pdr_override() from mpl_finance import candlestick2_ohlc from argparse import ArgumentParser def createZigZagPoints(dfSeries, minSegSize=0.1, sizeInDevs=0.5): minRetrace = minSegSize curVal = dfSeries[0] curPos = dfSeries.index[0] curDir = 1 dfRes = pd.DataFrame(index=dfSeries.index, columns=["Dir", "Value"]) for ln in dfSeries.index: if ((dfSeries[ln] - curVal) * curDir >= 0): curVal = dfSeries[ln] curPos = ln else: retracePrc = abs((dfSeries[ln] - curVal) / curVal * 100) if (retracePrc >= minRetrace): dfRes.loc[curPos, 'Value'] = curVal
# -*- coding: utf-8 -*- """ Created on Fri Feb 21 10:22:27 2020 @author: TerryLaw """ from datetime import datetime, timezone, timedelta import ffn import matplotlib.pyplot as plt import matplotlib.ticker as mtick import yfinance as yfin yfin.pdr_override() def calculate_ifree_growth_and_income_fund(): if datetime.now( timezone.utc).astimezone().tzinfo.utcoffset(None) == timedelta( seconds=28800): prices = ffn.get('TLT, GLD, BIL', start='2013-01-01', end=datetime.today()) else: prices = ffn.get('TLT, GLD, BIL', start='2012-12-31', end=datetime.today()) prices = prices.reset_index() prices['portfolio'] = 100 prices['tlt_rb'] = 0
#Richard Moglen Jan 2020 Backtest of RWB strategies #import necessary packages/libraries import pandas as pd import numpy as np import yfinance as yf import datetime as dt from pandas_datareader import data as pdr import statistics import time yf.pdr_override() # Activate yahoo finance workaround now = dt.datetime.now() #Runs until todays date print() stock = input("Enter the stock symbol (enter 'quit' to stop): " ) #Query user for stock ticker while stock != "quit": #Runs this loop until user enters 'quit' (can do many stocks in a row) startString = input( "Enter Date to start Backtest (ex: 12/4/2003): ") #Query user startList = list(map( int, (startString.split('/')))) #Split string into an array startyear = startList[2] #assign 3rd element in array to startyear startmonth = startList[0] #assign 1st element in array to startyear startday = startList[1] #assign 2nd element in array to startyear start = dt.datetime(startyear, startmonth, startday) #Set starting time for datasample startalt = dt.datetime(startyear - 1, startmonth, startday) #Set starting time for datasample df = pdr.get_data_yahoo(stock, startalt, now) #create panda dataframe with stock data
import os from pandas_datareader import data as pdr import matplotlib.pyplot as pyplot import pandas as pd import numpy as np import yfinance as yf from datetime import datetime today = datetime.today().strftime('%Y-%m-%d') x = (sys.argv[1]) print("The script has the name %s" % x) yf.pdr_override() # <== that's all it takes :-) # download dataframe using pandas_datareader data = pdr.get_data_yahoo(x, start="2019-06-01", end="2020-12-18") df = pd.DataFrame(data) df = df.reset_index() print(df.columns) #df.plot(kind='line',x='Date',y='Close',color='red') #pyplot.show() #for i in range(0,df.shape[0]-2): # df.loc[df.index[i+2],'SMA_3'] = np.round(((df.iloc[i,1]+ df.iloc[i+1,1] +df.iloc[i+2,1])/3),1)
def main(): yf.pdr_override() sp500 = pdr.get_data_yahoo('^GSPC', period=('30d')) print(sp500.tail()) mpf.plot(sp500, type='line', title='S&P 500') action = 1 while action != 0: print("What do you want to do today\n") action = gf.getnumber( "\npress 1 to search current and historic stock price \npress 2 to download data about a stock \npress 3 to view downloaded data \npress 4 to show the index\npress 5 to get tickers from an index \npress 6 to get all s&p 500 or nasdaq price data (WARNING: THIS WILL TAKE A WHILE)\npress 7 to show the correlation heatmap between stock (WARNING: THIS WILL TAKE A WHILE)\npress 8 to use the stock researcher \npress 9 to use the calculator \npress 0 to quit " ) #if action == 1: #Whattofind = input("What you want to find? ") #specificCellletter = (find_specific_cell(Whattofind)) #value = get_role_value(specificCellletter) #newvalue = input("What the new value? ") #currentSheet['C' + str(value)] = float(newvalue) #theFile.save('stock portfolio.xlsx') #print("The stock " + Whattofind + " value has changed to " +newvalue) #elif action == 2: #Whattofind = input("What you want to find? ") #specificCellletter = (find_specific_cell(Whattofind)) #value = get_role_value(specificCellletter) #price = currentSheet['C' + str(value)].value #print("\nThe value of the stock "+ Whattofind +" is "+ str(price) +"\n") if action == 1: #A function to show stock price by asking the user to input the stock symbol, also provide the user the ability to choose the time period Whattofind = input("Which stock price are you interested? ") whattofindprice = yf.Ticker(Whattofind) pricehistory = whattofindprice.history(period="10d") print("The price of " + Whattofind + " for the last 10 days is\n" + str(pricehistory)) try: mpf.plot(pricehistory, type='candle', volume=True, title=str(Whattofind), ylabel='OHLC Candles', ylabel_lower='Volume', style='charles') except: print() option = input("Would you want more data? y/n") while option == "y": period = gf.getnumber("How many days of data do you want? ") pricehistory = whattofindprice.history(period=(str(period) + "d")) print("The price of " + Whattofind + " is\n" + str(pricehistory)) mpf.plot(pricehistory, type='candle', volume=True, title=str(Whattofind), ylabel='OHLC Candles', ylabel_lower='Volume', style='charles') option = input("Would you want more data? y/n") elif action == 2: #A function allows the user to download stock data by asking the user to input the stock symbol and the start and end date then save the data into a csv file yes = 0 if not os.path.exists('history/downloadhistory.dat'): Whattofind = input( "Which stock/stocks price are you interested? (You can enter one or more stocks just separate the stock symbol with space)" ) startdate = input("Startdate (format: YYYY/MM/DD): ") enddate = input("Enddate (format: YYYY/MM/DD): ") lastdownload = open('history/downloadhistory.dat', 'wb') pickle.dump(str(Whattofind), lastdownload) pickle.dump(startdate, lastdownload) pickle.dump(enddate, lastdownload) lastdownload.close() else: lastdownload = open('history/downloadhistory.dat', 'rb') history = pickle.load(lastdownload) hisstart = pickle.load(lastdownload) hisend = pickle.load(lastdownload) print( "You have previously download data of '{}', would you like to download it again?" .format(history)) choice = input("y/n\n") if choice == 'y': question = input( "Would you like to download the same period? if yes please press 1, if you would like to update your data to today press 2, if you would like to update your data to 60days press 3, if you would like to download the data of specific time period press enter." ) Whattofind = history if question == '1': startdate = hisstart enddate = hisend elif question == "2": startdate = hisstart enddate = dt.date.today() enddate = enddate + dt.timedelta(days=1) lastdownload = open('history/downloadhistory.dat', 'wb') pickle.dump(str(Whattofind), lastdownload) pickle.dump(startdate, lastdownload) pickle.dump(enddate, lastdownload) lastdownload.close() elif question == '3': yes = 1 pass else: startdate = input("Startdate (format: YYYY/MM/DD): ") enddate = input("Enddate (format: YYYY/MM/DD): ") lastdownload = open('history/downloadhistory.dat', 'wb') pickle.dump(str(Whattofind), lastdownload) pickle.dump(startdate, lastdownload) pickle.dump(enddate, lastdownload) lastdownload.close() else: Whattofind = input( "Which stock/stocks price are you interested? (You can enter one or more stocks just separate the stock symbol with space)" ) CHOICE = input( "The default option for this download is 60 day period, do you want to proceed?(y/n)" ) if CHOICE.lower() == 'y': startdate = "0000/00/00" enddate = "0000/00/00" lastdownload = open('history/downloadhistory.dat', 'wb') pickle.dump(str(Whattofind), lastdownload) pickle.dump(startdate, lastdownload) pickle.dump(enddate, lastdownload) lastdownload.close() yes = 1 if CHOICE.lower() == 'n': startdate = input("Startdate (format: YYYY/MM/DD): ") enddate = input("Enddate (format: YYYY/MM/DD): ") lastdownload = open('history/downloadhistory.dat', 'wb') pickle.dump(str(Whattofind), lastdownload) pickle.dump(startdate, lastdownload) pickle.dump(enddate, lastdownload) lastdownload.close() # the following three try functions are use to change the date from string to dt type and also choosing which mode to download, the 60 days or the custom date try: startdate = gf.changestringtodate(startdate) except: pass try: enddate = gf.changestringtodate(enddate) enddate = enddate + dt.timedelta(days=1) except: pass if yes == 0: data = yf.download( str(Whattofind), start=startdate, end=enddate).to_csv(str(Whattofind) + ".csv") elif yes == 1: data = yf.download( str(Whattofind), period="60d").to_csv(str(Whattofind) + ".csv") print("The data have been saved in the directory " + str(os.getcwd())) elif action == 3: #A function to allow user to open csv files print( "Which csv do you want to open? (Please type the full name): ") currentpathnote = os.getcwd() os.chdir(str(currentpathnote)) for file in glob.glob("*.csv"): print(file) filename = input("") try: df = pd.read_csv(filename, header=0, index_col='Date', parse_dates=True) print(df) except ValueError: df = pd.read_csv(filename, skiprows=1) print(df) elif action == 4: #A function allows the user to search up s&p 500 index history choice = 0 stockidx = financeplayground.get_index() sp500 = pdr.get_data_yahoo(stockidx, period=('60d')) print(sp500.tail()) mpf.plot(sp500, type='line', title=stockidx) choice = gf.getnumber( "What would you like to do?\nPress 1 to show the candle plot\nPress 2 to download data\n" ) if choice == 1: mpf.plot(sp500, type='candle', title=stockidx, style='charles') if choice == 2: lastdownload = open('history/downloadhistory.dat', 'rb') history = pickle.load(lastdownload) hisstart = pickle.load(lastdownload) hisend = pickle.load(lastdownload) startdate = gf.changestringtodate(hisstart) enddate = gf.changestringtodate(hisend) enddate = enddate + dt.timedelta(days=1) data = yf.download(str(stockidx), start=startdate, end=enddate).to_csv(str(stockidx) + ".csv") elif action == 5: #get tickers action = gf.getnumber( "Which ticket do you want to get?\ns&p press 1\nnasdaq press 2" ) if action == 1: financeplayground.save_tickers( 'https://en.wikipedia.org/wiki/List_of_S%26P_500_companies', 'sp500tickers.pickle', 0) with open("ticker/sp500tickers.pickle", "rb") as f: tickers = pickle.load(f) print(tickers) if action == 2: financeplayground.save_tickers( 'https://en.wikipedia.org/wiki/NASDAQ-100', 'nasdaqtickers.pickle', 1) with open("ticker/nasdaqtickers.pickle", "rb") as f: tickers = pickle.load(f) print(tickers) elif action == 6: #download s&p 500 data and automatically compile them into a separate file contain all the adjusted close action = gf.getnumber( "Which data do you wanna get?\ns&p press 1\nnasdaq press 2\nget all press 3 " ) if action == 1: update.updatesp() if action == 2: update.updatenasdaq() if action == 3: update.updateall() elif action == 7: action = gf.getnumber('s&p 500 press 1\nnasdaq press 2 ') if action == 1: if not os.path.exists( 'joined_closed/sp500tickers.pickle_joined_closed.csv'): financeplayground.compile_data('sp500tickers.pickle', 'stocks_dfs') financeplayground.visualize_data( 'sp500tickers.pickle_joined_closed.csv') if action == 2: if not os.path.exists( 'joined_closed/nasdaqtickers.pickle_joined_closed.csv' ): financeplayground.compile_data('nasdaqtickers.pickle', 'stocks_nasdaq') financeplayground.visualize_data( 'nasdaqtickers.pickle_joined_closed.csv') elif action == 8: ## Research stocks researcher.research() elif action == 9: #A function that allow the user to use the calculator calc = "" while calc != 'exit': calc = input("Type Calculation (type exit to exit): \n") print("Answer: " + str(eval(calc)))
from pandas_datareader import data as pdr import yfinance as yf yf.pdr_override() #빠르게 data 다운로드 sec = pdr.get_data_yahoo('005930.KS', start='2018-05-04') msft = pdr.get_data_yahoo('MSFT', start='2018-05-04') print(sec.head(10)) tmp_msft = msft.drop(columns='Volume') print(tmp_msft.tail()) print(sec.index) print(sec.columns) #import matplotlib.pyplot as plt #plt.plot(sec.index,sec.Close,'b',label='Samsung Electronics') #plt.plot(msft.index,msft.Close,'r--',label='Microsoft') #plt.legend(loc='best') #plt.show() print(sec['Close'])
class BacktestTool(AbstractTool): """ This class represents a tool for backtesting purposes. """ yf.pdr_override() def __init__(self, symbol='AAPL', initial_date="2019-01-01", final_date="2020-01-01"): """ Class constructor. @param initial_balance: initial_balance @@type initial_balance: float @param symbols: symbols that should be used while backtesting @@type symbols: list of strings @param initial_date: initial date to get data @@type initial_date: datetime string in the format "%YYYY-%MM-%DD" @param final_date: final date to get data @@type final_date: datetime string in the format "%YYYY-%MM-%DD" @param take_profit: take profit constant (where stop the operation for profit) @@type take_profit: float @param stop_loss: stop loss constant (where stop the operation for loss) @@type stop_loss """ super().__init__(tool_name="Backtest") self.symbol = symbol self.data = None self.initial_date = initial_date self.final_date = final_date def execute_agent(self, agent, balance, percentage, take_profit, stop_loss, save_log=True): """ Runs the backtest tool. @param agent: the agent the method should be executed on. @@type agent: class Agent """ self.initial_balance = balance print(f'Running backtest on agent {agent.get_name()}...') data = self.get_data() total_length = len(data) for i in tqdm(range(1, total_length)): agent.update(data[0:i]) active_operation_data = agent.get_active_operation_data( data['Close'][-1]) operation_history = agent.get_history() balance = agent.get_balance() data = self._create_backtest_log_data(agent, active_operation_data, balance, operation_history) # Save log file if save_log: self.log.log(data) def get_data(self): """ Method to get data online using yahoo finance api. @return data: data achieved online @@@type data: list of dataframes """ if self.initial_date and self.final_date: # Get stock data from yahoo self.data = pdr.get_data_yahoo(self.symbol, start=self.initial_date, end=self.final_date) self.data['Change'] = self.data['Close'].pct_change() return self.data elif not initial_date: raise ValueError("Initial date can't be an empty value.") else: raise ValueError("Final date can't be an empty value.") def _create_backtest_log_data(self, agent, active_operation_data, balance, operation_history): """ Method to create the data that goes into the log file. """ count_buy_operations, count_buy_success_operations, count_sell_operations, count_sell_success_operations, count_successful_operations, count_failed_operations = 0, 0, 0, 0, 0, 0 for history in operation_history: if history['Entered as'].upper() == 'BUY': if history['Result'].upper() == 'SUCCESS': count_buy_success_operations += 1 count_buy_operations += 1 else: if history['Result'].upper() == 'SUCCESS': count_sell_success_operations += 1 count_sell_operations += 1 if history['Result'].upper() == 'SUCCESS': count_successful_operations += 1 else: count_failed_operations += 1 total_balance = balance + active_operation_data[1] initial_balance = self.initial_balance # Initialize as empty data = {} # Get model name and tools parameters data['Used on'] = agent.get_name() data['Symbol'] = self.symbol data['Initial date'] = self.initial_date data['Final date'] = self.final_date data['Balance'] = { 'Initial (R$)': round(self.initial_balance, 2), 'Final (R$)': round(total_balance, 2) } data['Profit'] = { 'Total profit (R$)': round(total_balance - initial_balance, 2), 'Total profit (%)': f'{((total_balance - initial_balance) / initial_balance * 100).round(2)} %' } data['Active'] = { 'Total (#)': round(active_operation_data[0], 2), 'Total (R$)': active_operation_data[1] } data['Operations'] = { 'Total': count_buy_operations + count_sell_operations + active_operation_data[0], 'Total closed': count_buy_operations + count_sell_operations, 'Total buy closed': count_buy_operations, 'Total buy closed successful': count_buy_success_operations, 'Total sell closed': count_sell_operations, 'Total sell closed successful': count_sell_success_operations, 'Total successful': count_successful_operations, 'Total failed': count_failed_operations, 'History': operation_history } return data
from pandas_datareader import data as pdr import yfinance as yf import matplotlib.pyplot as plt yf.pdr_override() # pandas data reader를 재정의 sec = pdr.get_data_yahoo('005930.KS', start='2018-05-04') msft = pdr.get_data_yahoo('MSFT', start='2018-05-04') sec_dpc = (sec['Close']/sec['Close'].shift(1) - 1)*100 sec_dpc.iloc[0] = 0 sec_dpc_cs = sec_dpc.cumsum() print(sec_dpc.head()) msft_dpc = (msft['Close']/msft['Close'].shift(1) - 1)*100 msft_dpc.iloc[0] = 0 msft_dpc_cs = msft_dpc.cumsum() plt.plot(sec_dpc_cs.index, sec_dpc_cs, 'b', label='Samsung') plt.plot(msft_dpc_cs.index, msft_dpc_cs, 'r--', label='MS') plt.ylabel('Change %') plt.grid(True) plt.legend(loc='best') plt.show()
import csv import os import time import pickle app = dash.Dash(external_stylesheets=[dbc.themes.LUX]) #read some older tweets for start and sort them from the most popular df = pd.read_csv('data/20200706_102141_Tesla_tweets.csv') df_pop = df[['retweetcount', 'text']] df_pop = df_pop.drop_duplicates(subset='text').reset_index(drop=True) df_pop = df_pop.sort_values(by=['retweetcount'], ascending=False).reset_index(drop=True) df2 = df_pop[['text']] df2.columns = ['Tweeter Feed'] yf.pdr_override() #use pandas_datareader #app layout using some Boostrap components app.layout = dbc.Container( [ html.H1('Tesla Stock & Twitter Dashboard'), html.Hr(), html.Label('Select start and end dates:'), html.Br(), dbc.Container([ dcc.DatePickerRange(id='my_date_picker', min_date_allowed=datetime.datetime(2015, 1, 1), max_date_allowed=datetime.date.today(), start_date=datetime.datetime(2020, 1, 1), end_date=datetime.date.today()), dbc.Button(id='submit-button',