def DL_earningsdates(argv=None):
today = datetime.datetime.today()
oneweeks = datetime.timedelta(days=21)
threeweeks = datetime.timedelta(days=21)
yec = YahooEarningsCalendar()
earningsDF = None
frames = []
for i in xrange(1, 26, 1):
if i > 1: today = today - (threeweeks)
threeweeksago = today - threeweeks
inthreeweeks = today + threeweeks
earnings = yec.earnings_between(threeweeksago, inthreeweeks)
df = pd.DataFrame(earnings)
print 'Found ' + str(len(df)) + ' results for between ' + str(
threeweeksago) + ' and ' + str(inthreeweeks)
if ('startdatetime' not in df.columns) or len(df) == 0:
print "no startdatetime detected/no data"
continue
df['startdatetime'] = pd.to_datetime(
df['startdatetime']) # TODO make timezone aware and convert to UTC
pdtoday = pd.to_datetime(today)
df['today'] = pdtoday
df['temp'] = df['startdatetime'].view('int64') - df['today'].view(
'int64')
df['days'] = df['temp'].apply(lambda x: np.timedelta64(x, 'ns').astype(
'timedelta64[D]') / np.timedelta64(1, 'D'))
frames.append(df)
df.to_csv('/root/data/temp/earningsdata-' + str(threeweeksago) + '-' +
str(inthreeweeks) + '.csv')
earningsDF = pd.concat(frames)
earningsDF.to_csv('/root/data/temp/earningsdata.csv')
def get_earnings_for_days(date_from, date_to):
try:
calender_manager = YahooEarningsCalendar()
data = calender_manager.earnings_between(date_from, date_to)
return [EarningsData(i) for i in data]
except KeyError:
return []
def GetCompanieslist():
print("@" * 20 +
" Pls Hang on getting data from YahooEarningsCalendar API " +
"@" * 20)
yec = YahooEarningsCalendar()
date_from = pd.to_datetime(
cfg.defaults["startdate"]) ##convert str to date format
date_to = pd.to_datetime(cfg.defaults["enddate"])
data = yec.earnings_between(date_from, date_to) ### Pull the data
print('\n' * 2)
print("Successfully Fetched the data for time range", date_from, date_to)
print('\n' * 2)
df = pd.DataFrame(data) ### Convert into DataFrame
df = df.sort_values(by=['epsestimate'],
ascending=False) ## Sort in Asc order by epsestimate
#df=df[df.epsestimate>cfg.defaults["epsestimate_threshold"]] ## Filter the records
df.startdatetime = df.startdatetime.apply(
lambda a: pd.to_datetime(a).strftime("%Y-%m-%d %H:%M:%S"))
df.fillna(0, inplace=True)
for idx, data in df.iterrows():
status = db.EarningCalender(data)
#print(status,idx)
companies = df.ticker.tolist() ### Get the companies list
#print(df.head())
if companies:
output = {"companies": companies, "status": True}
else:
output = {"companies": companies, "status": False}
return output
def generate_dfs(num_gl):
start_date = datetime.now().date()
end_date = datetime.now().date()
gainers=get_day_gainers()
topg=gainers.nlargest(num_gl,"% Change")
topg=topg.drop(columns=["Price (Intraday)","Change","Volume","Avg Vol (3 month)"])
losers=get_day_losers()
topl=losers.nsmallest(num_gl,"% Change")
topl=topl.drop(columns=["Price (Intraday)","Change","Volume","Avg Vol (3 month)"])
#try:
yec = YahooEarningsCalendar()
earnings_list = yec.earnings_between(start_date, end_date)
earnings_df = pd.DataFrame(earnings_list)
earnings_df["% Change"]=""
earnings_df["Current Price"]=""
earnings_df["Previous Close"]=""
earnings_df=earnings_df.drop(columns=["epsestimate","epsactual","epssurprisepct","startdatetime","timeZoneShortName","gmtOffsetMilliSeconds","quoteType"])
for index, x in enumerate(earnings_df["ticker"]):
try:
earnings_df["Previous Close"][index]=get_quote_table(x , dict_result = True)["Previous Close"]
earnings_df["Current Price"][index]=get_live_price(x)
earnings_df["% Change"][index]=100*((earnings_df["Current Price"][index]-earnings_df["Previous Close"][index])/earnings_df["Previous Close"][index])
except:
pass
earnings_df=earnings_df.dropna().sort_values(by="% Change",ascending=False)
#except:
# earnings_df=pd.DataFrame
return earnings_df , topg,topl
def get_earnings_calendar(start_date, end_date):
yec = YahooEarningsCalendar()
print('Getting earnings calendar between {} - {}'.format(
start_date, end_date))
all_earnings_data = yec.earnings_between(start_date, end_date)
all_earnings_df = pd.DataFrame(all_earnings_data)
all_earnings_df = all_earnings_df.set_index('ticker')
return all_earnings_df
def get_todays_earnings():
today = datetime.date.today()
date_from = datetime.datetime.combine(today, datetime.datetime.min.time())
date_to = datetime.datetime.combine(today, datetime.datetime.max.time())
yec = YahooEarningsCalendar()
earnings_list = yec.earnings_between(date_from, date_to)
ticker_list = []
for stock in earnings_list:
ticker_list.append(stock['ticker'])
return np.unique(ticker_list)
def get_earnings(self, days_before = 0, days_after = 30):
from yahoo_earnings_calendar import YahooEarningsCalendar
dfdb = pd.read_sql(self.earnings_db, con=self.engine)
yec = YahooEarningsCalendar()
dfd = pd.DataFrame(yec.earnings_between(
datetime.now() - timedelta(days=days_before), datetime.now() + timedelta(days=days_after)))
df_new = dfd.append(dfdb, ignore_index=True)
df_new.drop_duplicates(subset=["ticker","startdatetime","startdatetimetype"], inplace=True, keep="first")
#save DATAFRAME to database
df_new.to_sql(self.earnings_db, con=self.engine,
if_exists='replace', index=False)
print(df_new)
return df_new
def OneTimeUpdate(num_days):
count = 1
print('OneTimeUpdate')
yec = YahooEarningsCalendar()
date_from = datetime.date.today()
date_to = date_from + dateutil.relativedelta.relativedelta(
days=num_days)
ERs = yec.earnings_between(date_from, date_to)
ERs = [{k: item[k]
for k in ('ticker', 'startdatetime')} for item in ERs]
num_itr = len(ERs)
for er in ERs:
screener.objects.update_or_create(
symbol=er['ticker'], defaults={'nextER': er['startdatetime']})
print("itr %3d of %3d" % (count, num_itr))
count = count + 1
def get_earnings():
'''
get earnings date and ticker from yahoo calendar library
save as format:
[
{
ticker: 'string',
date: 'string',
},
...
]
'''
print('earnings date script started.......')
def get_front_date(date_delta):
dates_list = []
for i in range(0, date_delta):
d = datetime.date.today()
d += datetime.timedelta(i)
if d.weekday() == 4:
dates_list.append(str(d))
#print(dates_list[-2])
return dates_list[-1]
front_date = get_front_date(15)
print(front_date)
# ========= check earnings calendar ==========
date_from = datetime.datetime.strptime(date.today().strftime('%Y-%m-%d') + " 05:00:00", '%Y-%m-%d %X')
date_to = datetime.datetime.strptime(front_date + " " + "18:00:00", '%Y-%m-%d %X')
yec = YahooEarningsCalendar()
earnings_list= []
earnings_calendar = yec.earnings_between(date_from, date_to)
if earnings_calendar:
for company in earnings_calendar:
earnings_dict = {}
earnings_dict['ticker'] = company['ticker']
earnings_dict['date'] = re.findall('\d\d\d\d-\d\d-\d\d',company['startdatetime'])[0]
earnings_list.append(earnings_dict)
with open('/tmp/json/companies_earnings.json', 'w') as f:
json.dump(earnings_list, f)
print('earnings date script finished !')
print('check /tmp/json/ for earnings_date')
def upcoming_earnings(self, days: int = 2) -> str:
result = ''
date_from = date.today()
date_to = date_from + timedelta(days=days)
yec = YahooEarningsCalendar()
ue = yec.earnings_between(date_from, date_to)
pd_ue = pd.DataFrame(ue)
pd_ue = pd_ue.drop_duplicates(subset=['ticker'])
columns = ['startdatetime', 'companyshortname', 'ticker']
result = pd_ue[columns].to_string(header=False,
index=False,
formatters={
columns[0]: formatter_date,
columns[1]: '{:.15}'.format
})
return result
def email():
ezgmail.init()
DAYS_AHEAD=1
start_date = datetime.now().date() + timedelta(days=DAYS_AHEAD)
end_date = (datetime.now().date() + timedelta(days=DAYS_AHEAD))
# downloading the earnings calendar
yec = YahooEarningsCalendar()
earnings_list = yec.earnings_between(start_date, end_date)
print(earnings_list)
# saving the data in a pandas DataFrame
earnings_df = pd.DataFrame(earnings_list)
print(earnings_df["startdatetime"])
earnings_df["startdatetime"]= earnings_df['startdatetime'].astype(str).str[:-14]
earnings_df["Link"]="https://finance.yahoo.com/quote/{}".format(earnings_df["ticker"])
for index, x in enumerate(earnings_df["ticker"]):
earnings_df["Link"][index]="https://finance.yahoo.com/quote/{}".format(x)
print(earnings_df["startdatetime"])
print(earnings_df)
earnings_df.to_csv( r"C:\Users\MIKEB\Desktop\Python\Fuhnance\Earnings_For_{}.csv".format(start_date))
e,g,l=generate_dfs(10)
msg="Top Gainers Today:\n\n"
for index,x in enumerate(g["Symbol"]):
try:
line=f"{x} | {g['Name'][index]} | {g['% Change'][index]}% | https://finance.yahoo.com/quote/{x}\n\n"
msg=msg+line
except:
pass
print(msg)
msg=msg+"\n\nTop Losers Today:\n\n"
for index,x in enumerate(l["Symbol"]):
try:
line=f"{x} | {l['Name'][index]} | {l['% Change'][index]}% | https://finance.yahoo.com/quote/{x}\n\n"
msg=msg+line
except:
pass
msg=msg+"\n\nEarnings Action Today:\n\n"
for index,x in enumerate(e["ticker"]):
line=f"{x} | {e['companyshortname'][index]} | {e['startdatetimetype'][index]} | {round(e['% Change'][index],2)}% | https://finance.yahoo.com/quote/{x}\n\n"
msg=msg+line
print(msg)
#for x in ["*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**"]:
for x in ["*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**","*****@*****.**"]:
ezgmail.send(x,"Gainers, Losers, and Earnings {}".format(start_date),msg,r"C:\Users\MIKEB\Desktop\Python\Fuhnance\Earnings_For_{}.csv".format(start_date))
def PopulateEarningDate(num_days):
yec = YahooEarningsCalendar()
date_to = datetime.date.today()
date_from = date_to - dateutil.relativedelta.relativedelta(
days=num_days)
ERs = yec.earnings_between(date_from, date_to)
ERs = [{
k: item[k]
for k in ('ticker', 'startdatetime', 'epsestimate', 'epsactual',
'epssurprisepct')
} for item in ERs]
for er in ERs:
screener.objects.update_or_create(symbol=er['ticker'],
defaults={
'epsActual':
er['epsactual'],
'epsEstimate':
er['epsestimate'],
'mostRecentER':
er['startdatetime'],
'epsSurprisePC':
er['epssurprisepct']
})
def get_future_earnings(self):
date_from = datetime.strptime(self.start_date, '%b %d %Y')
date_to = datetime.strptime(self.end_date, '%b %d %Y')
yec = YahooEarningsCalendar()
el = yec.earnings_between(date_from, date_to)
df_list = []
for elem in el:
if elem['ticker'] in self.name_list:
str1 = elem['startdatetime']
l1 = str1.split("T")
date = l1[0]
str2 = elem['startdatetimetype']
type = ""
if str2 == "BMO" or str2 == "AMC":
type = str2
else:
l2 = l1[1].split(":")
if int(l2[0]) <= 16:
type = "BMO"
else:
type = "AMC"
l2 = date.split("-")
day = day_dict[calendar.weekday(int(l2[0]), int(l2[1]),
int(l2[2]))]
#print("|",elem['ticker'].ljust(10),elem['companyshortname'].ljust(40),day.ljust(4),date.ljust(15),type.ljust(8),"|")
t = (elem['ticker'], elem['companyshortname'], day, date, type)
df_list.append(t)
arr = np.array(df_list)
df = pd.DataFrame(arr,
columns=['Ticker', 'Company', 'Day', 'Date', 'When'])
model = pandasModel(df)
#print(tabulate(df, headers='keys', tablefmt='psql'))
return model
import datetime
from yahoo_earnings_calendar import YahooEarningsCalendar
date_from = datetime.datetime.strptime('May 5 2017 10:00AM',
'%b %d %Y %I:%M%p')
date_to = datetime.datetime.strptime('May 8 2017 1:00PM', '%b %d %Y %I:%M%p')
yec = YahooEarningsCalendar()
print(yec.earnings_on(date_from))
print(yec.earnings_between(date_from, date_to))
'August 22 2020 10:00AM', '%B %d %Y %I:%M%p')
date_to = datetime.datetime.strptime(
'September 10 2020 5:00PM', '%B %d %Y %I:%M%p')
"""
date_to = datetime.datetime.today().replace(year=datetime.datetime.today().year+1)
print("date_to: " + str(date_to))
print("today: " + str(datetime.datetime.today()))
yec = YahooEarningsCalendar()
earning_info_list = []
fetched_earnings = yec.earnings_between(datetime.datetime.today(), date_to)
for each in fetched_earnings:
earning_info_list.append(EarningInfo(each['ticker'], each['companyshortname'], each['startdatetime'], each['startdatetimetype'], each['epsestimate']))
ticker_set = set()
for each in earning_info_list:
ticker_set.add(each.ticker)
tickers_string = ""
for ticker in ticker_set:
tickers_string += " " + ticker
def main(argv):
list_file = ""
name_list = set()
start_date = ""
end_date = ""
future_flag = False
db_name = ""
update_flag = False
method_flag = False
try:
opts, args = getopt.getopt(argv, "hd:l:s:e:uafm", [
"db_name=", "list_file=", "start_date=", "end_date=", "update",
"add", "future", "method"
])
except getopt.GetoptError:
print("""driver2.py -l <file containing list of stocks>
-d <name of the database>
-s <start_date in YYYY-MM-DD format>
-e <end_date in YYYY-MM-DD format>
-u (update, do not replace)
-a (add additional instruments)
-f (this is for coming earnings)
-m (use laternative method for future earnings)
""")
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print("""driver2.py -l <file containing list of stocks>
-s <start_date in YYYY-MM-DD format>
-e <end_date in YYYY-MM-DD format>
-d <name of the database>
-u (update, do not replace)
-a (add additional instruments)
-f (this is for coming earnings)
-m (use laternative method for future earnings)
""")
sys.exit()
elif opt in ("-l", "--list_file"):
list_file = arg
elif opt in ("-s", "--start_date"):
start_date = arg
elif opt in ("-e", "--end_date"):
end_date = arg
elif opt in ("-f", "--future"):
future_flag = True
elif opt in ("-u", "--update"):
update_flag = True
elif opt in ("-m", "--method"):
method_flag = True
elif opt in ("-d", "--db_name"):
db_name = arg
process_file(list_file, name_list)
date_from = datetime.strptime(start_date, '%b %d %Y')
date_to = datetime.strptime(end_date, '%b %d %Y')
if future_flag == True:
if method_flag == False:
yec = YahooEarningsCalendar()
el = yec.earnings_between(date_from, date_to)
print_future_earnings(el, name_list)
else:
future_earnings_method2(start_date, end_date, name_list)
else:
l1 = start_date.split()
l2 = end_date.split()
obtain_historical_earnings_data(l1, l2, name_list, db_name,
update_flag)
yec = YahooEarningsCalendar()
'''
get earnings date and ticker from yahoo calendar library
save as format:
[
{
ticker: 'string',
date: 'string',
},
...
]
'''
#print('getting earnings dates from yahoo')
earnings_list= []
#print(yec.earnings_on(date_from))
#earnings_calendar = yec.earnings_between(date_from, date_to) # <-- get request for yahoo calendar ehre
earnings_calendar = yec.earnings_between(date_from, date_to)
#print(earnings_calendar)
if earnings_calendar:
for company in earnings_calendar:
earnings_dict = {}
earnings_dict['ticker'] = company['ticker']
earnings_dict['date'] = re.findall('\d\d\d\d-\d\d-\d\d',company['startdatetime'])[0]
earnings_list.append(earnings_dict)
with open('callie_scripts/companies_earnings.json', 'w') as f:
json.dump(earnings_list, f)
from yahoo_earnings_calendar import YahooEarningsCalendar
from yahooquery import Ticker
import pandas as pd
from datetime import datetime, timedelta
# Create instance of yec
yec = YahooEarningsCalendar()
# Define Start/End Dates and Pull list of stocks with upcoming earnings
start = datetime.today() + timedelta(days=15)
end = datetime.today() + timedelta(days=25)
earnings = yec.earnings_between(start, end)
# Extract symbols from results
screener_symbols = [dic['ticker'] for dic in earnings]
# Pull current prices
screener = Ticker(screener_symbols)
today_price = screener.price
# Prices DataFrame
prices_df = pd.DataFrame(today_price).T.reset_index()
prices_df.rename({'regularMarketPrice': 'stock_price'}, inplace=True, axis=1)
# Create empty list to store filtered stocks
filtered_stocks = []
# Go through stocks and check if price is between 5/100
for stock in today_price.keys():
# Dealing with stocks with no results
db = firebase.database()
user = auth.sign_in_with_email_and_password(EMAIL, PW)
today = datetime.today()
#date_to = today + relativedelta(years=1)
date_to = today + relativedelta(months=1)
print("Today: " + str(today))
print("Date to: " + str(date_to))
yec = YahooEarningsCalendar()
earning_info_list = []
#print("retrieving earning info...")
fetched_earnings = yec.earnings_between(today, date_to)
#print("fetched earnings...")
print(fetched_earnings)
data = []
for each in fetched_earnings:
if each['epsestimate'] is None:
each['epsestimate'] = "None"
data.append({
'ticker': each['ticker'],
'company': each['companyshortname'],
'epsestimate': each['epsestimate'],
'startdatetime': each['startdatetime'],
'startdatetimetype': each['startdatetimetype'],
'timezone': each['timeZoneShortName']
def next_sunday(d):
days_ahead = 6 - d.weekday()
if days_ahead <= 0:
days_ahead += 7
return d + datetime.timedelta(days_ahead)
date_from = next_sunday(
datetime.datetime.today()) #+ datetime.timedelta(weeks=2)
date_to = date_from + datetime.timedelta(weeks=1)
yec = YahooEarningsCalendar()
earnings = yec.earnings_between(date_from, date_to)
errors = []
earnings = [{'ticker': 'LULU'}]
for earning in earnings:
ticker = earning['ticker']
stock = tickers.find_one({'symbol': ticker})
if stock is not None:
try:
series = iex_earnings.IEXEarnings([ticker]).read()
except KeyError:
print(f"Error getting the iex earnings for {ticker}")
s = {'ticker': ticker}
close as close_before
FROM close_yst2) yst3
ON cur.rank = yst3.rank+1
'''
df = pd.read_sql_query(qry, conn, parse_dates=["date"])
# print(df.head(1104))
date_from = datetime.datetime.strptime('Aug 5 2016', '%b %d %Y').date()
date_to = datetime.date.today()
yec = YahooEarningsCalendar()
list_result = yec.earnings_on(date_from)
df_table = pd.DataFrame(yec.earnings_between(date_from, date_to))
df_table = df_table[[
'companyshortname', 'startdatetime', 'startdatetimetype', 'ticker'
]]
print(df_table)
#print(yec.earnings_on(date_from)[])
#print(yec.earnings_between(date_from, date_to))
# data['4. close'].plot()
# plt.title('Intraday Times Series for the MSFT stock (1 min)')
# plt.show()
#
# print("script is running")
earnings_list = yec.earnings_on(report_date) earnings_df = pd.DataFrame(earnings_list) earnings_df = earnings_df.drop(columns = ['gmtOffsetMilliSeconds', 'quoteType', 'timeZoneShortName']) earnings_df.columns = ['Ticker', 'Company Name', 'DateTime', 'Type', 'EPS Estimate', 'EPS Actual', 'EPS Surprise PCT'] earnings_df = earnings_df[['Ticker', 'Company Name', 'DateTime', 'Type', 'EPS Estimate', 'EPS Actual', 'EPS Surprise PCT']] earnings_df['DateTime'] = pd.to_datetime(earnings_df['DateTime']).dt.tz_localize(None) print(earnings_df) # Downloading the earnings for a range of dates DAYS_AHEAD = 7 start_date = datetime.now().date() end_date = (datetime.now().date() + timedelta(days=DAYS_AHEAD)) yec = YahooEarningsCalendar() earnings_list = yec.earnings_between(start_date, end_date) earnings_df = pd.DataFrame(earnings_list) earnings_df = earnings_df.drop(columns = ['gmtOffsetMilliSeconds', 'quoteType', 'timeZoneShortName']) earnings_df.columns = ['Ticker', 'Company Name', 'DateTime', 'Type', 'EPS Estimate', 'EPS Actual', 'EPS Surprise PCT'] earnings_df = earnings_df[['Ticker', 'Company Name', 'DateTime', 'Type', 'EPS Estimate', 'EPS Actual', 'EPS Surprise PCT']] earnings_df['DateTime'] = pd.to_datetime(earnings_df['DateTime']).dt.tz_localize(None) print(earnings_df) # Downloading the earnings for a specific product TICKER = 'TWTR' DAYS_AHEAD = 180 start_date = datetime.now().date() end_date = (datetime.now().date() + timedelta(days=DAYS_AHEAD)) yec = YahooEarningsCalendar()
cursor.execute(q)
#set dates
now = datetime.now()
startDate = now.strftime('%b %d %Y %I:%M%p')
print(startDate)
endDate = now + timedelta(days=60)
endDate = endDate.strftime('%b %d %Y %I:%M%p')
print(endDate)
startDate = datetime.strptime(
startDate, '%b %d %Y %I:%M%p')
endDate = datetime.strptime(
endDate, '%b %d %Y %I:%M%p')
yec = YahooEarningsCalendar()
xx = yec.earnings_between(startDate, endDate)
print(xx)
sys.exit()
for x in xx:
print("start--->{}".format(x['startdatetime']))
print("ticker--->{}".format(x['ticker']))
print("epsestimate--->{}".format(x['epsestimate']))
print("epsactual--->{}".format(x['epsactual']))
print("epssurprisepct--->{}".format(x['epssurprisepct']))
try:
q = "insert ignore into yahoo_earnings (earnings_date, ticker, epsestimate, epsactual, epssurprisepct) values (%s,%s,%s,%s,%s)"
args = (x['startdatetime'], x['ticker'].lower(), x['epsestimate'],
x['epsactual'], x['epssurprisepct'])
cursor.execute(q, args)
def get_earnings_range(date_from, date_to):
yec = YahooEarningsCalendar()
el = yec.earnings_between(date_from, date_to)
print_future_earnings(el, name_list)
class EarningsManager:
def __init__(self, criteria):
self.yec = YahooEarningsCalendar()
self.criteria = criteria
def get_earnings(self, date_range):
filename = '../data/' + Utils.get_proper_date_format(date_range[0]) + '_' + \
Utils.get_proper_date_format(date_range[1]) + '_earnings.csv'
# If datafile already exists, load from that instead
if path.exists(filename):
data = Utils.load_csv_to_dataframe(filename)
else:
# File doesn't exist, write to it
try:
data_dict = self.yec.earnings_between(date_range[0], date_range[1])
except:
print('Yahoo Finance Earnings Calender is down. Try again later.')
return pd.DataFrame.empty
data = pd.DataFrame.from_dict(data_dict)
# Remove unused columns
unused = ['startdatetimetype', 'timeZoneShortName', 'gmtOffsetMilliSeconds', 'quoteType']
data.drop(unused, axis=1, inplace=True)
# Add more columns of interest
ticker_data = {'volume': {}, 'marketCap': {}, 'lastClose': {}}
# Go through each ticker to find ones that don't meet certain criteria
tickers = data['ticker'].tolist()
for ticker in tickers:
curr_share = yf.Ticker(ticker)
try:
# Attempt to get ticker data
curr_info = curr_share.info
vl = curr_info['volume']
mc = curr_info['marketCap']
lc = curr_info['previousClose']
cr = curr_info['currency']
except:
print('Bad data on ticker ' + ticker + '. Deleting from results.')
data = data[data.ticker != ticker]
continue
# Check if passes criteria
if self.criteria(vl, mc, lc, cr):
ticker_data['volume'][vl] = ticker
ticker_data['marketCap'][mc] = ticker
ticker_data['lastClose'][lc] = ticker
else:
print('Ticker ' + ticker + ' did not meet the criteria. Deleting from results.')
data = data[data.ticker != ticker]
# Add new columns that passed criteria to dataframe
data['volume'] = ticker_data['volume']
data['marketCap'] = ticker_data['marketCap']
data['lastClose'] = ticker_data['lastClose']
data.reset_index(drop=True, inplace=True) # Reset indices after removing
Utils.write_dataframe_to_csv(data, filename)
return data
def get_earnings_in_range(self, date_range):
return self.get_earnings(date_range)
def get_next_week_earnings(self):
week_range = Utils.get_following_week_range()
data = self.get_earnings(week_range)
return data