def getTrending(self):
trending = []
k = 0
retry = 0
maxRetries = 3
while k < len(self.bySymbol.keys()):
ticker = self.bySymbol.keys()[k]
try:
sData = Share(ticker)
sData.get_avg_daily_volume()
avgVolume = float(sData.get_avg_daily_volume())
pVolume = float(sData.get_volume())
sdVolume = (avgVolume)**0.5
trendingP = (pVolume - avgVolume) / sdVolume
trending.append((ticker, trendingP))
k += 1
except:
time.sleep(0.05)
retry += 1
if retry >= maxRetries:
retry = 0
k += 1
trending.sort(key=lambda x: x[1], reverse=True)
trending = [s for s in trending if s[1] > 0]
return trending
def collect_stock_data(symbol):
""" Collect stock data for stock with symbol symbol
:param symbol: symbol of stock to collect data for
:return: dictionary containing stock data
"""
stock_data = dict()
stock = Share(symbol)
# check if symbol was for a valid stock
name = stock.get_name()
if name == 'N/A':
return None
stock_data['symbol'] = symbol
stock_data['name'] = name
# get all data between today and start of 21st century
start_date = time.strftime("2000-01-01")
end_date = time.strftime("%Y-%m-%d")
stock_data['historical_data'] = stock.get_historical(start_date, end_date)
# get dividend information
stock_data['dividend_per_share'] = stock.get_dividend_share()
stock_data['dividend_yield'] = stock.get_dividend_yield()
# get volume information
stock_data['avg_daily_volume'] = stock.get_avg_daily_volume()
# primary key is the stock's symbol
stock_data['_id'] = symbol
return stock_data
def data_frame_companies_amount(list_companies,porcentaje_volumnen_diario,max_var_pvd):
# Es una funcion que toma una lista de empresas (codificadas por yahoo.finance), el porcentaje (tanto por uno)
# sobre el volumen diario a considerar y la maxima variacion en porcentaje (tanto por uno) sobre este porcentaje.
list_index=["ask5","ask4","ask3","ask2","ask1","bid1","bid2","bid3","bid4","bid5"]
companies_amount=pd.DataFrame(index=list_index)
for i in list_companies:
company = Share(i)
volume=company.get_volume()
cantidad_per_ba=float(company.get_avg_daily_volume())*porcentaje_volumnen_diario
num=cantidad_per_ba*max_var_pvd # variacion maxima respecto al 1% del volumen diario
vec_list_amount=[]
for h in range(0,len(list_index)):
vec_list_amount.append(round(cantidad_per_ba+np.random.randint(-num,num,1)))
vec_amount=np.array(vec_list_amount)
companies_amount[i]=vec_amount
return companies_amount
def metricsForSector(self,
Sector,
screenParam=['avgVolume'],
screenParamRange=(float("-inf"), float("inf"))):
outputData = []
for stock in self.bySector[Sector]:
try:
working = stock
sData = Share(stock[0])
screenQ = (type(screenParam) == list)
if 'avgVolume' in screenParam:
avgVolume = sData.get_avg_daily_volume()
if (screenParamRange[0] <= float(avgVolume) <=
screenParamRange[1]) or screenQ:
working.append(avgVolume)
else:
working = None
if 'mrkCap' in screenParam:
mrkCap = sData.get_market_cap()
if mrkCap[-1] == 'B':
amrkCap = float(mrkCap[:-1]) * 1000000000
if mrkCap[-1] == 'M':
amrkCap = float(mrkCap[:-1]) * 1000000
if (screenParamRange[0] <= amrkCap <=
screenParamRange[1]) or screenQ:
working.append(amrkCap)
else:
working = None
outputData.append(working)
except:
pass
return outputData
def set_ETF_data():
etf_data = []
for index, etf_symbol in enumerate(settings.ETF_MASTER_LIST):
etf_dict = {
'model': 'portfolio.ETF',
'pk': index + 1,
'fields': {},
}
fund = Share(etf_symbol)
fields = {
'name': fund.get_name(),
'symbol': etf_symbol,
'last_trade': fund.get_price(),
'dividend_yield': fund.get_dividend_yield(),
'absolute_change': fund.get_change(),
'percentage_change': fund.get_percent_change(),
'year high': fund.get_year_high(),
'year low': fund.get_year_low(),
'50 day moving average': fund.get_50day_moving_avg(),
'200 day moving average': fund.get_200day_moving_avg(),
'average_daily_volume': fund.get_avg_daily_volume()
}
etf_dict['fields'] = fields
etf_data.append(etf_dict)
json_data = json.dumps(etf_data)
# print(json_data)
output_dict = [y for y in etf_data if y['fields']['dividend_yield'] > 1]
output_dict = [
x for x in output_dict if x['fields']['average_daily_volume'] > 100000
]
output_dict = [
z for z in output_dict
if z['fields']['200 day moving average'] < z['fields']['last_trade']
]
sorted_list = sorted(output_dict,
key=lambda k: k['fields']['dividend_yield'],
reverse=True)
for etf in sorted_list[:5]:
ETF.objects.create(
portfolio=Portfolio.objects.get(pk=1),
name=etf['fields']['name'],
symbol=etf['fields']['symbol'],
investment_style=1,
last_trade=etf['fields']['last_trade'],
dividend_yield=etf['fields']['dividend_yield'],
absolute_change=etf['fields']['absolute_change'],
percentage_change=etf['fields']['percentage_change'],
currency='USD',
last_updated=timezone.now())
def stock_summary(request, symbol=None):
if symbol == None:
symbol = request.POST['symbol']
current_stock = Stock()
stock = Share(symbol)
current_stock.symbol = symbol.upper()
current_stock.price = stock.get_price()
current_stock.change = stock.get_change()
current_stock.volume = stock.get_volume()
current_stock.prev_close = stock.get_prev_close()
current_stock.stock_open = stock.get_open()
current_stock.avg_daily_volume = stock.get_avg_daily_volume()
current_stock.stock_exchange = stock.get_stock_exchange()
current_stock.market_cap = stock.get_market_cap()
current_stock.book_value = stock.get_book_value()
current_stock.ebitda = stock.get_ebitda()
current_stock.dividend_share = stock.get_dividend_share()
current_stock.dividend_yield = stock.get_dividend_yield()
current_stock.earnings_share = stock.get_earnings_share()
current_stock.days_high = stock.get_days_high()
current_stock.days_low = stock.get_days_low()
current_stock.year_high = stock.get_year_high()
current_stock.year_low = stock.get_year_low()
current_stock.fifty_day_moving_avg = stock.get_50day_moving_avg()
current_stock.two_hundred_day_moving_avg = stock.get_200day_moving_avg()
current_stock.price_earnings_ratio = stock.get_price_earnings_ratio()
current_stock.price_earnings_growth_ratio = stock.get_price_earnings_growth_ratio()
current_stock.price_sales = stock.get_price_sales()
current_stock.price_book = stock.get_price_book()
current_stock.short_ratio = stock.get_short_ratio()
date_metrics = []
url = 'http://chartapi.finance.yahoo.com/instrument/1.0/'+symbol+'/chartdata;type=quote;range=1y/csv'
page = urllib2.urlopen(url).read()
pagebreaks = page.split('\n')
for line in pagebreaks:
items = line.split(',')
if 'Company-Name:' in line:
current_stock.company_name = line[13:len(line)]
current_stock.save()
if 'values' not in items:
if len(items)==6:
hd = HistoricalData(
stock_id = Stock.objects.get(id=int(current_stock.id)).id,
date = items[0][4:6]+'/'+items[0][6:9]+'/'+items[0][0:4],
close = items[1][0:(len(items[1])-2)],
high = items[2][0:(len(items[2])-2)],
price_open = items[3][0:(len(items[3])-2)],
low = items[4][0:(len(items[4])-2)],
volume = items[5][0:-6]+","+items[5][-6:-3]+","+items[5][-3:len(items[5])])
hd.save()
date_metrics.append(hd)
del date_metrics[0]
return render(request, "stock_summary.html", {'current_stock': current_stock, 'date_metrics': date_metrics})
def get_stock_info(ticker):
temp_share = Share(ticker)
real_price = temp_share.get_price()
adj_price = (float(temp_share.get_open()) + float(temp_share.get_close()) +
float(temp_share.get_high()) +
float(temp_share.get_low())) / 4
real_vol = temp_share.get_volume()
avg_vol = temp_share.get_avg_daily_volume()
avg_50_day = temp_share.get_50day_moving_avg()
avg_200_day = temp_share.get_200day_moving_avg()
return real_price, adj_price, real_vol, avg_vol, avg_50_day, avg_200_day
def getAllStockData(ticker):
'''Get a few random tickers.'''
stock = Share(ticker)
stock.refresh()
data = {
'name': stock.get_name(),
'price': stock.get_price(),
'change': stock.get_change(),
'volume': stock.get_volume(),
'prev_close': stock.get_prev_close(),
'open': stock.get_open(),
'avg_daily_volume': stock.get_avg_daily_volume(),
'stock_exchange': stock.get_stock_exchange,
'market_cap': stock.get_market_cap(),
'book_value': stock.get_book_value(),
'ebitda': stock.get_ebitda(),
'dividend_share': stock.get_dividend_share(),
'dividend_yield': stock.get_dividend_yield(),
'earnings_share': stock.get_earnings_share(),
'days_high': stock.get_days_high(),
'days_low': stock.get_days_low(),
'year_high': stock.get_year_high(),
'year_low': stock.get_year_low(),
'50day_moving_avg': stock.get_50day_moving_avg(),
'200day_moving_avg': stock.get_200day_moving_avg(),
'price_earnings_ratio': stock.get_price_earnings_ratio(),
'price_earnings_growth_ratio': stock.get_price_earnings_growth_ratio(),
'get_price_sales': stock.get_price_sales(),
'get_price_book': stock.get_price_book(),
'get_short_ratio': stock.get_short_ratio(),
'trade_datetime': stock.get_trade_datetime(),
'percent_change_from_year_high': stock.get_percent_change_from_year_high(),
'percent_change_from_year_low': stock.get_percent_change_from_year_low(),
'change_from_year_low': stock.get_change_from_year_low(),
'change_from_year_high': stock.get_change_from_year_high(),
'percent_change_from_200_day_moving_average': stock.get_percent_change_from_200_day_moving_average(),
'change_from_200_day_moving_average': stock.get_change_from_200_day_moving_average(),
'percent_change_from_50_day_moving_average': stock.get_percent_change_from_50_day_moving_average(),
'change_from_50_day_moving_average': stock.get_change_from_50_day_moving_average(),
'EPS_estimate_next_quarter': stock.get_EPS_estimate_next_quarter(),
'EPS_estimate_next_year': stock.get_EPS_estimate_next_year(),
'ex_dividend_date': stock.get_ex_dividend_date(),
'EPS_estimate_current_year': stock.get_EPS_estimate_current_year(),
'price_EPS_estimate_next_year': stock.get_price_EPS_estimate_next_year(),
'price_EPS_estimate_current_year': stock.get_price_EPS_estimate_current_year(),
'one_yr_target_price': stock.get_one_yr_target_price(),
'change_percent_change': stock.get_change_percent_change(),
'divended_pay_date': stock.get_dividend_pay_date(),
'currency': stock.get_currency(),
'last_trade_with_time': stock.get_last_trade_with_time(),
'days_range': stock.get_days_range(),
'years_range': stock.get_year_range()
}
return data
def filter_good_candidates(self, good_candidates):
"""
Filter all of the matching candidates by certain parameters. Right now, specifically
filter out all low volume stocks. Low volume limit is 500,000/day. Could be adjusted
"""
filtered_tickers = []
for ticker in good_candidates:
# Filter duplicates. This happens from time to time
if ticker in filtered_tickers:
continue
print "ticker: %s" % ticker
# Try to load the share object. If you can't after a certain
# number of retries, just continue and skip the ticker
retries = 0
failure = False
while True:
try:
time.sleep(0.25)
share_object = Share(ticker)
except Exception:
if retries > 5:
failure = True
break
retries = retries + 1
continue
break
if failure is True:
continue
# Filter by volume
average_volume = share_object.get_avg_daily_volume()
# If the average volume can't be found, just continue
try:
int(average_volume)
except TypeError:
continue
if int(average_volume) >= LOW_VOLUME_LIMIT:
filtered_tickers.append(ticker)
# Add any other filtering conditions here!!!
return filtered_tickers
def test_filter_stocks(self):
start, end = get_time_period()
tickers = self.get_fifty_random_tickers()
tested = 0
for ticker in tickers:
if tested >= 10:
break
try:
s = Share(ticker)
data = s.get_historical(end, start)
except:
continue
tested += 1
if len(data) < MIN_DATA_LEN or data[0]['Date'] == last_trading_day:
continue
if not data:
self.assertTrue(filter_stocks(s, data))
elif data[0]['Close'] < 1:
self.assertTrue(filter_stocks(s, data))
elif not s.get_market_cap():
self.assertTrue(filter_stocks(s, data))
elif _parse_market_cap_string(s.get_market_cap()) < float(
getenv('MARKET_CAP_MIN',
FILTER_DEFAULTS['MARKET_CAP_MIN'])):
self.assertTrue(filter_stocks(s, data))
elif not s.get_price_earnings_ratio():
self.assertTrue(filter_stocks(s, data))
elif float(s.get_price_earnings_ratio()) >= float(getenv('PE_MAX', FILTER_DEFAULTS['PE_MAX'])) or \
float(s.get_price_earnings_ratio()) <= float(getenv('PE_MIN', FILTER_DEFAULTS['PE_MIN'])):
self.assertTrue(filter_stocks(s, data))
elif not s.get_avg_daily_volume() or float(
s.get_avg_daily_volume()) >= float(
getenv('VOLUME_MIN', FILTER_DEFAULTS['VOLUME_MIN'])):
self.assertTrue(filter_stocks(s, data))
elif (float(s.get_year_high()) * .99) <= float(data[0]['High']):
self.assertTrue(filter_stocks(s, data))
else:
self.assertFalse(filter_stocks(s, data))
def rec(p):
yahoo = Share(p)
a = yahoo.get_prev_close()
b = yahoo.get_year_high()
c = yahoo.get_year_low()
d = yahoo.get_open()
e = yahoo.get_ebitda()
f = yahoo.get_market_cap()
g = yahoo.get_avg_daily_volume()
h = yahoo.get_dividend_yield()
i = yahoo.get_earnings_share()
j = yahoo.get_days_low()
k = yahoo.get_days_high()
l = yahoo.get_50day_moving_avg()
m = yahoo.get_200day_moving_avg()
n = yahoo.get_price_earnings_ratio()
o = yahoo.get_price_earnings_growth_ratio()
print p
print "Previous Close: ", a
print "Year High", b
print "Year Low", c
print "Open:", d
print "EBIDTA", e
print "Market Cap", f
print "Average Daily Volume", g
print "Dividend Yield", h
print "Earnings per share", i
print "Days Range:", j, "-", k
print "50 Days Moving Average", l
print "200 Days Moving Average", m
print "Price Earnings Ratio", n
print "Price Earnings Growth Ratio", o
import MySQLdb
db = MySQLdb.connect(host="127.0.0.1",
user="******",
passwd="1111",
db="stocks",
local_infile=1)
cur = db.cursor()
cur.execute(
"""
INSERT INTO stockapp_info (symbol, prev_close, year_high, year_low, open_price , ebidta, market_cap, avg_daily_vol , dividend_yield, eps , days_low ,days_high, moving_avg_50, moving_avg_200, price_earnings_ratio, price_earnings_growth_ratio)
VALUES
(%s, %s, %s, %s, %s, %s, %s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
""", (p, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
db.commit()
cur.close()
def get_price_YAHOO(ticker):
#for ticker in list_of_symbols:
try:
from yahoo_finance import Share
yahoo = Share(ticker)
yahoo.refresh()
price_finance = yahoo.get_price()
print("IN->", ticker)
print("Open -> ", yahoo.get_open())
print("Current Price -> ", yahoo.get_price())
print("Ave Volume -> ", yahoo.get_avg_daily_volume())
print("Volume -> ", yahoo.get_volume())
print("Time -> ", yahoo.get_trade_datetime())
return float(price_finance)
except:
get_price_YAHOO(ticker)
def get_company_info(ticker):
try:
s = Share(ticker)
data = {
'Market_cap': s.get_market_cap(),
'Average_volume': s.get_avg_daily_volume(),
'EPS': s.get_earnings_share(),
'Short_ratio': s.get_short_ratio(),
'PE': s.get_price_earnings_ratio(),
'PEG': s.get_price_earnings_growth_ratio(),
}
return DataFetcher._extract_company_info(data)
except YQLQueryError:
logger.error("Company info not found for {}".format(ticker))
except Exception as e:
logger.error("Unexpected error occured: {}".format(e))
return {}
def get_company_info(ticker):
try:
s = Share(ticker)
data = {
'Market_cap': s.get_market_cap(),
'Average_volume': s.get_avg_daily_volume(),
'EPS': s.get_earnings_share(),
'Short_ratio': s.get_short_ratio(),
'PE': s.get_price_earnings_ratio(),
'PEG': s.get_price_earnings_growth_ratio(),
}
return DataFetcher._extract_company_info(data)
except YQLQueryError:
logger.error("Company info not found for {}".format(ticker))
except Exception as e:
logger.error("Unexpected error occured: {}".format(e))
return {}
def rec(p):
yahoo = Share(p)
a=yahoo.get_prev_close()
b=yahoo.get_year_high()
c=yahoo.get_year_low()
d=yahoo.get_open()
e=yahoo.get_ebitda()
f=yahoo.get_market_cap()
g=yahoo.get_avg_daily_volume()
h=yahoo.get_dividend_yield()
i=yahoo.get_earnings_share()
j=yahoo.get_days_low()
k=yahoo.get_days_high()
l=yahoo.get_50day_moving_avg()
m=yahoo.get_200day_moving_avg()
n=yahoo.get_price_earnings_ratio()
o=yahoo.get_price_earnings_growth_ratio()
print p
print "Previous Close: ",a
print "Year High",b
print "Year Low",c
print "Open:",d
print "EBIDTA",e
print "Market Cap",f
print "Average Daily Volume",g
print "Dividend Yield",h
print "Earnings per share",i
print "Days Range:", j ,"-",k
print "50 Days Moving Average",l
print "200 Days Moving Average",m
print"Price Earnings Ratio", n
print"Price Earnings Growth Ratio",o
import MySQLdb
db = MySQLdb.connect(host="127.0.0.1", user="******",passwd="1111", db="stocks",local_infile = 1)
cur=db.cursor()
cur.execute ("""
INSERT INTO stockapp_info (symbol, prev_close, year_high, year_low, open_price , ebidta, market_cap, avg_daily_vol , dividend_yield, eps , days_low ,days_high, moving_avg_50, moving_avg_200, price_earnings_ratio, price_earnings_growth_ratio)
VALUES
(%s, %s, %s, %s, %s, %s, %s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
""", (p,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o))
db.commit()
cur.close()
def get_symbol_yahoo_stats_yql(symbols, exclude_name=False):
"""
Get the symbols' basic statistics from Yahoo Finance.
Input:
symbols - a list of symbol strings, e.g. ['AAPL']
Output: stats in Pandas DataFrame.
This function is ported from pandas_datareader/yahoo/components.py
"""
sym_list = str2list(symbols)
if sym_list == None:
return DataFrame()
# Yahoo Finance tags, refer to http://www.financialwisdomforum.org/gummy-stuff/Yahoo-data.htm
tags = ['Symbol']
if not exclude_name:
tags += ['Name']
tags += ['Exchange', 'MarketCap', 'Volume', 'AverageDailyVolume', 'BookValue', 'P/E', 'PEG', 'Price/Sales',
'Price/Book', 'EBITDA', 'EPS', 'EPSEstimateNextQuarter', 'EPSEstimateCurrentYear', 'EPSEstimateNextYear',
'OneyrTargetPrice', 'PriceEPSEstimateCurrentYear', 'PriceEPSEstimateNextYear', 'ShortRatio',
'Dividend/Share', 'DividendYield', 'DividendPayDate', 'ExDividendDate']
lines = []
for sym in sym_list:
stock = Share(sym)
line = [sym]
if not exclude_name:
line += [stock.get_name()]
line += [stock.get_stock_exchange(), str2num(stock.get_market_cap(), m2b=True),
str2num(stock.get_volume()), str2num(stock.get_avg_daily_volume()), str2num(stock.get_book_value()),
str2num(stock.get_price_earnings_ratio()), str2num(stock.get_price_earnings_growth_ratio()),
str2num(stock.get_price_sales()), str2num(stock.get_price_book()), str2num(stock.get_ebitda()),
str2num(stock.get_earnings_share()), str2num(stock.get_EPS_estimate_next_quarter()),
str2num(stock.get_EPS_estimate_current_year()), str2num(stock.get_EPS_estimate_next_year()),
str2num(stock.get_one_yr_target_price()), str2num(stock.get_price_EPS_estimate_current_year()),
str2num(stock.get_price_EPS_estimate_next_year()), str2num(stock.get_short_ratio()),
str2num(stock.get_dividend_share()), str2num(stock.get_dividend_yield()), stock.get_dividend_pay_date(),
stock.get_ex_dividend_date()]
lines.append(line)
stats = DataFrame(lines, columns=tags)
stats = stats.drop_duplicates()
stats = stats.set_index('Symbol')
return stats
def selectStock(stocks):
'''
select the stock with today's trading volume at least 6 fold higher than
average historical trading volume
'''
start_time = time()
resultStock = {}
count = 0
num = 0
for symb in stocks.keys():
try:
stock = Share(symb)
vol = int(stock.get_volume())
daily_avg_vol = int(stock.get_avg_daily_volume())
price = float(stock.get_price())
prevPrice = float(stock.get_prev_close())
avg_50day = float(stock.get_50day_moving_avg())
avg_200day = float(stock.get_200day_moving_avg())
except (TypeError, AttributeError):
continue
num += 1
volRatio = vol / daily_avg_vol
print num, stocks[symb][0], volRatio
if volRatio > 6 and price > prevPrice and price > avg_50day:
count += 1
stocks[symb].extend([
vol, daily_avg_vol, volRatio, price, prevPrice, avg_50day,
avg_200day,
stock.get_price_earnings_ratio(),
stock.get_price_book(),
stock.get_short_ratio(),
stock.get_dividend_yield()
])
resultStock = {
symb: stocks[symb]
for symb in stocks.keys() if len(stocks[symb]) > 1
}
print '{} stock(s) has marvelous volume'.format(count)
print 'total time of running: {} seconds'.format(time() - start_time)
return resultStock
def main():
# this adds commas to all numbers greater than one thousand
locale.setlocale(locale.LC_ALL, 'en_US')
# if statement that checks for args. error/help message will appear if no args
if (len(sys.argv) == 1):
print "\nPlease supply one or more tickers. Example: python stephan_s_stock_quote.py GOOG\n"
else:
for counter in range(1, len(sys.argv)):
# this is where we fetch our stocks from
y = Share(sys.argv[counter])
# this is the output along with a message regarding the CSV file
print "\nSymbol: " + str(sys.argv[counter])
print "Company Name: " + str(y.get_name())
print "Market Capitalization: $" + str(y.get_market_cap())
print "Earnings Per Share: $" + str(
locale.format(
"%d", float(y.get_earnings_share()), grouping=True))
print "P/E Ratio: " + str(y.get_price_earnings_ratio())
print "Average Volume: " + str(
locale.format(
"%d", float(y.get_avg_daily_volume()), grouping=True))
print "Today's Volume: " + str(
locale.format("%d", float(y.get_volume()), grouping=True))
print "Today's Closing Price: $" + str(y.get_price())
print "Percent Change: " + str(y.get_percent_change()) + "\n"
print "A CSV file of your selected stock tickers has been downloaded to your computer under the name 'stocks.csv'. " + "\n"
print "The CSV file will be downloaded to the same folder that this program was stored in." + "\n"
except: pass try: russell3000.set_value(s,'Change',shy.get_change()) except: pass try: russell3000.set_value(s,'Volume',shy.get_volume()) except: pass try: russell3000.set_value(s,'Open',shy.get_open()) except: pass try: russell3000.set_value(s,'Average daily volume',shy.get_avg_daily_volume()) except: pass try: russell3000.set_value(s,'Market cap',shy.get_market_cap()) except: pass try: russell3000.set_value(s,'Book value',shy.get_book_value()) except: pass try: russell3000.set_value(s,'Ebitda',shy.get_ebitda()) except: pass try:
from yahoo_finance import Share, Currency
yahoo = Share('AAPL')
yahoo.refresh()
print yahoo.get_info()
print yahoo.get_avg_daily_volume()
print yahoo.get_stock_exchange()
print yahoo.get_book_value()
print yahoo.get_ebitda()
print yahoo.get_dividend_share()
print yahoo.get_price_earnings_ratio()
print yahoo.get_short_ratio()
print yahoo.get_price_book()
# f = open('nasdaqlisted.txt', 'r')
# print (f.readline())
# print (f.readline())
def stock_quote_get():
print(request.args.get('symbol'))
symbol = str(request.args.get('symbol'))
# get all the relevant data from the Yahoo Finance API
stock = Share(symbol)
stock_name = stock.get_name()
stock_symbol = stock.symbol
stock_price = stock.get_price()
stock_change = stock.get_change()
stock_change_pct = stock.get_percent_change()
prev_close = stock.get_prev_close()
open = stock.get_open()
day_range = stock.get_days_range()
year_range = stock.get_year_range()
volume = stock.get_volume()
avg_volume = stock.get_avg_daily_volume()
market_cap = stock.get_market_cap()
pe_ratio = stock.get_price_earnings_ratio()
eps = stock.get_earnings_share()
dividend = stock.get_dividend_share()
dividend_yld = stock.get_dividend_yield()
dividend_ex_date = stock.get_ex_dividend_date()
yr_target = stock.get_one_yr_target_price()
historical = stock.get_historical('2017-01-01',
date.isoformat(date.today()))
# put the data into the DynamoDB database
table = dynamodb.Table('Stocks')
response = table.put_item(
Item={
'symbol': symbol,
'date': date.isoformat(date.today()),
'prev_close': prev_close,
'open': open,
'day_range': day_range,
'year_range': year_range,
'volume': volume,
'avg_volume': avg_volume,
'market_cap': market_cap,
'pe_ratio': pe_ratio,
'eps': eps,
'dividend': dividend,
'dividend_yld': dividend_yld,
'dividend_ex_date': dividend_ex_date,
'yr_target': yr_target,
})
close_history = []
for point in historical:
close_date = point['Date']
close_date = int(
time.mktime(datetime.strptime(close_date, "%Y-%m-%d").timetuple()))
close_price = point['Adj_Close']
close_price = float(close_price)
close_history.append([close_date, close_price])
return render_template("stock/stock_detail.html",
stock_name=stock_name,
stock_symbol=stock_symbol,
stock_price=stock_price,
stock_change=stock_change,
stock_change_pct=stock_change_pct,
prev_close=prev_close,
open=open,
day_range=day_range,
year_range=year_range,
volume=volume,
avg_volume=avg_volume,
market_cap=market_cap,
pe_ratio=pe_ratio,
eps=eps,
dividend=dividend,
dividend_yld=dividend_yld,
dividend_ex_date=dividend_ex_date,
yr_target=yr_target,
close_history=close_history)
def on_message(self, message):
print_logger.debug("Received message: %s" % (message))
if "ValidateTicker" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed ticker validation request")
self.write_message("ValidationFailed:Malformed")
return
ticker = message[1]
if validate_ticker(ticker):
self.write_message("ValidationSucceeded:%s" % ticker)
print_logger.debug("Ticker was valid")
else:
self.write_message("ValidationFailed:%s" % ticker)
print_logger.debug("Ticker was bad")
return
elif "GetCompanyName" in message:
print_logger.debug("You got here")
message = message.split(":")
company_ticker = message[1]
company_name = get_company_title(company_ticker)
self.write_message("CompanyName:%s" % company_name)
elif "GetStockData" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Get ticker information
share_data = Share(ticker)
price = share_data.get_price()
percent_change = share_data.get_change()
previous_close = share_data.get_prev_close()
open_price = share_data.get_open()
volume = share_data.get_volume()
pe_ratio = share_data.get_price_earnings_ratio()
peg_ratio = share_data.get_price_earnings_growth_ratio()
market_cap = share_data.get_market_cap()
book_value = share_data.get_price_book()
average_volume = share_data.get_avg_daily_volume()
dividend_share = share_data.get_dividend_share()
dividend_yield = share_data.get_dividend_yield()
earnings_per_share = share_data.get_earnings_share()
ebitda = share_data.get_ebitda()
fifty_day_ma = share_data.get_50day_moving_avg()
days_high = share_data.get_days_high()
days_low = share_data.get_days_low()
year_high = share_data.get_year_high()
year_low = share_data.get_year_low()
two_hundred_day_ma = share_data.get_200day_moving_avg()
# Build a string to send to the server containing the stock data
share_string = "price:" + str(price) + "|"\
+ "percentChange:" + str(percent_change) + "|"\
+ "previousClose:" + str(previous_close) + "|"\
+ "openPrice:" + str(open_price) + "|"\
+ "volume:" + str(volume) + "|"\
+ "peRatio:" + str(pe_ratio) + "|"\
+ "pegRatio:" + str(peg_ratio) + "|"\
+ "marketCap:" + str(market_cap) + "|"\
+ "bookValue:" + str(book_value) + "|"\
+ "averageVolume:" + str(average_volume) + "|"\
+ "dividendShare:" + str(dividend_share) + "|"\
+ "dividendYield:" + str(dividend_yield) + "|"\
+ "earningsPerShare:" + str(earnings_per_share) + "|"\
+ "ebitda:" + str(ebitda) + "|"\
+ "50DayMa:" + str(fifty_day_ma) + "|"\
+ "daysHigh:" + str(days_high) + "|"\
+ "daysLow:" + str(days_low) + "|"\
+ "yearHigh:" + str(year_high) + "|"\
+ "yearLow:" + str(year_low) + "|"\
+ "200DayMa:" + str(two_hundred_day_ma) + "|"
self.write_message("StockData;%s" % (share_string))
print_logger.debug("Sending Message: StockData;%s" % (share_string))
elif "GetCompanyDesc" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
description = update_description_oneoff(ticker)
self.write_message("CompanyDescription:%s" % str(description))
elif "GetCompanyDividend" in message and "Record" not in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Grab the dividend data from dividata.com
dividend_url = "https://dividata.com/stock/%s/dividend" % ticker
# This should potentially be a
dividend_data = requests.get(dividend_url)
dividend_soup = BeautifulSoup(dividend_data.text, 'html5lib')
if len(dividend_soup.find_all("table")) > 0:
dividend_soup = dividend_soup.find_all("table")[0]
else:
dividend_soup = "<h3>No dividend history found.</h3>"
# Send this div up to the server
self.write_message("DividendHistoryData:" + str(dividend_soup))
elif "GetCompanyDividendRecord" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Get the dividend record html for the table and send it up
#dividend_record = strip_dividends(ticker, req_proxy)
#print_logger.debug("Writing message: " + str(dividend_record))
#self.write_message("DividendRecord:" + str(dividend_record))
elif "GetBollinger" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Switch into the tmp directory
old_dir = os.getcwd()
os.chdir(TEMP_DIR)
# Update the historical data for the ticker symbol
YAHOO_FINANCE_HISTORICAL_OBJECT.read_ticker_historical(ticker)
bands = BollingerBandStrategy(data_storage_dir="%s/historical_stock_data" % TEMP_DIR\
, ticker_file="%s/stock_list.txt" % TEMP_DIR, filtered_ticker_file=\
"%s/filtered_stock_list.txt" % TEMP_DIR)
# Save the graph so that we can show it on the website
bands.save_stock_chart(ticker, "%s" % TEMP_DIR)
# Also let the server know that we found an answer
result = bands.test_ticker(ticker)
if result is not None:
print_logger.debug("BB:GoodCandidate")
self.write_message("BB:GoodCandidate")
else:
print_logger.debug("BB:BadCandidate")
self.write_message("BB:BadCandidate")
elif "CheckRobinhoodLogin" in message:
print "HELLO WORLD!!! HELLO WORLD!!! HELLO WORLD!!!%s" % ROBINHOOD_INSTANCE
if ROBINHOOD_INSTANCE.is_logged_in() is True:
self.write_message("RobinhoodLoggedIn:%s" % ROBINHOOD_INSTANCE.username)
else:
self.write_message("RobinhoodNotLoggedIn")
elif "GetPosition" in message:
ticker = message.replace("GetPosition:", "")
account_positions = ROBINHOOD_INSTANCE.get_position_history(active=True)
user_owns_stock = False
position_string = ""
for position in account_positions:
# Get data about the position, including current price.
position_data = requests.get(position["instrument"])
position_data = json.loads(position_data._content)
position.update(position_data)
if position["symbol"] != ticker:
continue
quote_data = requests.get(position["quote"]);
quote_data = json.loads(quote_data._content)
position.update(quote_data)
position_string = json.dumps(position)
user_owns_stock = True
if user_owns_stock is True:
self.write_message("Position:%s" % position_string)
else:
self.write_message("Position:None")
def on_message(self, message):
print_logger.debug("Received message: %s" % (message))
self.write_message("Test Message")
if "ValidateTicker" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed ticker validation request")
self.write_message("ValidationFailed:Malformed")
return
ticker = message[1]
# The file I have stored didn't end up being a good validation
# option as it does not contain a complete list of all
# securities. I have to acquire the data from yahoo
# finance anyway, so just use that. The Share function
# call will throw a NameError exception if the ticker doesn't exist
# isValid = current_stock_list.is_valid_stock(ticker)
isValid = True
try:
test = Share(str(ticker))
if test.get_price() is None:
isValid = False
except NameError:
isValid = False
if isValid:
self.write_message("ValidationSucceeded:%s" % ticker)
print_logger.debug("Ticker was valid")
else:
self.write_message("ValidationFailed:%s" % ticker)
print_logger.debug("Ticker was bad")
return
elif "GetCompanyName" in message:
print_logger.debug("You got here")
message = message.split(":")
company_ticker = message[1]
company_name = ""
try:
company_info="../task_1/google_search_program/cleaned_data/" + company_ticker + "/company_info"
company_name = " "
f = open(company_info, "r")
line = f.readlines()
company_name = line[0].split(",")
company_name = company_name[0]
company_name = company_name.title()
if '(' not in company_name:
company_name = company_name + " (%s)" % company_ticker
except Exception:
company_name = get_company_title_proxied(company_ticker)
self.write_message("CompanyName:%s" % company_name)
elif "ExecuteQuery" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed input query")
self.write_message("QueryResult:Error")
data = current_solr_object.issue_query(str(message[1]))
data = current_solr_object.recover_links(data)
final_string = "QueryResult"
for link in data:
final_string = final_string + ":" + str(link)
self.write_message(final_string)
elif "GetStockData" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Get ticker information
share_data = Share(ticker)
price = share_data.get_price()
percent_change = share_data.get_change()
previous_close = share_data.get_prev_close()
open_price = share_data.get_open()
volume = share_data.get_volume()
pe_ratio = share_data.get_price_earnings_ratio()
peg_ratio = share_data.get_price_earnings_growth_ratio()
market_cap = share_data.get_market_cap()
book_value = share_data.get_price_book()
average_volume = share_data.get_avg_daily_volume()
dividend_share = share_data.get_dividend_share()
dividend_yield = share_data.get_dividend_yield()
earnings_per_share = share_data.get_earnings_share()
ebitda = share_data.get_ebitda()
fifty_day_ma = share_data.get_50day_moving_avg()
days_high = share_data.get_days_high()
days_low = share_data.get_days_low()
year_high = share_data.get_year_high()
year_low = share_data.get_year_low()
two_hundred_day_ma = share_data.get_200day_moving_avg()
# Build a string to send to the server containing the stock data
share_string = "price:" + str(price) + "|"\
+ "percentChange:" + str(percent_change) + "|"\
+ "previousClose:" + str(previous_close) + "|"\
+ "openPrice:" + str(open_price) + "|"\
+ "volume:" + str(volume) + "|"\
+ "peRatio:" + str(pe_ratio) + "|"\
+ "pegRatio:" + str(peg_ratio) + "|"\
+ "marketCap:" + str(market_cap) + "|"\
+ "bookValue:" + str(book_value) + "|"\
+ "averageVolume:" + str(average_volume) + "|"\
+ "dividendShare:" + str(dividend_share) + "|"\
+ "dividendYield:" + str(dividend_yield) + "|"\
+ "earningsPerShare:" + str(earnings_per_share) + "|"\
+ "ebitda:" + str(ebitda) + "|"\
+ "50DayMa:" + str(fifty_day_ma) + "|"\
+ "daysHigh:" + str(days_high) + "|"\
+ "daysLow:" + str(days_low) + "|"\
+ "yearHigh:" + str(year_high) + "|"\
+ "yearLow:" + str(year_low) + "|"\
+ "200DayMa:" + str(two_hundred_day_ma) + "|"
self.write_message("StockData;%s" % (share_string))
print_logger.debug("Sending Message: StockData;%s" % (share_string))
elif "GetCompanyDesc" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Read in the company description
description = ""
try:
f = open("../task_1/google_search_program/cleaned_data/%s/company_description" % str(ticker), "r")
description = f.read()
except Exception:
# If the file does not exist, get the data manually
description = update_description_oneoff(ticker)
self.write_message("CompanyDescription:%s" % str(description))
elif "GetCompanyDividend" in message and "Record" not in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Grab the dividend data from dividata.com
dividend_url = "https://dividata.com/stock/%s/dividend" % ticker
# This should potentially be a
dividend_data = requests.get(dividend_url)
dividend_soup = BeautifulSoup(dividend_data.text, 'html5lib')
if len(dividend_soup.find_all("table")) > 0:
dividend_soup = dividend_soup.find_all("table")[0]
else:
dividend_soup = "<h3>No dividend history found.</h3>"
# Send this div up to the server
self.write_message("DividendHistoryData:" + str(dividend_soup))
elif "GetCompanyDividendRecord" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Get the dividend record html for the table and send it up
dividend_record = strip_dividends(ticker, req_proxy)
print_logger.debug("Writing message: " + str(dividend_record))
self.write_message("DividendRecord:" + str(dividend_record))
elif "GetBollinger" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Get the bollinger band history along with the 5 day moving average
close, lower_band, five_day_ma = calculate_bands(ticker)
last_5_days_5_day_ma = []
last_5_days_bb = []
last_5_days_close = []
for i in range(0, 5):
last_5_days_5_day_ma.append(five_day_ma[i])
last_5_days_bb.append(lower_band[i])
last_5_days_close.append(close[i])
condition_1 = False
condition_2 = False
# Condition 1: Has the stock price at close been below the lower bollinger band
# at market close within the last 5 days
for i in range(0, 5):
if last_5_days_close[i] < last_5_days_bb[i]:
condition_1 = True
# Condition 2: Has the current stock price been above the 5 day moving average sometime in the last 3 days
for i in range(0, 3):
if last_5_days_close[i] > last_5_days_5_day_ma[i]:
condition_2 = True
if condition_1 is True and condition_2 is True:
self.write_message("BB:GoodCandidate")
else:
self.write_message("BB:BadCandidate")
elif "GetSentiment" in message:
message = message.split(":")
if len(message) != 2:
print_logger.error("Malformed Message from Client")
return
ticker = message[1]
# Lists of sentiment based words
good_words = ["buy", "bull", "bullish", "positive", "gain", "gains", "up"]
bad_words = ["sell", "bear", "bearish", "negative", "loss", "losses", "down"]
DATA_DIRECTORY = "../task_1/google_search_program/cleaned_data/%s" % ticker.upper()
positive_file_stats = []
negative_file_stats = []
positive_files = 0
negative_files = 0
neutral_files = 0
trump_count = 0
files_examined = 0
for root, dirs, files in os.walk(DATA_DIRECTORY):
path = root.split(os.sep)
print((len(path) - 1) * '---', os.path.basename(root))
for file in files:
if "article" in file:
f = open('/'.join(path) + '/' + file)
title = f.readline()
article_text = " ".join(f.readlines())
if article_text.count("trump") > 0:
trump_count = trump_count + 1
positive_word_count = 0
negative_word_count = 0
files_examined = files_examined + 1
for word in good_words:
if word in article_text:
positive_word_count = positive_word_count + article_text.count(word)
print "Word: %s, %s" % (word, article_text.count(word))
for word in bad_words:
if word in article_text:
negative_word_count = negative_word_count + article_text.count(word)
if positive_word_count > negative_word_count:
positive_ratio = float(positive_word_count) / float(negative_word_count + positive_word_count)
if positive_ratio > 0.7:
positive_files = positive_files + 1
positive_file_stats.append((positive_word_count, negative_word_count))
else:
neutral_files = neutral_files + 1
elif positive_word_count == negative_word_count:
neutral_files = neutral_files + 1
else:
negative_ratio = float(negative_word_count) / float(negative_word_count + positive_word_count)
if negative_ratio > 0.7:
negative_files = negative_files + 1
negative_file_stats.append((positive_word_count, negative_word_count))
else:
neutral_files = neutral_files + 1
print_logger.debug("Sentiment:" + str(positive_files) + ":" + str(negative_files) +\
":" + str(neutral_files) + ":" + str(trump_count) + ":" + str(files_examined))
self.write_message("Sentiment:" + str(positive_files) + ":" + str(negative_files) +\
":" + str(neutral_files) + ":" + str(trump_count) + ":" + str(files_examined))
print "The CSV file will be downloaded to the same folder that this program was stored in." + "\n"
# code that creates the CSV file
with open('stocks.csv', 'w') as fp:
outputFile = csv.writer(fp)
data1 = [[
'Symbol', 'Company Name', 'Market Capitalization',
'Earnings Per Share', 'P/E Ratio', 'Average Volume', 'Today\'s Volume',
'Today\'s Closing Price', 'Percent Change'
]]
outputFile.writerows(data1)
for counter in range(1, len(sys.argv)):
y = Share(sys.argv[counter])
data2 = [[
str(sys.argv[counter]),
str(y.get_name()),
str(y.get_market_cap()),
str(y.get_earnings_share()),
str(y.get_price_earnings_ratio()),
str(y.get_avg_daily_volume()),
str(y.get_volume()),
str(y.get_price()),
str(y.get_percent_change())
]]
outputFile.writerows(data2)
if __name__ == '__main__':
main()
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
'''Creates basic geometry for GUI'''
MainWindow.setObjectName(_fromUtf8("MainWindow"))
MainWindow.setMinimumSize(QtCore.QSize(490, 400))
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("DK_icon.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
MainWindow.setWindowIcon(icon)
MainWindow.setTabShape(QtGui.QTabWidget.Rounded)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
self.btnPredictPrices = QtGui.QPushButton(self.centralwidget)
self.btnPredictPrices.setGeometry(QtCore.QRect(300, 330, 161, 23))
self.btnPredictPrices.setObjectName(_fromUtf8("btnPredictPrices"))
self.btnPredictPrices.clicked.connect(self.show_predictions)
self.btnPlotSymbol = QtGui.QPushButton(self.centralwidget)
self.btnPlotSymbol.setGeometry(QtCore.QRect(300, 90, 161, 23))
self.btnPlotSymbol.setObjectName(_fromUtf8("btnPlotSymbol"))
self.btnPlotSymbol.clicked.connect(self.display_plots)
self.leditEnterTickers = QtGui.QLineEdit(self.centralwidget)
self.leditEnterTickers.setGeometry(QtCore.QRect(30, 330, 241, 21))
self.leditEnterTickers.setObjectName(_fromUtf8("leditEnterTickers"))
self.deditStartDate = QtGui.QDateEdit(self.centralwidget)
self.deditStartDate.setGeometry(QtCore.QRect(30, 30, 110, 22))
self.deditStartDate.setAlignment(QtCore.Qt.AlignCenter)
self.deditStartDate.setDate(QtCore.QDate(2013, 1, 1))
self.deditStartDate.setCalendarPopup(True)
self.deditStartDate.setObjectName(_fromUtf8("deditStartDate"))
self.deditEndDate = QtGui.QDateEdit(self.centralwidget)
self.deditEndDate.setGeometry(QtCore.QRect(290, 30, 110, 22))
self.deditEndDate.setAlignment(QtCore.Qt.AlignCenter)
self.deditEndDate.setDate(QtCore.QDate(2017, 1, 1))
self.deditEndDate.setCalendarPopup(True)
self.deditEndDate.setObjectName(_fromUtf8("deditEndDate"))
self.labelStartDate = QtGui.QLabel(self.centralwidget)
self.labelStartDate.setGeometry(QtCore.QRect(150, 30, 111, 21))
self.labelStartDate.setObjectName(_fromUtf8("labelStartDate"))
self.labelEndDate = QtGui.QLabel(self.centralwidget)
self.labelEndDate.setGeometry(QtCore.QRect(410, 30, 51, 21))
self.labelEndDate.setObjectName(_fromUtf8("labelEndDate"))
self.leditPlotSymb = QtGui.QLineEdit(self.centralwidget)
self.leditPlotSymb.setGeometry(QtCore.QRect(30, 90, 241, 21))
self.leditPlotSymb.setObjectName(_fromUtf8("leditPlotSymb"))
self.dedit1stPDate = QtGui.QDateEdit(self.centralwidget)
self.dedit1stPDate.setGeometry(QtCore.QRect(30, 210, 110, 22))
self.dedit1stPDate.setAlignment(QtCore.Qt.AlignCenter)
self.dedit1stPDate.setDate(QtCore.QDate(2016, 12, 6))
self.dedit1stPDate.setCalendarPopup(True)
self.dedit1stPDate.setObjectName(_fromUtf8("dedit1stPDate"))
self.dedit2ndPDate = QtGui.QDateEdit(self.centralwidget)
self.dedit2ndPDate.setGeometry(QtCore.QRect(30, 240, 110, 22))
self.dedit2ndPDate.setAlignment(QtCore.Qt.AlignCenter)
self.dedit2ndPDate.setDate(QtCore.QDate(2016, 12, 7))
self.dedit2ndPDate.setCalendarPopup(True)
self.dedit2ndPDate.setObjectName(_fromUtf8("dedit2ndPDate"))
self.dedit3rdPDate = QtGui.QDateEdit(self.centralwidget)
self.dedit3rdPDate.setGeometry(QtCore.QRect(30, 270, 110, 22))
self.dedit3rdPDate.setAlignment(QtCore.Qt.AlignCenter)
self.dedit3rdPDate.setDate(QtCore.QDate(2016, 12, 8))
self.dedit3rdPDate.setCalendarPopup(True)
self.dedit3rdPDate.setObjectName(_fromUtf8("dedit3rdPDate"))
self.label1stPDate = QtGui.QLabel(self.centralwidget)
self.label1stPDate.setGeometry(QtCore.QRect(150, 210, 131, 21))
self.label1stPDate.setObjectName(_fromUtf8("label1stPDate"))
self.label3rdPDate = QtGui.QLabel(self.centralwidget)
self.label3rdPDate.setGeometry(QtCore.QRect(150, 270, 121, 21))
self.label3rdPDate.setObjectName(_fromUtf8("label3rdPDate"))
self.label2ndPDate = QtGui.QLabel(self.centralwidget)
self.label2ndPDate.setGeometry(QtCore.QRect(150, 240, 131, 21))
self.label2ndPDate.setObjectName(_fromUtf8("label2ndPDate"))
self.btnFundData = QtGui.QPushButton(self.centralwidget)
self.btnFundData.setGeometry(QtCore.QRect(300, 120, 161, 23))
self.btnFundData.setObjectName(_fromUtf8("btnFundData"))
self.btnFundData.clicked.connect(self.display_fund_data)
self.deditLastTDate = QtGui.QDateEdit(self.centralwidget)
self.deditLastTDate.setGeometry(QtCore.QRect(30, 180, 110, 22))
self.deditLastTDate.setAlignment(QtCore.Qt.AlignCenter)
self.deditLastTDate.setDate(QtCore.QDate(2016, 12, 5))
self.deditLastTDate.setCalendarPopup(True)
self.deditLastTDate.setObjectName(_fromUtf8("deditLastTDate"))
self.labelStartDate_6 = QtGui.QLabel(self.centralwidget)
self.labelStartDate_6.setGeometry(QtCore.QRect(150, 180, 91, 21))
self.labelStartDate_6.setObjectName(_fromUtf8("labelStartDate_6"))
self.sbox1stPDate = QtGui.QSpinBox(self.centralwidget)
self.sbox1stPDate.setGeometry(QtCore.QRect(290, 210, 42, 22))
self.sbox1stPDate.setAlignment(QtCore.Qt.AlignCenter)
self.sbox1stPDate.setMinimum(0)
self.sbox1stPDate.setProperty("value", 0)
self.sbox1stPDate.setObjectName(_fromUtf8("sbox1stPDate"))
self.dedit4thPDate = QtGui.QDateEdit(self.centralwidget)
self.dedit4thPDate.setGeometry(QtCore.QRect(30, 300, 110, 22))
self.dedit4thPDate.setAlignment(QtCore.Qt.AlignCenter)
self.dedit4thPDate.setDate(QtCore.QDate(2016, 12, 9))
self.dedit4thPDate.setCalendarPopup(True)
self.dedit4thPDate.setObjectName(_fromUtf8("dedit4thPDate"))
self.label4thPDate = QtGui.QLabel(self.centralwidget)
self.label4thPDate.setGeometry(QtCore.QRect(150, 300, 131, 21))
self.label4thPDate.setFrameShape(QtGui.QFrame.NoFrame)
self.label4thPDate.setObjectName(_fromUtf8("label4thPDate"))
self.label1stPDate_2 = QtGui.QLabel(self.centralwidget)
self.label1stPDate_2.setGeometry(QtCore.QRect(340, 210, 121, 21))
self.label1stPDate_2.setObjectName(_fromUtf8("label1stPDate_2"))
self.label2ndPDate_2 = QtGui.QLabel(self.centralwidget)
self.label2ndPDate_2.setGeometry(QtCore.QRect(340, 240, 121, 21))
self.label2ndPDate_2.setObjectName(_fromUtf8("label2ndPDate_2"))
self.sbox2ndPDate = QtGui.QSpinBox(self.centralwidget)
self.sbox2ndPDate.setGeometry(QtCore.QRect(290, 240, 42, 22))
self.sbox2ndPDate.setAlignment(QtCore.Qt.AlignCenter)
self.sbox2ndPDate.setMinimum(0)
self.sbox2ndPDate.setProperty("value", 0)
self.sbox2ndPDate.setObjectName(_fromUtf8("sbox2ndPDate"))
self.label3rdPDate_2 = QtGui.QLabel(self.centralwidget)
self.label3rdPDate_2.setGeometry(QtCore.QRect(340, 270, 121, 21))
self.label3rdPDate_2.setObjectName(_fromUtf8("label3rdPDate_2"))
self.sbox3rdPDate = QtGui.QSpinBox(self.centralwidget)
self.sbox3rdPDate.setGeometry(QtCore.QRect(290, 270, 42, 22))
self.sbox3rdPDate.setAlignment(QtCore.Qt.AlignCenter)
self.sbox3rdPDate.setMinimum(0)
self.sbox3rdPDate.setProperty("value", 0)
self.sbox3rdPDate.setObjectName(_fromUtf8("sbox3rdPDate"))
self.label4thPDate_2 = QtGui.QLabel(self.centralwidget)
self.label4thPDate_2.setGeometry(QtCore.QRect(340, 300, 121, 21))
self.label4thPDate_2.setObjectName(_fromUtf8("label4thPDate_2"))
self.sbox4thPDate = QtGui.QSpinBox(self.centralwidget)
self.sbox4thPDate.setGeometry(QtCore.QRect(290, 300, 42, 22))
self.sbox4thPDate.setAlignment(QtCore.Qt.AlignCenter)
self.sbox4thPDate.setMinimum(0)
self.sbox4thPDate.setProperty("value", 0)
self.sbox4thPDate.setObjectName(_fromUtf8("sbox4thPDate"))
self.btnLookupSymbol = QtGui.QPushButton(self.centralwidget)
self.btnLookupSymbol.setGeometry(QtCore.QRect(30, 120, 161, 23))
self.btnLookupSymbol.setObjectName(_fromUtf8("btnLookupSymbol"))
self.btnLookupSymbol.clicked.connect(self.lookup_symbol)
self.line2ndHorizontal = QtGui.QFrame(self.centralwidget)
self.line2ndHorizontal.setGeometry(QtCore.QRect(30, 140, 431, 20))
self.line2ndHorizontal.setFrameShape(QtGui.QFrame.HLine)
self.line2ndHorizontal.setFrameShadow(QtGui.QFrame.Sunken)
self.line2ndHorizontal.setObjectName(_fromUtf8("line2ndHorizontal"))
self.labelPricePredictionDates = QtGui.QLabel(self.centralwidget)
self.labelPricePredictionDates.setGeometry(QtCore.QRect(30, 160, 151, 20))
self.labelPricePredictionDates.setObjectName(_fromUtf8("labelPricePredictionDates"))
self.line1stHorizontal = QtGui.QFrame(self.centralwidget)
self.line1stHorizontal.setGeometry(QtCore.QRect(30, 50, 431, 20))
self.line1stHorizontal.setFrameShape(QtGui.QFrame.HLine)
self.line1stHorizontal.setFrameShadow(QtGui.QFrame.Sunken)
self.line1stHorizontal.setObjectName(_fromUtf8("line1stHorizontal"))
self.labelHistoricalData = QtGui.QLabel(self.centralwidget)
self.labelHistoricalData.setGeometry(QtCore.QRect(30, 70, 151, 20))
self.labelHistoricalData.setObjectName(_fromUtf8("labelHistoricalData"))
self.labelDateRange = QtGui.QLabel(self.centralwidget)
self.labelDateRange.setGeometry(QtCore.QRect(30, 10, 261, 20))
self.labelDateRange.setObjectName(_fromUtf8("labelDateRange"))
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 490, 21))
self.menubar.setObjectName(_fromUtf8("menubar"))
self.menuFile = QtGui.QMenu(self.menubar)
self.menuFile.setObjectName(_fromUtf8("menuFile"))
MainWindow.setMenuBar(self.menubar)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8("statusbar"))
MainWindow.setStatusBar(self.statusbar)
self.actionQuit = QtGui.QAction(MainWindow)
self.actionQuit.triggered.connect(QtGui.qApp.quit)
self.actionQuit.setObjectName(_fromUtf8("actionQuit"))
self.actionTo_Find_Stock_Symbol = QtGui.QAction(MainWindow)
self.actionTo_Find_Stock_Symbol.setObjectName(_fromUtf8("actionTo_Find_Stock_Symbol"))
self.actionPortfolio_Folder = QtGui.QAction(MainWindow)
self.actionPortfolio_Folder.setObjectName(_fromUtf8("actionPortfolio_Folder"))
self.menuFile.addAction(self.actionQuit)
self.menubar.addAction(self.menuFile.menuAction())
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
'''Adds extra features to GUI's buttons and fields'''
MainWindow.setWindowTitle(_translate("MainWindow", "Stock Price Predictor", None))
self.btnPredictPrices.setToolTip(_translate("MainWindow", "<html><head/><body><p>Displays the predicted closing prices for the stock symbols and days entered. Also compares the predicted price to the actual price if possible.</p></body></html>", None))
self.btnPredictPrices.setText(_translate("MainWindow", "Predict Future Prices", None))
self.btnPlotSymbol.setToolTip(_translate("MainWindow", "Plots the daily historical stock price and volume information for a given stock symbol.", None))
self.btnPlotSymbol.setText(_translate("MainWindow", "Plot Historical Data", None))
self.leditEnterTickers.setToolTip(_translate("MainWindow", "(MAX 5) Enter stock ticker symbols for price prediction, separated by commas.", None))
self.leditEnterTickers.setPlaceholderText(_translate("MainWindow", "Enter Stock Ticker Symbols for Price Prediction", None))
self.deditStartDate.setToolTip(_translate("MainWindow", "The beginning of the range of dates to be used for data download and/or stock price prediction.", None))
self.deditEndDate.setToolTip(_translate("MainWindow", "The end of the range of dates to be used for data download and/or stock price prediction.", None))
self.labelStartDate.setToolTip(_translate("MainWindow", "The beginning of the range of dates to be used for data download and/or stock price prediction.", None))
self.labelStartDate.setText(_translate("MainWindow", "Start Date TO", None))
self.labelEndDate.setToolTip(_translate("MainWindow", "The end of the range of dates to be used for data download and/or stock price prediction.", None))
self.labelEndDate.setText(_translate("MainWindow", " End Date", None))
self.leditPlotSymb.setToolTip(_translate("MainWindow", "(MAX 5) Enter stock ticker symbols to plot, separated by commas.", None))
self.leditPlotSymb.setPlaceholderText(_translate("MainWindow", "Enter Stock Ticker Symbols to Plot", None))
self.dedit1stPDate.setToolTip(_translate("MainWindow", "First day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.dedit2ndPDate.setToolTip(_translate("MainWindow", "(Optional) Second day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.dedit3rdPDate.setToolTip(_translate("MainWindow", "(Optional) Third day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label1stPDate.setToolTip(_translate("MainWindow", "First day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label1stPDate.setText(_translate("MainWindow", "1st Predicted Date OR", None))
self.label3rdPDate.setToolTip(_translate("MainWindow", "(Optional) Third day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label3rdPDate.setText(_translate("MainWindow", "3rd Predicted Date OR", None))
self.label2ndPDate.setToolTip(_translate("MainWindow", "(Optional) Second day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label2ndPDate.setText(_translate("MainWindow", "2nd Predicted Date OR", None))
self.btnFundData.setToolTip(_translate("MainWindow", "Plots the fundamental data for a given stock symbol.", None))
self.btnFundData.setText(_translate("MainWindow", "Show Fundamental Data", None))
self.labelStartDate_6.setToolTip(_translate("MainWindow", "Last day used for training the price prediction model.", None))
self.labelStartDate_6.setText(_translate("MainWindow", "Last Training Date", None))
self.sbox1stPDate.setToolTip(_translate("MainWindow", "First day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.dedit4thPDate.setToolTip(_translate("MainWindow", "(Optional) Fourth day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label4thPDate.setToolTip(_translate("MainWindow", "(Optional) Fourth day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label4thPDate.setText(_translate("MainWindow", "4th Predicted Date OR", None))
self.label1stPDate_2.setToolTip(_translate("MainWindow", "First day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label1stPDate_2.setText(_translate("MainWindow", "Trading Days into Future", None))
self.label2ndPDate_2.setToolTip(_translate("MainWindow", "(Optional) Second day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label2ndPDate_2.setText(_translate("MainWindow", "Trading Days into Future", None))
self.sbox2ndPDate.setToolTip(_translate("MainWindow", "(Optional) Second day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label3rdPDate_2.setToolTip(_translate("MainWindow", "(Optional) Third day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label3rdPDate_2.setText(_translate("MainWindow", "Trading Days into Future", None))
self.sbox3rdPDate.setToolTip(_translate("MainWindow", "(Optional) Third day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label4thPDate_2.setToolTip(_translate("MainWindow", "(Optional) Fourth day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.label4thPDate_2.setText(_translate("MainWindow", "Trading Days into Future", None))
self.sbox4thPDate.setToolTip(_translate("MainWindow", "(Optional) Fourth day for which the closing price will be predicted. Must come after the Last Training Date.", None))
self.btnLookupSymbol.setToolTip(_translate("MainWindow", "Opens web page to help find a stock\'s ticker symbol.", None))
self.btnLookupSymbol.setText(_translate("MainWindow", "Lookup Symbol", None))
self.labelPricePredictionDates.setText(_translate("MainWindow", "Stock Price Prediction", None))
self.labelHistoricalData.setText(_translate("MainWindow", "Historical Stock Data", None))
self.labelDateRange.setText(_translate("MainWindow", "Date Range for Data Download and Price Prediction", None))
self.menuFile.setTitle(_translate("MainWindow", "File", None))
self.actionQuit.setText(_translate("MainWindow", "Quit", None))
self.actionTo_Find_Stock_Symbol.setText(_translate("MainWindow", "Look Up Stock Symbols", None))
self.actionPortfolio_Folder.setText(_translate("MainWindow", "Portfolio Folder", None))
self.actionPortfolio_Folder.setToolTip(_translate("MainWindow", "Location for saved portfolios", None))
def lookup_symbol(self):
'''Opens web page in browser to help user research stock ticker symbols'''
webbrowser.open('http://finance.yahoo.com/')
def get_fund_data(self, fund_ticker):
'''Obtains and displays basic stock information from Yahoo! Finance for each of the tickers'''
self.yahoo_request = Share(self.fund_ticker)
self.ADV = self.yahoo_request.get_avg_daily_volume()
self.market_cap = self.yahoo_request.get_market_cap()
self.mov_avg50 = self.yahoo_request.get_50day_moving_avg()
self.mov_avg200 = self.yahoo_request.get_200day_moving_avg()
self.pe_ratio = self.yahoo_request.get_price_earnings_ratio()
self.price = self.yahoo_request.get_price()
self.year_high = self.yahoo_request.get_year_high()
self.year_low = self.yahoo_request.get_year_low()
self.data = {'Ticker': self.fund_ticker, 'Price' : self.price, 'Year High' : self.year_high, 'Year Low' : self.year_low,
'Market Cap.' : self.market_cap, 'Avg. Daily Volume' : self.ADV,
'50 Day Moving Avg.': self.mov_avg50, '200 Day Moving Avg.': self.mov_avg200, 'P/E Ratio' : self.pe_ratio,
}
self.temp_df = pd.DataFrame(data = self.data, index=[0])
self.temp_df = self.temp_df[['Ticker', 'Price', 'Year High', 'Year Low', 'Market Cap.',
'Avg. Daily Volume', '50 Day Moving Avg.', '200 Day Moving Avg.', 'P/E Ratio']]
return self.temp_df
def display_fund_data(self):
'''Reads ticker symbols entered into GUI's plotting line edit, obtains fundamental data from Yahoo, displays data in FundamentalWidget'''
fund_ticker_text = str(self.leditPlotSymb.text())
fund_tickers = fund_ticker_text.split(',')
self.fundamental_df = pd.DataFrame()
for self.fund_ticker in fund_tickers:
self.fund_ticker = self.fund_ticker.strip().upper()
self.temp_df = self.get_fund_data(self.fund_ticker)
self.fundamental_df = self.fundamental_df.append(self.temp_df)
self.fund_window = FundamentalWidget(self.fundamental_df)
self.fund_window.show()
def show_predictions(self):
'''Reads ticker symbols and dates entered into GUI's fields, makes Predictor object, displays results in PredictionWidget'''
self.start_date = self.deditStartDate.date().toPyDate()
self.end_date = self.deditEndDate.date().toPyDate()
self.last_train_date = self.deditLastTDate.date().toPyDate()
future_date1 = self.dedit1stPDate.date().toPyDate()
future_date2 = self.dedit2ndPDate.date().toPyDate()
future_date3 = self.dedit3rdPDate.date().toPyDate()
future_date4 = self.dedit4thPDate.date().toPyDate()
self.future_dates = [future_date1, future_date2, future_date3, future_date4]
future_num_day1 = self.sbox1stPDate.value()
future_num_day2 = self.sbox2ndPDate.value()
future_num_day3 = self.sbox3rdPDate.value()
future_num_day4 = self.sbox4thPDate.value()
self.future_num_days = [future_num_day1, future_num_day2, future_num_day3, future_num_day4]
pred_ticker_text = str(self.leditEnterTickers.text())
self.pred_tickers = pred_ticker_text.split(',')
self.results_df = pd.DataFrame()
for self.pred_ticker in self.pred_tickers:
self.pred_ticker = self.pred_ticker.strip().upper()
self.predictor = PricePredictor(self.start_date, self.end_date, self.last_train_date,
self.future_dates, self.future_num_days, self.pred_ticker)
self.temp_df = self.predictor.make_predictions()
self.results_df = self.results_df.append(self.temp_df)
self.results_window = PredictionWidget(self.results_df)
self.results_window.show()
def display_plots(self):
'''Reads ticks symbols from GUI's plotting line edit, retrieves data from Yahoo, plots data in PlotWidget'''
plot_ticker_text = str(self.leditPlotSymb.text())
plot_tickers = plot_ticker_text.split(',')
self.start_date = self.deditStartDate.date().toPyDate()
self.end_date = self.deditEndDate.date().toPyDate()
for self.plot_ticker in plot_tickers:
self.plot_ticker = self.plot_ticker.strip().upper()
self.yahoo_df = web.DataReader(self.plot_ticker, 'yahoo', self.start_date, self.end_date)
self.plot_window = PlotWidget(self.yahoo_df, self.plot_ticker)
def getNDaysAgo(N):
date_N_days_ago = datetime.now() - timedelta(days=N)
return str(date_N_days_ago.date())
fname = 'C:\dump\companylist.csv'
with open(fname) as f:
content = csv.reader(f, delimiter=',')
twentDay = getNDaysAgo(1)
today = str(datetime.now().date())
for line in content:
if any(x not in line[0] for x in ['^', '$']):
stock = Share(line[0])
print line[0]
print stock.get_name()
print stock.get_50day_moving_avg()
# print stock.get_200day_moving_avg()
print stock.get_avg_daily_volume()
pprint(stock.get_historical(twentDay, today))
else:
print line[0] + ' contains a special character******'
# yahoo = Share('WWW')
# print yahoo.get_name()
# print yahoo.get_open();
#
# print yahoo.get_50day_moving_avg();
#
# print yahoo.get_avg_daily_volume()
def relative_analysis_00_get_average_daily_volume(stock_name):
# TODO: Error checking.
stock = Share(stock_name)
return stock.get_avg_daily_volume()
def view_stock(request, ticker):
if request.user.__class__.__name__ is "CustomUser":
c_user = get_object_or_404(CustomUser, pk=request.user.pk)
account = Account.objects.get(user=c_user)
else:
account = False
stock = get_object_or_404(Stock, ticker=ticker)
companyName = stock.ticker
companyName = companyName.upper()
stock = Stock.objects.get(ticker=companyName)
namer = "'" + companyName + "'"
ystock = Share(companyName)
the_price = ystock.get_price()
regex = 'Business Summary</span></th><th align="right"> </th></tr></table><p>(.+?)</p>'
pattern = re.compile(regex)
root_url = urllib.urlopen("http://finance.yahoo.com/q/pr?s=" + companyName + "+Profile")
htmltext = root_url.read()
decoded_str = str(re.findall(pattern, htmltext)).decode("utf8")
encoded_str = decoded_str.encode("ascii", "ignore")
stock.description = encoded_str
stock.description = stock.description[:-2]
stock.description = stock.description[2:]
stock.book_value = ystockquote.get_book_value(companyName)
stock.change = ystockquote.get_change(companyName)
# stock.dividend_per_share = ystockquote.get_dividend_per_share(companyName)
# stock.dividend_yield = ystockquote.get_dividend_yield(companyName)
stock.ebitda = ystockquote.get_ebitda(companyName)
stock.fifty_two_week_high = ystockquote.get_52_week_high(companyName)
stock.fifty_two_week_low = ystockquote.get_52_week_low(companyName)
stock.market_cap = ystockquote.get_market_cap(companyName)
stock.short_ratio = ystockquote.get_short_ratio(companyName)
stock.stock_exchange = ystockquote.get_stock_exchange(companyName)
stock.volume = ystockquote.get_volume(companyName)
stock.price = ystock.get_price()
# yahoo_finance
stock.average_daily_volume = ystock.get_avg_daily_volume()
stock.earnings_per_share = ystock.get_price_earnings_ratio()
stock.fifty_day_moving_avg = ystock.get_50day_moving_avg()
stock.two_hundred_day_moving_avg = ystock.get_200day_moving_avg()
stock.price_book_ratio = ystock.get_price_book()
stock.last_sale = ystock.get_price()
stock.price_earnings_growth_ratio = ystock.get_price_earnings_growth_ratio()
stock.price_earnings_ratio = ystock.get_price_earnings_ratio()
stock.price_sales_ratio = ystock.get_price_sales()
stock.save()
vl = []
acl = []
hl = []
ll = []
cl = []
ol = []
days_list = []
d = 0
seven_days_ago = datetime.datetime.now() + datetime.timedelta(-30)
today = datetime.datetime.now()
days = ystockquote.get_historical_prices("GOOGL", seven_days_ago.strftime("%Y-%m-%d"), today.strftime("%Y-%m-%d"))
for day in days.keys():
d += 1
date_label = datetime.datetime.now() + datetime.timedelta(-d)
days_list.append(date_label.strftime("%b-%d"))
day_info = days.get(day)
vol = int(day_info.get("Volume"))
vl.append(vol)
adjcl = float(day_info.get("Adj Close"))
acl.append(adjcl)
highs = float(day_info.get("High"))
hl.append(highs)
lows = float(day_info.get("Low"))
ll.append(lows)
closes = float(day_info.get("Close"))
cl.append(closes)
opens = float(day_info.get("Open"))
ol.append(opens)
volume = vl
lows = ll
opens = ol
highs = hl
averages = acl
closes = cl
days_l = days_list[::-1]
context = RequestContext(
request,
dict(
account=account,
request=request,
stock=stock,
volume=volume,
lows=lows,
highs=highs,
opens=opens,
closes=closes,
averages=averages,
days_l=days_l,
),
)
return render_to_response("scrapyr_app/stock.html", context=context)
def main():
count = 0 # Counter
# Need this for Technical Analysis calculations
curr = datetime.datetime.now()
currYear = str(curr.year)
currMonth = str(curr.month)
currDay = str(curr.day)
currDate = currYear + '-' + currMonth + '-' + currDay
startDate = str(curr.year - 1) + '-' + currMonth + '-' + currDay
contents = open('constituents.csv',
'r') # Open constituents file for reading
reader = csv.reader(contents) # CSV reader object
writeData = open('stockData.csv', 'w',
newline='') # Open output data file in write mode
writer = csv.writer(writeData) # CSV writer object
for row in reader: # For each line in the constituents file
try:
ticker = Share(row[0]) # Share object with ticker symbol as input
currPrice = ticker.get_price() # Get currPrice (15 min delay)
avgVol = ticker.get_avg_daily_volume() # Get average volume
cap = ticker.get_market_cap() # Get market cap
yearHigh = ticker.get_year_high() # Get year high
yearLow = ticker.get_year_low() # Get year low
ma50d = ticker.get_50day_moving_avg() # 50 DMA
ma200d = ticker.get_200day_moving_avg() # 200 DMA
dataList = numpy.array([]) # Create empty numpy array
data = ticker.get_historical(
startDate, currDate) # Get historical data for 1 year
data = data[::-1] # Reverse data
for item in data:
dataList = numpy.append(dataList, float(
item['Close'])) # Add closing prices to list
macd, macdsignal, macdhist = talib.MACD(
dataList, fastperiod=12, slowperiod=26,
signalperiod=9) # Calculate MACD values
rsi = talib.RSI(dataList, timeperiod=14) # Calculate RSI value
# Write data to stockData file
writer.writerow([
row[0], row[1], currPrice, avgVol, cap, yearLow, yearHigh,
ma50d, ma200d, macd[-1], macdsignal[-1], macdhist[-1], rsi[-1]
])
except:
pass
# Update screen with percent complete
count = count + 1
os.system('CLS')
print((str(format(count / 504.0 * 100.0, '.2f')) + '%'))
# Close CSV files
writeData.close()
contents.close()
}
fund = Share(ETF)
fields = {
'name': fund.get_name(),
'symbol': ETF,
'last_trade': fund.get_price(),
'dividend_yield': fund.get_dividend_yield(),
'absolute_change': fund.get_change(),
'percentage_change': fund.get_percent_change(),
'year high': fund.get_year_high(),
'year low': fund.get_year_low(),
'50 day moving average': fund.get_50day_moving_avg(),
'200 day moving average': fund.get_200day_moving_avg(),
'average_daily_volume': fund.get_avg_daily_volume()
}
etf_dict['fields'] = fields
etf_data.append(etf_dict)
json_data = json.dumps(etf_data)
# print(json_data)
output_dict = [y for y in etf_data if y['fields']['dividend_yield'] > 1]
output_dict = [
x for x in output_dict if x['fields']['average_daily_volume'] > 100000
]
output_dict = [
ticker = ticker.rstrip()
if len(ticker) == 0:
continue
stock = Share(ticker)
stock.refresh()
change = (float(stock.get_price()) - float(
stock.get_prev_close())) / float(stock.get_prev_close())
change = round(change * 100.0, 2)
if change > 0.0:
change = '+' + str(change)
else:
change = str(change)
line = ticker.ljust(7)
line += stock.get_price().ljust(9)+ change.ljust(8)+ stock.get_volume().ljust(11) + \
str(round(float(stock.get_volume())/float(stock.get_avg_daily_volume())*100.0)).ljust(8) +\
stock.get_open().ljust(10)+ \
stock.get_days_low().ljust(10)+ \
stock.get_days_high().ljust(10)+ \
stock.get_year_low().ljust(10)+ \
stock.get_year_high().ljust(10)
line = line + str(stock.get_market_cap()).ljust(11) + \
str(stock.get_price_earnings_ratio()).ljust(8)+\
stock.get_50day_moving_avg().ljust(10) +\
stock.get_200day_moving_avg().ljust(10)
print(line)
except Exception as e:
print("Exception error:", str(e))
traceback.print_exc()
i += 1
print(row_title)
ticker = ticker.rstrip()
if len(ticker) == 0:
continue
stock = Share(ticker)
stock.refresh()
change = (float(stock.get_price()) - float(stock.get_prev_close()))/float(stock.get_prev_close())
change = round(change *100.0, 2)
if change > 0.0:
change= '+' + str(change)
else:
change =str(change)
line = ticker.ljust(7)
line += stock.get_price().ljust(9)+ change.ljust(8)+ stock.get_volume().ljust(11) + \
str(round(float(stock.get_volume())/float(stock.get_avg_daily_volume())*100.0)).ljust(8) +\
stock.get_open().ljust(10)+ \
stock.get_days_low().ljust(10)+ \
stock.get_days_high().ljust(10)+ \
stock.get_year_low().ljust(10)+ \
stock.get_year_high().ljust(10)
line = line + str(stock.get_market_cap()).ljust(11) + \
str(stock.get_price_earnings_ratio()).ljust(8)+\
stock.get_50day_moving_avg().ljust(10) +\
stock.get_200day_moving_avg().ljust(10)
print(line)
except Exception as e:
print("Exception error:", str(e))
traceback.print_exc()
i+=1
if myargs.volume is True:
volume = stock.get_volume()
output.append(volume)
selections.append('Volume: ')
print output
if myargs.change is True:
change = stock.get_change()
output.append(change)
selections.append('Change: ')
print change
if myargs.avgvol is True:
avgvolume = stock.get_avg_daily_volume()
print avgvolume
if myargs.short is True:
short = stock.get_short_ratio()
print short
if myargs.peratio is True:
pe = stock.get_price_earnings_ratio()
print pe
if myargs.exchange is True:
exchange = stock.get_stock_exchange()
if myargs.ma50 is True:
ma50 = stock.get_50day_moving_avg()
from Parser.models import EtfInfo, EtfData, StockInfo, StockDetail
etfResult = StockInfo.objects.values('ticker', 'name')
#for etfIdx in range(0, len(etfResult)) :
tickerStr = etfResult[0]['ticker']
share = Share(tickerStr)
dateStr = share.get_trade_datetime()[0:11].replace('-','')
ma_200Str = convert(share.get_200day_moving_avg())
ma_50Str = convert(share.get_50day_moving_avg())
book_valueStr = convert(share.get_book_value())
volume_avgStr = convert(share.get_avg_daily_volume())
ebitdaStr = convert(share.get_ebitda())
dividend_yieldStr = convert(share.get_dividend_yield())
market_capStr = convert(share.get_market_cap())
year_highStr = convert(share.get_year_high())
year_lowStr = convert(share.get_year_low())
print tickerStr, dateStr, ma_200Str, ma_50Str, book_valueStr, volume_avgStr, ebitdaStr, dividend_yieldStr, market_capStr, year_highStr, year_lowStr
# print share.get_change()
# print share.get_days_high()
# print share.get_days_low()
# print share.get_dividend_share()
# print share.get_info()
# print share.get_open()
from yahoo_finance import Share, Currency
yahoo = Share('AAPL')
yahoo.refresh()
print yahoo.get_info()
print yahoo.get_avg_daily_volume()
print yahoo.get_stock_exchange()
print yahoo.get_book_value()
print yahoo.get_ebitda()
print yahoo.get_dividend_share()
print yahoo.get_price_earnings_ratio()
print yahoo.get_short_ratio()
print yahoo.get_price_book()
# f = open('nasdaqlisted.txt', 'r')
# print (f.readline())
# print (f.readline())
def view_stock(request, ticker):
if request.user.__class__.__name__ is 'CustomUser':
c_user = get_object_or_404(CustomUser, pk=request.user.pk)
account = Account.objects.get(user=c_user)
else:
account = False
stock = get_object_or_404(Stock, ticker=ticker)
companyName = stock.ticker
companyName = companyName.upper()
stock = Stock.objects.get(ticker=companyName)
namer = "'" + companyName + "'"
ystock = Share(companyName)
the_price = ystock.get_price()
regex = 'Business Summary</span></th><th align="right"> </th></tr></table><p>(.+?)</p>'
pattern = re.compile(regex)
root_url = urllib.urlopen("http://finance.yahoo.com/q/pr?s=" +
companyName + "+Profile")
htmltext = root_url.read()
decoded_str = str(re.findall(pattern, htmltext)).decode("utf8")
encoded_str = decoded_str.encode('ascii', 'ignore')
stock.description = encoded_str
stock.description = stock.description[:-2]
stock.description = stock.description[2:]
stock.book_value = ystockquote.get_book_value(companyName)
stock.change = ystockquote.get_change(companyName)
#stock.dividend_per_share = ystockquote.get_dividend_per_share(companyName)
#stock.dividend_yield = ystockquote.get_dividend_yield(companyName)
stock.ebitda = ystockquote.get_ebitda(companyName)
stock.fifty_two_week_high = ystockquote.get_52_week_high(companyName)
stock.fifty_two_week_low = ystockquote.get_52_week_low(companyName)
stock.market_cap = ystockquote.get_market_cap(companyName)
stock.short_ratio = ystockquote.get_short_ratio(companyName)
stock.stock_exchange = ystockquote.get_stock_exchange(companyName)
stock.volume = ystockquote.get_volume(companyName)
stock.price = ystock.get_price()
#yahoo_finance
stock.average_daily_volume = ystock.get_avg_daily_volume()
stock.earnings_per_share = ystock.get_price_earnings_ratio()
stock.fifty_day_moving_avg = ystock.get_50day_moving_avg()
stock.two_hundred_day_moving_avg = ystock.get_200day_moving_avg()
stock.price_book_ratio = ystock.get_price_book()
stock.last_sale = ystock.get_price()
stock.price_earnings_growth_ratio = ystock.get_price_earnings_growth_ratio(
)
stock.price_earnings_ratio = ystock.get_price_earnings_ratio()
stock.price_sales_ratio = ystock.get_price_sales()
stock.save()
vl = []
acl = []
hl = []
ll = []
cl = []
ol = []
days_list = []
d = 0
seven_days_ago = datetime.datetime.now() + datetime.timedelta(-30)
today = datetime.datetime.now()
days = ystockquote.get_historical_prices(
'GOOGL', seven_days_ago.strftime("%Y-%m-%d"),
today.strftime("%Y-%m-%d"))
for day in days.keys():
d += 1
date_label = datetime.datetime.now() + datetime.timedelta(-d)
days_list.append(date_label.strftime("%b-%d"))
day_info = days.get(day)
vol = int(day_info.get('Volume'))
vl.append(vol)
adjcl = float(day_info.get('Adj Close'))
acl.append(adjcl)
highs = float(day_info.get('High'))
hl.append(highs)
lows = float(day_info.get('Low'))
ll.append(lows)
closes = float(day_info.get('Close'))
cl.append(closes)
opens = float(day_info.get('Open'))
ol.append(opens)
volume = vl
lows = ll
opens = ol
highs = hl
averages = acl
closes = cl
days_l = days_list[::-1]
context = RequestContext(
request,
dict(account=account,
request=request,
stock=stock,
volume=volume,
lows=lows,
highs=highs,
opens=opens,
closes=closes,
averages=averages,
days_l=days_l))
return render_to_response('scrapyr_app/stock.html', context=context)
