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)