def load_tickers(self, cur, conn):
self.df_ticker = pd.DataFrame()
self.nasdaq = si.tickers_nasdaq()
self.sp500 = si.tickers_sp500()
self.dow = si.tickers_dow()
self.other = si.tickers_other()
self.tickers = list(set([*nasdaq, *sp500, *dow, *other]))
self.df_ticker['ticker'] = self.tickers
self.df_ticker.replace("", float("NaN"), inplace=True)
self.df_ticker.dropna(subset=["ticker"], inplace=True)
self.df_ticker['isdow'] = self.df_ticker['ticker'].isin(self.dow)
self.df_ticker['issp500'] = self.df_ticker['ticker'].isin(self.sp500)
self.df_ticker['isnasdaq'] = self.df_ticker['ticker'].isin(self.nasdaq)
self.insert = [
list(row) for row in self.df_ticker.itertuples(index=False)
]
self.SQL_Ticker_insert = """ INSERT INTO public.tickers(ticker,isdow, isnasdaq, issp500) VALUES (%s,%s,%s,%s) ON CONFLICT DO NOTHING"""
self.cur.executemany(self.SQL_Ticker_insert, self.insert)
self.conn.commit()
self.rowcount = self.cur.rowcount
return None
def listStock_gen(self, combobox):
# gather stock symbols from major US exchanges
df1 = pd.DataFrame( si.tickers_sp500() )
df2 = pd.DataFrame( si.tickers_nasdaq() )
df3 = pd.DataFrame( si.tickers_dow() )
df4 = pd.DataFrame( si.tickers_other() )
# convert DataFrame to list, then to sets
sym1 = set( symbol for symbol in df1[0].values.tolist() )
sym2 = set( symbol for symbol in df2[0].values.tolist() )
sym3 = set( symbol for symbol in df3[0].values.tolist() )
sym4 = set( symbol for symbol in df4[0].values.tolist() )
# join the 4 sets into one. Because it's a set, there will be no duplicate symbols
symbols = set.union( sym1, sym2, sym3, sym4 )
# Some stocks are 5 characters. Those stocks with the suffixes listed below are not of interest.
my_list = ['W', 'R', 'P', 'Q']
del_set = set()
sav_set = set()
for symbol in symbols:
if len( symbol ) > 4 and symbol[-1] in my_list:
del_set.add( symbol )
else:
sav_set.add( symbol )
for ticker in sav_set:
combobox.addItem(str(ticker))
def get_tickers():
'''
Get ticker symbols for stocks listed on major stock exchanges.
At time of writing, this function retrieves 9899 stock symbols
'''
print("Retrieving Stock Symbols...")
dow_tickers = stock_info.tickers_dow()
nasdaq_ticker = stock_info.tickers_nasdaq()
sp500_ticker = stock_info.tickers_sp500()
other_tickers = stock_info.tickers_other()
all_tickers = list(
set(dow_tickers + nasdaq_ticker + sp500_ticker + other_tickers))
print(f"\nTotal number of stock symbols retrieved: {len(all_tickers)}")
tickers_dict = {
'DOW': dow_tickers,
'NASDAQ': nasdaq_ticker,
'SP500': sp500_ticker,
'others': other_tickers
}
for exchange_name, ticker_list in tickers_dict.items():
print(f"\t{exchange_name}: {len(ticker_list)}")
return all_tickers
def yahoo_finance():
#dict_info = si.get_analysts_info('nflx')
#df_info = pd.DataFrame.from_dict(dict_info, orient='index')
#pprint.pprint(dict_info)
symbols = si.tickers_dow()
return str(symbols)
def get_dow_tickers(self):
"""
Get the Dow stocks tickers.
Returns
-------
tickers_dow : list of str
Dow tickers
"""
tickers_dow = ys.tickers_dow()
return tickers_dow
def tickers(request):
dow = si.tickers_dow()
nasdaq = si.tickers_nasdaq()
sp500 = si.tickers_sp500()
other = si.tickers_other()
all = json.dumps({
'dow': dow,
'nasdaq': nasdaq,
'sp500': sp500,
'other': other
})
return HttpResponse(all)
def get_US_price(start_date, end_date):
"""
Download US stocks prices.
Parameters
----------
start_date : string
example : '2000-01-01'.
end_date : string
example : '2019-12-31'.
Returns
-------
total_df : pd.DataFrame
Stocks prices from start_date to end_date.
"""
dow_list = si.tickers_dow()
sp500_list = si.tickers_sp500()
nasdaq_list = si.tickers_nasdaq()
other_list = si.tickers_other()
ticker = dow_list + sp500_list + nasdaq_list + other_list
ticker = [ticker[i] for i in range(len(ticker)) if not ticker[i] in ticker[:i]]
ticker = pd.DataFrame(ticker, columns=['Ticker'])
for num, code in enumerate(ticker['Ticker']):
try:
print(num, code)
time.sleep(1)
try:
df = fdr.DataReader(code, start_date, end_date)
df = df['Close']
df = pd.DataFrame(df)
df.columns = [code]
except Exception as e:
print(e, 'Error in Ticker', code)
continue
if num == 0:
total_df = df
else:
total_df = pd.merge(total_df, df, how='outer', right_index=True, left_index=True)
except ValueError:
continue
except KeyError:
continue
total_df.to_csv(r'C:\Users\Samsung\Downloads\quant\Python\data\US_price.csv')
return total_df
def get_symbols(index):
symbols = []
if index == CFG.INDEX_DOW:
symbols = si.tickers_dow()
elif index == CFG.INDEX_NASDAQ:
symbols = si.tickers_nasdaq()
elif index == CFG.INDEX_SP500:
symbols = si.tickers_sp500()
return {
'fulfillmentText': str(symbols),
'displayText': '25',
'source': 'webhookdata',
'platform': 'FACEBOOK',
}
def update_tickers(path, name):
'''
Gets a list of tickers from the yahoo finance database and saves the list to a .csv file under a given directory and name
:param path: string, must be denoted as path\\to\\main\\folder\\
:param name: string, will be the name of the .csv file saved, must not have any file denotion in it
:return: saves a list of tickers to path\\name.csv
'''
sources, tickers = [
stock_info.tickers_dow(),
stock_info.tickers_nasdaq(),
stock_info.tickers_other(),
stock_info.tickers_sp500()
], []
for source in sources:
for ticker in source:
if ticker not in tickers:
tickers.append(ticker)
pd.DataFrame(tickers).to_csv(path + name + '.csv')
def __init__(self, date=None):
self.ticker = "AAPL"
self.date = date
self.expiry_date = None
self.underlying = self.get_underlying_price()
self.tickers_select = [{
"label": i,
"value": i
} for i in stock_info.tickers_dow()] + [{
"label": "SPY",
"value": "SPY"
}]
self.calls_formatted = None
self.puts_formatted = None
self.live_price = self.live_prices_released()
if self.live_price:
self.live_price_comment = ''
self.current_date = datetime.datetime.now()
else:
self.live_price_comment = "* Prices displayed are not current. Live prices released around 3pm GMT"
self.current_date = datetime.datetime(2021, 1, 7)
def main():
initialize()
parser = build_parser()
options = parser.parse_args()
if options.mode == "train":
import finrl.autotrain.training
finrl.autotrain.training.train_one()
elif options.mode == "download_data":
print('Download Data Begin')
dow_30 = si.tickers_dow()
# ETF
#dftmp = pd.read_csv('data/etf_tom.csv',index_col=0)
#dow_30 = dftmp.tic.unique()
# DOW30
dftmp = pd.read_csv('data/tom_dow_done_data.csv', index_col=0)
dow_30 = dftmp.tic.unique()
#dow_30 = ['DSS','AAPL','INFY']
#dow_30 = ['^DJI']
price_data = {ticker: si.get_data(ticker) for ticker in dow_30}
df = reduce(lambda x, y: x.append(y), price_data.values())
df.reset_index(inplace=True)
df = df.rename(columns={'index': 'date', 'ticker': 'tic'})
fe = FeatureEngineer(use_technical_indicator=True,
use_turbulence=False,
user_defined_feature=False)
df = fe.preprocess_data(df)
now = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
df.to_csv(config.DATA_SAVE_DIR + "/" + "dow30_" + now + ".csv",
index=False)
print('Download Complete')
def format_ticker():
# this function allows a user to pick a stock or get a random stock
# These the sets are formed by importing the tickers from Yahoo API
dow_set = set(yf.tickers_dow())
snp_set = set(yf.tickers_sp500())
# Combine both sets to create a random set of all companies in the S&P 500 and the dow jones
sp_dow = dow_set.union(snp_set)
test = True
print("Please type 'quit' to exit the program at any time")
print("Please type 'random' to get a random stock to analyze")
while test:
input_1 = str(
input(
"Please enter a ticker of your choosing, with no quotation marks:"
))
# allows the user to quit
if input_1.upper().strip() == "QUIT":
print("you have opted to quit the program, goodbye!")
test = False
# this allows the user get a random stock from the dop and SP set
elif input_1.upper().strip() == "RANDOM":
# pops a string from the set
a = sp_dow.pop()
print(a)
# this ticker calls the format object function which is the main function
format_object(a)
test = False
# will allow the function to run again if the user enters a string longer than 8 elements
# no stock will no 8 strings long
elif len(input_1) < 8:
print(input_1)
# this ticker calls the format object function which is the main function
format_object(input_1)
test = False
def getOptionsData(personalRiskTolerance, budget, printOutput = 'True'):
'''
get the up to date stock options pareto.
Currently hardcoded for the DOW stocks
inputs:
personalRiskTolerance - risk level - number between 0 and 0.9
budget - Number - larger than 2000
printOutput - bool to determine whether print statements show
outputs:
stockPareto DataFrame (all options within the budget)
bestPick DataFrame (highest value return within risk tolerance)
hardcoded:
options date - 5/15/2020
stocks to pick from: All DOW stocks
'''
# date selection
today = datetime.today()
optionsDate = datetime(2020,5,15)
t = ((optionsDate - today).days + ((optionsDate - today).seconds/86400))/365
daysLeft = (optionsDate - today).days
hoursLeft = int((optionsDate - today).seconds/3600)
if printOutput:
print('\nOptions will expire in approximately {} days and {} hours'.format(daysLeft,hoursLeft))
stockPareto = pd.DataFrame()
if printOutput:
print('Pulling stock data...\n')
# initial data capture and processing
for stock in stock_info.tickers_dow():
# checks if there is an option during the particular week.
try:
individualOptionsData = options.get_puts(stock,date=optionsDate)
# capture stock, current price for each stock
individualOptionsData['Stock Name'] = stock
individualOptionsData['Current Price'] = stock_info.get_live_price(stock)
# IV formatting to a number
individualOptionsData['IV']= individualOptionsData['Implied Volatility'].str.slice_replace(-1,repl='').astype(float)/100
# if not, skip the ticker
except:
if printOutput:
print('No data from {}'.format(stock))
continue
# if successful at obtaining options data, fill DataFrame stockPareto with the values
stockPareto = stockPareto.append(individualOptionsData)
if printOutput:
print('Data from {} collected'.format(stock))
if printOutput:
print('Data Capture Complete!')
# bool logic to make sure options are worth investing in
beingTraded = stockPareto['Volume'] != '-'
asksExist = stockPareto['Ask'] != '-'
bidsExist = stockPareto['Bid'] != '-'
# filtering by bool logic
stockPareto = stockPareto[beingTraded & asksExist & bidsExist]
####################################################
### formatting of key variables in the DataFrame ###
####################################################
# POP derived from Black-Scholes model
stockPareto['POP'] = 100*stats.norm.cdf((np.log(stockPareto['Current Price'] / stockPareto['Strike'] ) +
( (stockPareto['IV']**2) /2)*t) / (stockPareto['IV']*np.sqrt(t)))
stockPareto['Strike'] = stockPareto['Strike'].astype(float)
stockPareto['Bid'] = stockPareto['Bid'].astype(float)
stockPareto['Ask'] = stockPareto['Ask'].astype(float)
# determine number of each contract that is in budget
# potential gain is the average contract selling price ~ (bid / ask) * 100
# potential gain multiple contracts - potential gain * number of contracts that can be sold within budget
stockPareto['contractsInBudget'] = np.floor(budget/(stockPareto['Strike']*100))
stockPareto['Potential Gain'] = ((stockPareto['Ask'] + stockPareto['Bid'])/2) * 100
stockPareto['Potential Gain Multiple Contracts'] = stockPareto['Potential Gain'] * stockPareto['contractsInBudget']
###########################
### plotting the pareto ###
###########################
inBudget = stockPareto['contractsInBudget'] > 0
isInteresting = stockPareto['Bid'] != 0
stockPareto = stockPareto[inBudget & isInteresting]
stockPareto = stockPareto.set_index('Contract Name')
# this is the field which will show in the interactive plot
stockPareto['printString'] = ('Stock: ' + stockPareto['Stock Name']+'\n'
'Strike Price = $'+ round(stockPareto['Strike'],2).astype(str)+'\n'+
'Current Price = $' + round(stockPareto['Current Price'],2).astype(str) + '\n' +
'Potential Gain = $'+ round(stockPareto['Potential Gain Multiple Contracts'],2).astype(str)+'\n' +
'ROI = ' + round(((stockPareto['Potential Gain Multiple Contracts']/budget) * 100),2).astype(str) + '%\n' +
'Probability of Profit = ' + round(stockPareto['POP'],2).astype(str))
####################
## Best Fit Logic ##
####################
notBelowRisk = stockPareto['POP'] > (personalRiskTolerance*100)
bestPick = stockPareto[notBelowRisk].sort_values(by='Potential Gain Multiple Contracts',ascending = False)
bestPick = bestPick.loc[bestPick['Potential Gain Multiple Contracts'].idxmax()]
if printOutput:
print('The best OPTION is:')
print(bestPick)
return stockPareto, bestPick
import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
import datetime
from yahoo_fin import stock_info as si
plt.rcParams['figure.figsize'] = (15, 10)
tickers = si.tickers_dow()
individual_stock = input(
f"Which of the following stocks would you like to backtest \n{tickers}\n:")
num_of_years = 1
start = datetime.date.today() - datetime.timedelta(days=int(365.25 *
num_of_years))
yf_prices = yf.download(tickers, start=start)
# Individual Stock Strategy
prices = yf_prices['Adj Close'][individual_stock]
rs = prices.apply(np.log).diff(1).fillna(0)
w1 = 5
w2 = 22
ma_x = prices.rolling(w1).mean() - prices.rolling(w2).mean()
pos = ma_x.apply(np.sign)
fig, ax = plt.subplots(2, 1)
ma_x.plot(ax=ax[0],
title=f'{individual_stock} Moving Average Crossovers and Positions')
pos.plot(ax=ax[1])
from typing import Optional
import yahoo_fin.stock_info as si
from great_expectations.core.expectation_configuration import ExpectationConfiguration
from great_expectations.execution_engine import PandasExecutionEngine
from great_expectations.expectations.expectation import ColumnMapExpectation
from great_expectations.expectations.metrics import (
ColumnMapMetricProvider,
column_condition_partial,
)
DOW_TICKERS_LIST = [t.lower() for t in si.tickers_dow()]
# This method compares a string to the valid Dow Jones ticker
def is_valid_dow_ticker(ticker: str) -> bool:
return ticker.lower() in DOW_TICKERS_LIST
# This class defines a Metric to support your Expectation.
# For most ColumnMapExpectations, the main business logic for calculation will live in this class.
class ColumnValuesToBeValidDowTicker(ColumnMapMetricProvider):
# This is the id string that will be used to reference your metric.
condition_metric_name = "column_values.valid_dow_ticker"
# This method implements the core logic for the PandasExecutionEngine
@column_condition_partial(engine=PandasExecutionEngine)
def _pandas(cls, column, **kwargs):
return column.apply(lambda x: is_valid_dow_ticker(x))
#!/usr/bin/env python3 from yahoo_fin import options, stock_info as si import random # commented out bc takes a while to scrape all this data # get S&P stock tickers sp500 = si.tickers_sp500() # get NASDAQ stock tickers nasdaq = si.tickers_nasdaq() # get Dow Jones stock tickers dow = si.tickers_dow() # get Other stock tickers others = si.tickers_other() # Combine all elements into one list all = sp500 + nasdaq + dow + others # select random ticker from list random_ticker = random.choice(all) # random_ticker = "T" print(random.choice(["calls","puts"])
def dow(self):
self.symb = si.tickers_dow()
def getDowJonesList():
return si.tickers_dow()
def get_symbols_down_jones():
"""Retrieves Dow Jones Symbols"""
return tickers_dow()
import pandas as pd
import plotly.offline as py
import datetime as dt
import yahoo_fin.stock_info as yf
import plotly.graph_objs as go
Markets = ("NASDAQ", "DOW", "SP500")
Market = input("Select Market Index: ")
while Market not in Markets:
print("Please Select between DOW, NASDAQ or SP500")
Market = input("Select Market Index: ")
if Market == "DOW":
Market = yf.tickers_dow()
print("Fetching DOW JONES tickers")
elif Market == "SP500":
Market = yf.tickers_sp500()
print("Fetching S&P500 tickers")
elif Market == "NASDAQ":
Market = yf.tickers_nasdaq()
print("Fetching NASDAQ tickers")
else:
print("Market Data currently unavailabe")
Market = input("Select Market Index: ")
Ticker = input("Select Stock: ")
if Ticker in Market:
print("Fetching Required Data for " + str(Ticker) +
import statsmodels.api as sm
key = "PKDMJ3EFG7K6RBAQNPT3"
sec = "gogIZwlzCnbkBbxcdBWPdiUxrrRJDyoPNR88GO4K"
#API endpoint URL
url = "https://paper-api.alpaca.markets"
#api_version v2 refers to the version that we'll use
#very important for the documentation
api = tradeapi.REST(key, sec, url, api_version='v2')
#Init our account var
account = api.get_account()
dow_list = si.tickers_dow()
sp500_list = si.tickers_sp500()
nasdaq_list = si.tickers_nasdaq()
all_tickers = sorted(list(filter(None, set(dow_list + sp500_list + nasdaq_list))))
"""
all_historical = {}
for ticker in all_tickers:
all_historical[ticker] = si.get_data(ticker)
print(ticker)
dow_historical = {}
for ticker in dow_list:
dow_historical = si.get_data(ticker, start_date='1990-01-01', end_date='2020-01-01', interval='1d')
print(ticker)
import urllib.request, urllib.error, urllib.parse
import time
import datetime
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
import matplotlib.dates as mdates
from mplfinance.original_flavor import candlestick_ohlc
import matplotlib
import pylab
import requests
from yahoo_fin import stock_info as si
matplotlib.rcParams.update({'font.size': 9})
evenBetter = si.tickers_dow()
def rsiFunc(prices, n=14):
deltas = np.diff(prices)
seed = deltas[:n + 1]
up = seed[seed >= 0].sum() / n
down = -seed[seed < 0].sum() / n
rs = up / down
rsi = np.zeros_like(prices)
rsi[:n] = 100. - 100. / (1. + rs)
for i in range(n, len(prices)):
delta = deltas[i - 1] # the diff is 1 shorter
if delta > 0:
upval = delta
from pandas_datareader import data as pdr
import yfinance as yf
yf.pdr_override() # Override yfinance API in order to use Pandas DataReader
import numpy as np
import os
end = datetime.date.today()
end = datetime.datetime(end.year, end.month,
end.day) # to midnight of that day
#Going back 3 years ensures that we can accumulate a 200 day MA for the most recent 100 days
#These are isolated after attaching the 200 day MA
start = (end - relativedelta(years=3))
# return list of Dow tickers
dow_tickers = pd.Series(stock_info.tickers_dow()).unique()
sp_tickers = pd.Series(stock_info.tickers_sp500()).unique()
nasdaq_tickers = pd.Series(stock_info.tickers_nasdaq()).unique()
all_tickers = np.unique(np.hstack((nasdaq_tickers, dow_tickers, sp_tickers)))
indicators = [
'dma', 'volume_delta', 'close_12_ema', 'close_26_ema', 'macd',
'macd_9_ema', 'macds', 'macdh'
]
# Functions
# Returns the OCHLV for a stock over a 10 year period
def get_ticker_data(ticker):
'''Takes a list of stock symbols and appends the open, close,
high, low and trading day data from Yahoo Finance for that
import matplotlib.pyplot as plt
from datetime import date
import yfinance as yf
import pandas as pd
from yahoo_fin import stock_info as si
import mplcursors
symbol1 = "AAPL"
stockOne = yf.Ticker(symbol1)
dailyData = pd.DataFrame(stockOne.history(period="1d", interval="1m"))['Open']
dailyData.index = dailyData.index.strftime("%H:%M:%S")
gainers = pd.DataFrame(si.get_day_gainers())[['Price (Intraday)', '% Change']]
gainers.index = pd.DataFrame(si.get_day_gainers())['Symbol']
losers = pd.DataFrame(si.get_day_losers())[['Price (Intraday)', '% Change']]
losers.index = pd.DataFrame(si.get_day_losers())['Symbol']
active = pd.DataFrame(
si.get_day_most_active())[['Price (Intraday)', '% Change']]
active.index = pd.DataFrame(si.get_day_most_active())['Symbol']
print(pd.DataFrame(si.tickers_dow()))
days = 0
constDate = str("0001") + "-" + str("01") + "-" + str("01")
if args.days:
days = int(args.days)
if args.processes:
noOfProcesses = int(args.processes)
else:
noOfProcesses = 10
if args.filename:
fileName = args.filename + ".xlsx"
else:
fileName = "insider_trading.xlsx"
if args.stocklist:
l1 = args.stocklist.split(',')
else:
l1 = si.tickers_sp500() + si.tickers_nasdaq() + si.tickers_other() + si.tickers_dow()
l1 = list(set(l1))
l1.sort()
l1.pop(0)
tickerList = []
for i,ticker in enumerate(l1):
if not re.search(r"\$", ticker):
tickerList.append(ticker)
l1 = tickerList
if args.insidersales:
value = int(args.insidersales)
if value > 1:
print("ERROR insider sales value can only be 0 or 1 and you have passed %d" %(value))
sys.exit(1)
else:
insiderSales = value
def get_dow_tickers():
return si.tickers_dow()
def query_tickers(industry):
# load tickers
dow = si.tickers_dow()
dow_set = set(dow)
if industry == "Business & Commerce":
companies = [
"AMZN", "TSLA", "HD", "LOW", "MCD", "SBUX", "NKE", "WMT", "COST",
"PG", "PEP", "KO"
]
companies_set = set(companies)
non_dupes = list(companies_set - dow_set)
tickers = dow + non_dupes
elif industry == "Healthcare Professions & Pharmacology Programs":
companies = [
"JNJ", "MRK", "ABBV", "PFE", "LLY", "AMGN", "GILD", "ABT", "TMO",
"DHR", "REGN", "UNH"
]
companies_set = set(companies)
non_dupes = list(companies_set - dow_set)
tickers = dow + non_dupes
elif industry == "Biological & Biomedical Sciences":
companies = [
"AMZN", "TSLA", "HD", "LOW", "MCD", "SBUX", "NKE", "WMT", "COST",
"PG", "PEP", "KO"
]
companies_set = set(companies)
non_dupes = list(companies_set - dow_set)
tickers = dow + non_dupes
elif industry == "Engineering & Technology":
companies = [
"AMAT", "TSLA", "ADBE", "CSCO", "NVDA", "AVGO", "IBM", "AMD",
"TXN", "QCOM", "INTC", "CRM"
]
companies_set = set(companies)
non_dupes = list(companies_set - dow_set)
tickers = dow + non_dupes
elif industry == "Energy & Infrastructure":
companies = [
"XOM", "CVX", "COP", "EOG", "PSX", "MPC", "SPG", "NEE", "DUK",
"LIN", "APD", "SRE"
]
companies_set = set(companies)
non_dupes = list(companies_set - dow_set)
tickers = dow + non_dupes
elif industry == "Communication, Journalism & Related Programs":
companies = [
"GOOGL", "FB", "T", "VZ", "TMUS", "ATVI", "NFLX", "DIS", "CMCSA",
"CHTR", "EA", "LYV"
]
companies_set = set(companies)
non_dupes = list(companies_set - dow_set)
tickers = dow + non_dupes
else:
tickers = dow
yahoo_recommendations = []
# call request from yahoo
for each_ticker in tickers:
print("Now Querying Recommendation for: " + each_ticker)
query_a = 'https://query2.finance.yahoo.com/v10/finance/quoteSummary/'
query_b = '?formatted=true&crumb=swg7qs5y9UP&lang=en-US®ion=US&' \
'modules=upgradeDowngradeHistory,recommendationTrend,' \
'financialData,earningsHistory,earningsTrend,industryTrend&' \
'corsDomain=finance.yahoo.com'
request_url = query_a + each_ticker + query_b
response = requests.get(request_url)
# if response failed
if not response.ok:
recommendation = 0
# response success
try:
result = response.json()['quoteSummary']['result'][0]
recommendation = result['financialData']['recommendationMean'][
'fmt']
except:
recommendation = 0
yahoo_recommendations.append(recommendation)
# converting to a pandas dataframe
data = {'Ticker': tickers, 'Recommendations': yahoo_recommendations}
df = pd.DataFrame(data)
df['Recommendations'] = pd.to_numeric(df['Recommendations'])
# sort and filter dataframe
df = df[df.Recommendations != 0]
df.sort_values(by=['Recommendations'], ascending=True)
# filter based on recommendation value
df_buy = df[df.Recommendations <= 1.5]
df_sell = df[df.Recommendations >= 4.5]
df_hold = df[df.Recommendations == 3]
# combine dataframes (for experienced investor who understands buys/sells/holds)
df_final = pd.concat([df_hold, df_buy, df_sell])
df_final.reset_index(level=0, inplace=True)
if df_final.empty:
df_buy = df[df.Recommendations <= 2]
df_sell = df[df.Recommendations >= 4]
df_hold = df[df.Recommendations == 3]
df_final = pd.concat([df_hold, df_buy, df_sell])
df_final.reset_index(level=0, inplace=True)
return df_final
print(80*'=')
print('Choose the index analysis:Our analysis will be made on stocks composites of index you want,type:(DOW has the smallest index with 30 components)')
print('SP500 : for S&P 500 composites')
print('DOW : for DOW JONES composites')
print('NASDAQ : for NASDAQ composites')
print(80*'=')
print('What is your choice?')
stocklist=input('NASDAQ/DOW/SP500 : ')
while stocklist!='NASDAQ' and stocklist!='DOW' and stocklist!='SP500' :
print('Please choose the right option')
stocklist=input()
if stocklist=='NASDAQ':
stocklist=si.tickers_nasdaq()
elif stocklist=='DOW':
stocklist=si.tickers_dow()
else:
stocklist=si.tickers_sp500()
start_date=date.today()-timedelta(days=360)
end_date=date.today()
print('Do you want to use the dividend yields or not(Y/N)?')
yn=input()
while yn!='Y' and yn!='N':
print('You can type Y or N')
yn=input()
print('Do you want to use the pricing for American Options or European ones?(type A or E)')
opt=input('You can type A or E : ')
while opt!='A' and opt!='E':
import pandas as pd from sklearn.cluster import KMeans from math import sqrt import pylab as pl import numpy as np import yfinance as yf import datetime as dt import requests from pandas_datareader import data as pdr from yahoo_fin import stock_info as si #Loading the data yf.pdr_override() stocks = si.tickers_dow() stocks = stocks[10:30] start = dt.datetime(2010, 1, 1) now = dt.datetime.now() data = pdr.get_data_yahoo(stocks, start, now)['Close'] #Calculating annual mean returns and variances returns = data.pct_change().mean() * 252 variance = data.pct_change().std() * sqrt(252) returns.columns = ["Returns"] variance.columns = ["Variance"] #Concatenating the returns and variances into a single data-frame ret_var = pd.concat([returns, variance], axis=1).dropna() ret_var.columns = ["Returns", "Variance"] X = ret_var.values #Converting ret_var into nummpy array
