def SourceHistoricPrices():
if info == 1: print('[INFO] Fetching stock prices for portfolio holdings')
# Set Up for Tiingo
config = {}
config['session'] = True
file = open("API Code", "r")
code = file.read()
config['api_key'] = code
client = TiingoClient(config)
# Create a list of tickers for the API call
Tickers = []
i = 0
for ticker in data:
while i <= len(data):
Tickers.append(data[ticker][i])
i = i + 1
if info == 1: print('[INFO] Portfolio Holdings determined as', Tickers)
if info == 1:
print('[INFO] Portfolio Weights determined as', data['Quantity'])
# Call the API and store the data
global HistData
startDate = dateforNoOfScenarios(today)
endDate = today
HistData = client.get_dataframe(Tickers,
startDate,
endDate,
metric_name='close')
print(HistData.size)
if info == 1:
print('[INFO] Fetching stock prices completed.', len(HistData),
'days.')
return (HistData)
class TestCryptoEndpoints(TestCase):
def setUp(self):
self._client = TiingoClient()
@vcr.use_cassette('tests/fixtures/crypto_metadata.yaml')
def test_crypto_metadata(self):
metadata = self._client.get_crypto_metadata(tickers=['btcusd', 'fldcbtc'])
assert len(metadata) == 2 # 1 item per ticker
assert metadata[0]['ticker'] == 'btcusd'
assert metadata[1]['ticker'] == 'fldcbtc'
@vcr.use_cassette('tests/fixtures/crypto_top_of_book.yaml')
def test_crypto_top_of_book(self):
top_of_book = self._client.get_crypto_top_of_book(tickers=['btcusd', 'fldcbtc'], includeRawExchangeData=True)
assert len(top_of_book) == 2 # 1 each for btcusd and fldcbtc
first_ticker_data = top_of_book[0]
assert 'topOfBookData' in first_ticker_data
assert 'exchangeData' in first_ticker_data
@vcr.use_cassette('tests/fixtures/crypto_price_history.yaml')
def test_crypto_price_history(self):
price_history = self._client.get_crypto_price_history(tickers=['btcusd', 'fldcbtc'],
startDate='2019-05-01', endDate='2019-05-02',
includeRawExchangeData=True, resampleFreq='1day')
assert len(price_history) == 2 # 1 item per ticker
assert len(price_history[0]['priceData']) == 2 # 1 set of data per day
assert 'exchangeData' in price_history[0] # includedRawExchangeData
def volume(this_object, stock, days, prevDays):
config = {}
config['session'] = True
#Probably shouldn't use my API-key
config['api_key'] = "5bb2f699440e3f8aeba0b5d8ab6467c00af165bc"
prevDate, currentDate = this_object.dates(days)
client = TiingoClient(config)
ticker_history = client.get_dataframe(stock,
startDate=prevDate,
endDate=currentDate)
pDate, cDate = this_object.dates(prevDays)
ticker_history_last = client.get_dataframe(stock,
startDate=pDate,
endDate=cDate)
#Array of previous volumes
X = np.median(ticker_history['volume'])
Y = np.average(ticker_history_last['volume'])
#print(X)
#print(Y)
#returns average lastdays divided by average of Days(argument)
return np.average(Y) / np.average(X)
def get_tiingo_prices(assets, startDate, endDate):
'''
Download pandas DataFrame of Tiingo data of adjusted close prices
:param assets: list of asset symbols
:param startDate: start date in format '%Y-%m-%d'
:param endDate: end date in format '%Y-%m-%d'
:return: pandas DataFrame
'''
from tiingo import TiingoClient
TIINGO_API_KEY = 'c5ec6d8655e80ab3318af299a695443c62494efe'
config = {
'api_key': TIINGO_API_KEY,
'session':
True # Reuse HTTP sessions across API calls for better performance
}
# Throughout the rest of this notebook, you'll use the "client" to interact with the Tiingo backend services.
client = TiingoClient(config)
return client.get_dataframe(assets,
frequency='daily',
metric_name='close',
startDate=startDate,
endDate=endDate)
def tiingo_data(ticker, start, end):
config = {}
# To reuse the same HTTP Session across API calls (and have better performance), include a session key.
config['session'] = True
# Obtain Tiingo API Key
myFile = open("/Users/brittanythomas/PycharmProjects/SystemTraderV2/tiingoAPIkey.txt", "r")
myAPIkey = myFile.readline()
myFile.close()
config['api_key'] = myAPIkey
# Initialize
client = TiingoClient(config)
try:
print('Trying to pull Tiingo data for '+ticker)
df = client.get_dataframe(ticker,
startDate=start,
endDate=end,
frequency='daily')
except:
print("Unexpected error:", sys.exc_info()[0])
time.sleep(1)
try:
print('AGAIN - Trying to pull Tiingo data for ' + ticker)
df = client.get_dataframe(ticker,
startDate=start,
endDate=end,
frequency='daily')
except:
print('Could not pull Tiingo data for ' + ticker)
print("Unexpected error:", sys.exc_info()[0])
return None
return df
def get_desc(ticker):
''' Get Description and Stock Exchange Name for ticker
'''
from tiingo import TiingoClient
client = TiingoClient({'api_key': os.getenv('TIINGO')})
df = client.get_ticker_metadata(str(ticker))
df = pd.DataFrame(df, index=[0])
return df[['ticker','description','exchangeCode']]
def make_portfolio(tickers,start='2017-01-01'):
'''Function that download stock data for companies from ticker list
We don't need to do pivot table here '''
from tiingo import TiingoClient
client = TiingoClient({'api_key':os.getenv('TIINGO')})
data = client.get_dataframe(tickers,frequency='daily',metric_name='adjClose',startDate=start)
data.index = data.index.date
return data
def get_prices(ticker_file, tiingo_key, nyse_pref, end_date):
"""Obtains close of day prices for each ticker..
nyse_pref: Attempt to recognize tickers with PR in the ticker name and
convert to tiingo friendly format for the lookup.
"""
prices = []
config = {}
config['session'] = True
config['api_key'] = tiingo_key
delta = timedelta(days=365)
start_date = end_date - delta
client = TiingoClient(config)
with open(ticker_file, newline = '') as t_file:
# dialect = csv.Sniffer().sniff(csvfile.read(1024))
# csvfile.seek(0)
# reader = csv.reader(csvfile, dialect)
for line in t_file: # Each line contains a ticker
#print(line )
ticker = line.strip()
if nyse_pref is True:
if('PR') in ticker:
tiingo_ticker = ticker.replace(' ','')
tiingo_ticker = tiingo_ticker.replace('PR','-P-')
print("Found a Preferred Stock {} and looked up {}".format(
ticker,tiingo_ticker))
else:
tiingo_ticker = ticker
else:
tiingo_ticker = ticker
try:
# price = client.get_ticker_price(tiingo_ticker, startDate=end_date,endDate=end_date)
ly_hist = client.get_dataframe(tickers=tiingo_ticker,
frequency='daily',
startDate=start_date,
endDate=end_date)
tot_divs = ly_hist['divCash'].sum()
# Forced to use numerical indexing for the last row hence the cryptic -1,0
print("Ticker = {} Price = {:.3f} Divs = {:.2f}"
.format(ticker, ly_hist.iloc[-1,0], tot_divs))
prices.append((ticker,
round(ly_hist.iloc[-1,0],3),
round(tot_divs, 3)))
except Exception as ex:
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
print(message)
print('tingo did not find {}'.format(ticker))
return prices
class TestTiingoWithoutPython(TestCase):
def setUp(self):
if pandas_is_installed:
self.skipTest("test_tiingo_without_pandas: Pandas is installed.")
else:
self._client = TiingoClient()
@vcr.use_cassette('tests/fixtures/ticker_price_pandas_single.yaml')
def test_get_dataframe_without_pandas(self):
with self.assertRaises(InstallPandasException):
self._client.get_dataframe("GOOGL")
def from_rest(self, ticker=None, days=260):
"""Download data from Tiingo"""
self.cache_filename = "%s/%s.json" % (self.cache_directory, ticker)
if os.path.exists(self.cache_filename):
buffer = self.from_json(self.cache_filename)
#print("Loading from cache")
else:
client = TiingoClient()
data = client.get_ticker_price(ticker,
startDate=last_business_day(days),
endDate=last_business_day())
result = []
column_list = None
set_columns = False
for row in data:
buffer = {}
if column_list is None and not set_columns:
column_list = []
for column in row:
# Loop through each rows column list
if ("adj" in column) or (column == 'date'):
# Only grab adjusted data (to account for any splits)
column_name = column.replace("adj", "").lower()
if not set_columns:
column_list.append(
column.replace("adj", "").lower())
if column == 'date':
buffer[column_name] = row[column].split("T")[0]
else:
buffer[column_name] = row[column]
if not set_columns and column_list is not None:
# Only set the column list once
set_columns = True
result.append(buffer)
data = pandas.DataFrame(result, columns=column_list)
data = data.sort_values(by=['date'])
if 'EDGELORD_CACHE_DIR' in os.environ:
data.to_json("%s/%s.json" % (self.cache_directory, ticker))
buffer = self.build(data)
return buffer
def out_stock_excel(item_id,
startdate=dt.datetime(2010, 1, 1),
enddate=dt.datetime.now()):
file_path = './out/' + item_id + '_stock.xlsx'
writer = pd.ExcelWriter(file_path)
config = {'api_key': '138fd2efede60c466126add93ebf585fc5492f75'}
client = TiingoClient(config)
df = client.get_dataframe(item_id,
frequency='daily',
startDate='{:%Y-%m-%d}'.format(startdate),
endDate='{:%Y-%m-%d}'.format(enddate))
df.index = df.index.tz_convert(None)
df.to_excel(writer, encoding='utf-8', engine='openpyxl')
writer.save()
def setUp(self):
self._client = TiingoClient()
self.article_keys = [ # Properties every article should have.
'description', 'title', 'url', 'publishedDate', 'tags', 'source',
'tickers', 'crawlDate', 'id'
]
# Search for articles about a topic
self.num_articles = 1
self.search_params = {
"tickers": ["aapl", "googl"],
"tags": ["Technology", "Bitcoin"],
"startDate": "2016-01-01",
"endDate": "2017-08-31",
"sources": ['cnbc.com', 'altcointoday.com'],
"limit": self.num_articles
}
def stockprices(this_object, stock, days):
config = {}
config['session'] = True
#Probably shouldn't use my API-key
config['api_key'] = "5bb2f699440e3f8aeba0b5d8ab6467c00af165bc"
prevDate, currentDate = this_object.dates(days)
client = TiingoClient(config)
ticker_history = client.get_dataframe(stock,
startDate=prevDate,
endDate=currentDate)
X = np.array(ticker_history['close'])
return X
def main():
global TODAY
global START_DATE
args = get_args()
client = TiingoClient()
TODAY = date.today()
START_DATE = TODAY + relativedelta(months=-args.price_history)
ticker_a = args.tickers[0]
ticker_b = args.tickers[-1]
prices_a = get_close_prices(client, ticker_a)
prices_b = get_close_prices(client, ticker_b)
if len(prices_a) != len(prices_b):
print(
"WARNING! You have gone past the total lifetime of at least one of your assets."
" This may affect model accuracy.")
correlation_ab = calc_correlation(prices_a, prices_b)
expected_returns = []
standard_deviations = []
for percent in range(0, 101):
variance = calc_portfolio_variance(percent, prices_a, (100 - percent),
prices_b, correlation_ab)
stdev = math.sqrt(variance)
expected_ret = calc_portfolio_expected_return(percent, prices_a,
(100 - percent),
prices_b)
standard_deviations.append(stdev)
expected_returns.append(expected_ret)
plt.title(f"Return vs. Risk\n{int(args.price_history/12)} year model")
plt.plot(standard_deviations, expected_returns, 'b')
plt.ylabel('Expected Return (%)')
plt.xlabel('Standard Deviation (%)')
# Plot Minimum Variance
percent_a, percent_b = calc_minimum_variance_allocation(prices_a, prices_b)
min_var_er = calc_portfolio_expected_return(percent_a * 100, prices_a,
percent_b * 100, prices_b)
min_var_stdev = math.sqrt(
calc_portfolio_variance(percent_a * 100, prices_a, percent_b * 100,
prices_b, correlation_ab))
percent_a_label = int(math.ceil(percent_a * 100))
percent_b_label = int(math.floor(percent_b * 100))
min_var_label = "{} {}%, {} {}%".format(ticker_a, percent_a_label,
ticker_b, percent_b_label)
plt.plot(min_var_stdev, min_var_er, 'ro-')
plt.annotate(min_var_label, (min_var_stdev, min_var_er))
plt.show()
def __init__(self,
asset_type,
adjust_prices=True,
symbols=None,
tiingo_api_key=None,
start_date=None,
end_date=None):
self.asset_type = asset_type
self.adjust_prices = adjust_prices
self.symbols = symbols
self.start_date = start_date
self.end_date = end_date
self.tiingo_api_key = tiingo_api_key
self.config = {'session': True, 'api_key': self.tiingo_api_key}
self.client = TiingoClient(self.config)
self.asset_bar_frames = self._load_csvs_into_dfs()
self.asset_bid_ask_frames = self._convert_bars_into_bid_ask_dfs()
def instantiate_conn_tiingo():
# Set Values to Configuration
config = {}
config['session'] = True
config['api_key'] = input('Tiingo token')
# Pass Configurations to TiingoClient Server / api
client = TiingoClient(config)
# Return Connection
return client
class TestTickerPrices(TestCase):
def setUp(self):
self._client = TiingoClient()
@vcr.use_cassette('tests/fixtures/ticker_metadata.yaml')
def test_ticker_metadata(self):
"""Refactor this with python data schemavalidation"""
metadata = self._client.get_ticker_metadata("GOOGL")
assert metadata.get('ticker') == "GOOGL"
assert metadata.get("name")
@vcr.use_cassette('tests/fixtures/ticker_metadata.yaml')
def test_ticker_metadata_as_object(self):
metadata = self._client.get_ticker_metadata("GOOGL", fmt="object")
assert metadata.ticker == "GOOGL" # Access property via ATTRIBUTE
assert metadata.name # (contrast with key access above
@vcr.use_cassette('tests/fixtures/ticker_price.yaml')
def test_ticker_price(self):
"""Test that EOD Prices Endpoint works"""
prices = self._client.get_ticker_price("GOOGL")
assert len(prices) == 1
assert prices[0].get('adjClose')
@vcr.use_cassette('tests/fixtures/ticker_price.yaml')
def test_ticker_price_as_object(self):
"""Test that EOD Prices Endpoint works"""
prices = self._client.get_ticker_price("GOOGL", fmt="object")
assert len(prices) == 1
assert hasattr(prices[0], 'adjClose')
@vcr.use_cassette('tests/fixtures/ticker_price_with_date.yaml')
def test_ticker_price_with_date(self):
"""Test the EOD Prices Endpoint with data param"""
prices = self._client.get_ticker_price("GOOGL",
startDate="2015-01-01",
endDate="2015-01-05")
self.assertGreater(len(prices), 1)
@vcr.use_cassette('tests/fixtures/ticker_price_with_date_csv.yaml')
def test_ticker_price_with_csv(self):
"""Confirm that CSV endpoint works"""
prices_csv = self._client.get_ticker_price("GOOGL",
startDate="2015-01-01",
endDate="2015-01-05",
fmt='csv')
reader = csv.reader(prices_csv.splitlines(), delimiter=",")
rows = list(reader)
assert len(rows) > 2 # more than 1 day of data
@vcr.use_cassette('tests/fixtures/list_stock_tickers.yaml')
def test_list_stock_tickers(self):
tickers = self._client.list_stock_tickers()
assert len(tickers) > 1
assert all(ticker['assetType'] == 'Stock' for ticker in tickers)
def gen_stock_chart(item_id,
startdate=dt.datetime(2010, 1, 1),
enddate=dt.datetime.now()):
config = {'api_key': '138fd2efede60c466126add93ebf585fc5492f75'}
client = TiingoClient(config)
df = client.get_dataframe(item_id,
frequency='weekly',
startDate='{:%Y-%m-%d}'.format(startdate),
endDate='{:%Y-%m-%d}'.format(enddate))
df = df.loc[:, ['open', 'close', 'low', 'high']]
data = np.array(df).tolist()
index = []
for i in df.index.tolist():
index.append("{:%Y-%m-%d}".format(i.to_pydatetime()))
c = kline_datazoom_slider_position(index, data, item_id)
return c
def load_data(ticker):
"""Return data for the given ticker symbol"""
client = TiingoClient()
data = client.get_ticker_price(ticker,
startDate=last_business_day(300),
endDate=last_business_day())
result = []
column_list = None
set_columns = False
for row in data:
buffer = {}
if column_list is None and not set_columns:
column_list = []
for column in row:
# Loop through each rows column list
if ("adj" in column) or (column == 'date'):
# Only grab adjusted data (to account for any splits)
column_name = column.replace("adj", "").lower()
if not set_columns:
column_list.append(column.replace("adj", "").lower())
if column == 'date':
buffer[column_name] = row[column].split("T")[0]
else:
buffer[column_name] = row[column]
if not set_columns and column_list is not None:
# Only set the column list once
set_columns = True
result.append(buffer)
return pandas.DataFrame(result, columns=column_list)
def __init__(self, symbol, years=5, nmacd=(12, 26, 9), ncci=20, nrsi=14):
register_matplotlib_converters()
self.nmacd = nmacd
self.ncci = ncci
self.nrsi = nrsi
# TIINGO Setup
config = {}
config['api_key'] = os.getenv('TINGO_SECRET')
client = TiingoClient(config)
self.symbol = symbol
resp = client.get_ticker_price(
self.symbol,
fmt='csv',
startDate=datetime.datetime.today() - relativedelta(years=years),
endDate=datetime.datetime.today()
)
self.data = pd.read_csv(io.StringIO(resp))
if 'date' not in self.data:
raise ti.InvalidOptionError
f = lambda col: datetime.datetime.strptime(col, '%Y-%m-%d')
self.data['date'] = self.data['date'].apply(f)
self.data.index = self.data['date']
self.data['avg'] = (self.data['close'] + self.data['low'] + self.data['high']) / 3
self.data['returns'] = (self.data['open'] - self.data['close']) / self.data['open']
self.lognorm = lambda x: scipy.stats.lognorm(x, loc=self.data['avg'].mean(), scale=self.data['avg'].std())
# Indicators
macd, macd_signal, macd_histogram = ti.macd(self.data, *nmacd)
self.indicators = {
'cci': ti.cci(self.data, ncci),
'rsi': ti.rsi(self.data, nrsi),
'shortema': ti.ema(self.data, nmacd[0]),
'longema': ti.ema(self.data, nmacd[1]),
'macd': macd,
'macd_signal': macd_signal,
'macd_histogram': macd_histogram,
'show': self.data
}
def update_graph(n_clicks, stock_ticker, start_date, end_date):
start = datetime.strptime(start_date[:10], '%Y-%m-%d')
end = datetime.strptime(end_date[:10], '%Y-%m-%d')
traces = []
config = {}
# To reuse the same HTTP Session across API calls (and have better performance), ˓→include a session key.
config['api_key'] = '94bc55bd22b602be267b1449201ce793e96fa607'
# If you don't have your API key as an environment variable, # pass it in via a configuration dictionary. config['api_key'] = "MY_SECRET_API_KEY"
# Initialize
client = TiingoClient(config)
for tic in stock_ticker:
df = client.get_dataframe(tic, start, end)
traces.append({'x': df.index, 'y': df.close, 'name': tic})
fig = {
'data': traces,
'layout': {
'title': ', '.join(stock_ticker) + ' Closing Prices'
}
}
return fig
class TestNews(TestCase):
def setUp(self):
self._client = TiingoClient()
self.article_keys = [ # Properties every article should have.
'description', 'title', 'url', 'publishedDate', 'tags', 'source',
'tickers', 'crawlDate', 'id'
]
# Search for articles about a topic
self.num_articles = 1
self.search_params = {
"tickers": ["aapl", "googl"],
"tags": ["Technology", "Bitcoin"],
"startDate": "2016-01-01",
"endDate": "2017-08-31",
"sources": ['washingtonpost.com', 'altcointoday.com'],
"limit": self.num_articles
}
@vcr.use_cassette('tests/fixtures/news.yaml')
def test_get_news_articles(self):
articles = self._client.get_news(**self.search_params)
assert len(articles) == self.num_articles
for article in articles:
assert all(key in article for key in self.article_keys)
@vcr.use_cassette('tests/fixtures/news_bulk.yaml')
def test_get_news_bulk(self):
"""Fails because this API key lacks institutional license"""
with self.assertRaises(RestClientError):
value = self._client.get_bulk_news(file_id="1")
assert value
@vcr.use_cassette('tests/fixtures/news_bulk_file_ids.yaml')
def test_get_news_bulk_ids(self):
"""Fails because this API key lacks institutional license"""
with self.assertRaises(RestClientError):
value = self._client.get_bulk_news()
assert value
# Tests "object" formatting option
@vcr.use_cassette('tests/fixtures/news.yaml')
def test_get_news_as_objects(self):
articles = self._client.get_news(fmt="object", **self.search_params)
assert len(articles) == self.num_articles
for article in articles: # check if attribute access works
assert all(hasattr(article, key) for key in self.article_keys)
@vcr.use_cassette('tests/fixtures/news_bulk_file_ids.yaml')
def test_get_news_bulk_ids_as_objects(self):
"""Fails because this API key lacks institutional license"""
with self.assertRaises(RestClientError):
value = self._client.get_bulk_news(fmt="object")
assert value
@vcr.use_cassette('tests/fixtures/news_bulk.yaml')
def test_news_bulk_as_objects(self):
"""Fails because this API key lacks institutional license"""
with self.assertRaises(RestClientError):
assert self._client.get_bulk_news(file_id="1", fmt="object")
def tiingo(self, startNum, endNum):
fx = clsfunctions()
config = {}
config['session'] = True
config['api_key'] = ""
client = TiingoClient(config)
for i in range(startNum, endNum):
ticker = fx.getTicker(i)
data = client.get_ticker_price(ticker,
fmt='json',
startDate='1993-01-29',
endDate='2019-07-12',
frequency='daily')
columns = ['date', 'open', 'high', 'low', 'close', 'volume']
df = pd.DataFrame(data, columns=columns)
df['ticker'] = ticker
df.to_csv('c:/users/paul/desktop/tickers/' + ticker + '.csv')
def get_data():
"""
gathers data for plotting and prediction from TiingoClient for stock
specified in the function.
Parameters:
None
Returns:
None
"""
now = datetime.datetime.now()
end = str(now.year) + '-' + str(now.month) + '-' + str(now.day-1)
start = str(now.year - 10) + '-' + str(now.month) + '-' + str(now.day-1)
config = {'api_key': '9ce6be2cc6e402a69ff4cb803168c024c4518216',
'session': True}
client = TiingoClient(config)
google = client.get_dataframe("GOOGL",
startDate=start,
endDate=end,
frequency='daily')
# google.to_csv('../data/google.csv')
microsoft = client.get_dataframe("MSFT",
startDate=start,
endDate=end,
frequency='daily')
# microsoft.to_csv('../data/microsoft.csv')
apple = client.get_dataframe("AAPL",
startDate=start,
endDate=end,
frequency='daily')
# apple.to_csv('../data/apple.csv')
jnj = client.get_dataframe("JNJ",
startDate=start,
endDate=end,
frequency='daily')
# jnj.to_csv('../data/jnj.csv')
amazon = client.get_dataframe("AMZN",
startDate=start,
endDate=end,
frequency='daily')
# amazon.to_csv('../data/amazon.csv')
return google, microsoft, apple, jnj, amazon
class TestFundamentals(TestCase):
def setUp(self):
self._client = TiingoClient()
@vcr.use_cassette('tests/fixtures/fundamentals_definitions.yaml')
def test_definitions(self):
definitions = self._client.get_fundamentals_definitions("GOOGL")
assert len(definitions) > 1
@vcr.use_cassette('tests/fixtures/fundamentals_definitions_csv.yaml')
def test_definitions_csv(self):
definitions = self._client.get_fundamentals_definitions("GOOGL",
fmt='csv')
assert len(definitions) > 1
@vcr.use_cassette('tests/fixtures/fundamentals_daily.yaml')
def test_daily(self):
daily = self._client.get_fundamentals_daily("GOOGL",
startDate='2020-1-1',
endDate='2020-4-1')
assert len(daily) > 1
@vcr.use_cassette('tests/fixtures/fundamentals_daily_csv.yaml')
def test_daily_with_csv(self):
daily = self._client.get_fundamentals_daily("GOOGL",
startDate='2020-1-1',
endDate='2020-4-1',
fmt='csv')
assert len(daily) > 1
@vcr.use_cassette('tests/fixtures/fundamentals_statements.yaml')
def test_statements(self):
statements = self._client.get_fundamentals_statements(
"GOOGL", startDate='2020-1-1', endDate='2020-4-1')
assert len(statements) > 1
@vcr.use_cassette(
'tests/fixtures/fundamentals_statements_with_as_reported.yaml')
def test_statements(self):
statements = self._client.get_fundamentals_statements(
"GOOGL", startDate='2020-1-1', endDate='2020-4-1', asReported=True)
assert len(statements) > 1
@vcr.use_cassette('tests/fixtures/fundamentals_statements_csv.yaml')
def test_statements_with_csv(self):
statements = self._client.get_fundamentals_statements(
"GOOGL", startDate='2020-1-1', endDate='2020-4-1', fmt='csv')
assert len(statements) > 1
class StockDataRetriever:
client = ""
def __init__(self):
config = {}
config['session'] = True
config['api_key'] = "b061027e46f532a4cfb0e91a9ff444a0582302cc"
self.client = TiingoClient(config)
def getData(self, symbol, startDate, endDate):
# return self.client.get_ticker_price(symbol, fmt, startDate, endDate, frequency)
return self.client.get_ticker_price(symbol,
fmt='json',
startDate=startDate,
endDate=endDate,
frequency='daily')
@staticmethod
def getHigh(stockData, daysAgo):
daysAgo = -1 * daysAgo
return stockData[daysAgo].get('high')
@staticmethod
def getLow(stockData, daysAgo):
daysAgo = -1 * daysAgo
return stockData[daysAgo].get('low')
@staticmethod
def getOpen(stockData, daysAgo):
daysAgo = -1 * daysAgo
return stockData[daysAgo].get('open')
@staticmethod
def getClose(stockData, daysAgo):
daysAgo = -1 * daysAgo
return stockData[daysAgo].get('close')
def setUp(self):
self._client = TiingoClient()
class TestTickerPrices(TestCase):
def setUp(self):
self._client = TiingoClient()
@vcr.use_cassette('tests/fixtures/ticker_metadata.yaml')
def test_ticker_metadata(self):
"""Refactor this with python data schemavalidation"""
metadata = self._client.get_ticker_metadata("GOOGL")
assert metadata.get('ticker') == "GOOGL"
assert metadata.get("name")
@vcr.use_cassette('tests/fixtures/ticker_metadata.yaml')
def test_ticker_metadata_as_object(self):
metadata = self._client.get_ticker_metadata("GOOGL", fmt="object")
assert metadata.ticker == "GOOGL" # Access property via ATTRIBUTE
assert metadata.name # (contrast with key access above
@vcr.use_cassette('tests/fixtures/ticker_price.yaml')
def test_ticker_price(self):
"""Test that EOD Prices Endpoint works"""
prices = self._client.get_ticker_price("GOOGL")
assert len(prices) == 1
assert prices[0].get('adjClose')
@vcr.use_cassette('tests/fixtures/ticker_price_weekly.yaml')
def test_ticker_price(self):
"""Test that weekly frequency works"""
prices = self._client.get_ticker_price("GOOGL",
startDate='2018-01-05',
endDate='2018-01-19',
frequency='weekly')
assert len(prices) == 3
assert prices[0].get('adjClose')
@vcr.use_cassette('tests/fixtures/ticker_price.yaml')
def test_ticker_price_as_object(self):
"""Test that EOD Prices Endpoint works"""
prices = self._client.get_ticker_price("GOOGL", fmt="object")
assert len(prices) == 1
assert hasattr(prices[0], 'adjClose')
@vcr.use_cassette('tests/fixtures/ticker_price_with_date.yaml')
def test_ticker_price_with_date(self):
"""Test the EOD Prices Endpoint with data param"""
prices = self._client.get_ticker_price("GOOGL",
startDate="2015-01-01",
endDate="2015-01-05")
self.assertGreater(len(prices), 1)
@vcr.use_cassette('tests/fixtures/ticker_price_with_date_csv.yaml')
def test_ticker_price_with_csv(self):
"""Confirm that CSV endpoint works"""
prices_csv = self._client.get_ticker_price("GOOGL",
startDate="2015-01-01",
endDate="2015-01-05",
fmt='csv')
reader = csv.reader(prices_csv.splitlines(), delimiter=",")
rows = list(reader)
assert len(rows) > 2 # more than 1 day of data
@vcr.use_cassette('tests/fixtures/intraday_price.yaml')
def test_intraday_ticker_price(self):
"""Test the EOD Prices Endpoint with data param"""
prices = self._client.get_ticker_price("GOOGL",
startDate="2018-01-02",
endDate="2018-01-02",
frequency="30Min")
self.assertGreater(len(prices), 1)
@vcr.use_cassette('tests/fixtures/list_all_tickers.yaml')
def test_list_all_tickers(self):
tickers = self._client.list_tickers()
assert len(tickers) > 1
assert any(ticker['assetType'] == 'Stock' for ticker in tickers)
print(tickers)
assert any(ticker['assetType'] == 'Mutual Fund' for ticker in tickers)
assert any(ticker['assetType'] == 'ETF' for ticker in tickers)
@vcr.use_cassette('tests/fixtures/list_all_tickers.yaml')
def test_list_multi_tickers(self):
tickers = self._client.list_tickers(['Stock', 'ETF'])
assert len(tickers) > 1
assert any(ticker['assetType'] == 'Stock' for ticker in tickers)
assert any(ticker['assetType'] == 'ETF' for ticker in tickers)
assert all(ticker['assetType'] != 'Mutual Fund' for ticker in tickers)
@vcr.use_cassette('tests/fixtures/list_all_tickers.yaml')
def test_list_stock_tickers(self):
tickers = self._client.list_stock_tickers()
assert len(tickers) > 1
assert all(ticker['assetType'] == 'Stock' for ticker in tickers)
@vcr.use_cassette('tests/fixtures/list_fund_tickers.yaml')
def test_list_fund_tickers(self):
tickers = self._client.list_fund_tickers()
assert len(tickers) > 1
assert all(ticker['assetType'] == 'Mutual Fund' for ticker in tickers)
@vcr.use_cassette('tests/fixtures/list_etf_tickers.yaml')
def test_list_etf_tickers(self):
tickers = self._client.list_etf_tickers()
assert len(tickers) > 1
assert all(ticker['assetType'] == 'ETF' for ticker in tickers)
def test_invalid_frequency_error(self):
with self.assertRaises(InvalidFrequencyError):
prices = self._client.get_ticker_price("GOOGL",
startDate="2018-01-02",
endDate="2018-01-02",
frequency="1.5mins")
def test_api_key_missing_error(self):
config = {'api_key': ""}
with self.assertRaises(RuntimeError):
client = TiingoClient(config=config)
assert client
def test_client_repr():
"""Test representation of client when logged to console"""
client = TiingoClient()
base_url = "https://api.tiingo.com"
assert repr(client) == "<TiingoClient(url=\"{}\")>".format(base_url)
