def fundamentals_from_fids(fids_list, sandbox=False): if sandbox == False: intrinio_sdk.ApiClient().configuration.api_key['api_key'] = config('INTRINIO_KEY') security_api = intrinio_sdk.SecurityApi() elif sandbox == True: intrinio_sdk.ApiClient().configuration.api_key['api_key'] = config('INTRINIO_SANDBOX_KEY') security_api = intrinio_sdk.SecurityApi() # Initialize api's fapi = intrinio_sdk.FundamentalsApi() fund_dict = {} for id in fids_list: for attempt in range(5): try: fundamentals_ret = fapi.get_fundamental_standardized_financials(id) except: print('Connection error. Retry attempt {}'.format(attempt)) sleep(2) else: break fund_get = fundamentals_ret.standardized_financials_dict fund_info = fundamentals_ret.fundamental_dict funds = {} funds['date'] = fund_info['filing_date'] funds['fiscal_year'] = fund_info['fiscal_year'] funds['quarter'] = fund_info['fiscal_period'] for f in fund_get: funds[f['data_tag']['tag'].lower()] = f['value'] fund_dict[id] = funds return fund_dict
def get_intrinio_fids(tkr_id, after_date, end_date='', sandbox=False): if sandbox == False: intrinio_sdk.ApiClient().configuration.api_key['api_key'] = config('INTRINIO_KEY') security_api = intrinio_sdk.SecurityApi() elif sandbox == True: intrinio_sdk.ApiClient().configuration.api_key['api_key'] = config('INTRINIO_SANDBOX_KEY') security_api = intrinio_sdk.SecurityApi() # Initialize api's capi = intrinio_sdk.CompanyApi() capi_params = { 'identifier' : tkr_id, 'filed_after' : '', 'filed_before' : '', 'reported_only' : False, # 'fiscal_year' : fiscal_year, 'statement_code' : 'income_statement', 'type' : 'QTR', 'start_date' : after_date, 'end_date' : end_date, 'page_size' : 500, 'next_page' : '' } # Set up dictionary to populate with financial report availibility information for attempt in range(5): try: fundamentals = capi.get_company_fundamentals(**capi_params) except: print("There was a server error. Retrying, attempt {}.".format(attempt)) sleep(5) else: break # n_results = len(fundamentals.fundamentals) # for i in range(n_results): # if fundamentals.fundamentals[i].filing_date != None: # fundamentals.fundamentals[i].filing_date = fundamentals.fundamentals[i].filing_date.strftime('%Y-%m-%d') return(fundamentals.fundamentals)
def __init__(self): try: intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = 'OmNiNGM1YmUyZTFhOGVhODgzMWIxZmNmZjdiYTllZWFj' self.security_api = intrinio_sdk.SecurityApi() self.company_api = intrinio_sdk.CompanyApi() except ApiException as e: print("Exception when establishing connection with api: %s\r\n" % e)
def __init__(self, identifier): intrinio_sdk.ApiClient( ).configuration.api_key['api_key'] = 'YOUR API KEY' self.identifier = identifier self.start_date = days_ago self.end_date = today self.frequency = frequency self.page_size = page_size self.next_page = next_page X = [] self.original_data = X
def get_connection(): with open(config_file_name, 'r') as f: vals = yaml.safe_load(f) if not ('PRODUCTION_API_KEY' in vals.keys() and 'SANDBOX_API_KEY' in vals.keys() and 'USE_PRODUCTION' in vals.keys()): raise Exception('Bad config file: ' + config_file_name) intrinio_sdk.ApiClient( ).configuration.api_key['api_key'] = vals['PRODUCTION_API_KEY'] if vals[ 'USE_PRODUCTION'] else vals['SANDBOX_API_KEY'] return intrinio_sdk
def get_stonks(): intrinio_sdk.ApiClient().configuration.api_key['api_key'] = 'API-KEY' security_api = intrinio_sdk.SecurityApi() identifiers = ['AAPL', 'MSFT', 'GS', 'NKE'] price_list = list() try: for identifier in identifiers: api_response = security_api.get_security_realtime_price(identifier) price_list.append((identifier, api_response.ask_price)) except ApiException as e: print( "Exception when calling SecurityApi->get_security_realtime_price: %s\r\n" % e) finally: return price_list
def Getstock(name): intrinio_sdk.ApiClient( ).configuration.api_key['api_key'] = '[your-intrino-api-key]' security_api = intrinio_sdk.SecurityApi() identifier = name # str | A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID) #returns info on stock in json format try: api_response = security_api.get_security_realtime_price(identifier) high = api_response.high_price low = api_response.low_price opn = api_response.open_price exc = api_response.exchange_volume stock = [high, low, opn, exc] return (stock) except ApiException as e: zip = ( "Exception when calling SecurityApi->get_security_realtime_price: %s\n" % e)
def get_data_intrinio(ticker): import intrinio_sdk from pprint import pprint from intrinio_sdk.rest import ApiException intrinio_sdk.ApiClient( ).configuration.api_key['api_key'] = globals.INTRINIO_API_KEYS[0] security_api = intrinio_sdk.SecurityApi() identifier = ticker # str | A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID) try: start_date = '2019-08-01' # date | Return intraday prices starting at the specified date (optional) end_date = '2019-08-04' # date | Return intraday prices stopping at the specified date (optional) api_response1 = security_api.get_security_realtime_price( identifier, start_date=start_date, end_date=end_date) api_response2 = security_api.get_security_realtime_price( identifier) #, start_date=start_date, end_date=end_date) pprint(api_response1) pprint(api_response2) except ApiException as e: print( "Exception when calling SecurityApi->get_security_intraday_prices: %s\n" % e)
# [NAME: library.py] # [IMPORTS] from __future__ import print_function import csv import time import json import pickle import intrinio_sdk from pprint import pprint from urllib.request import urlopen from finviz.screener import Screener from intrinio_sdk.rest import ApiException # [PRE-SCRIPTING DIRECTIVES & CONSTANT CREATION] intrinio_sdk.ApiClient().configuration.api_key['api_key'] = 'Ojg1Y2IzMzFlNjcxY2U3YmYwNzc5MjgyNTgwMjEyM2Jh' company_api = intrinio_sdk.CompanyApi() # [PRIMARY SCREEN FOR COMPANIES WITH M_CAPS GREATER THAN 3B.] def compilepimary(): dictionary_ticker_mc = {} filters = ['cap_midover','geo_usa'] stock_list = Screener(filters=filters, table='Valuation', order='market cap') # Get the performance table and sort it by price ascending for stock in stock_list: dictionary_ticker_mc[stock['Ticker']] = stock['Market Cap'] remove = [k for k,v in dictionary_ticker_mc.items() if v == '-'] for k in remove: del dictionary_ticker_mc[k] return dictionary_ticker_mc # [PULLS INFORMATION ABOUT EBIT AND ENTERPROSE VALUE. CALCULATE RATIO AND SAVES TO PICKLE FILE]
def gather_financial_statement_time_series( api_key, ticker, statement, year, period, output_format='pddf'): """ Given the tickers, statement, year and period returns the complete financial information from the Intrinio API stock data Parameters ----------- api_key : str API key (sandbox or production) from Intrinio ticker : str the ticker symbol you would like to get information for statement : str the statement that you want to study options: 'income_statement', 'cash_flow_statement', 'balance_sheet_statement' year : list the list containing the years as strings period : list the list of quarters (as strings) for which you want information output_format : str (optional, default = 'pddf') the output format for the data, options are 'dict' for dictionary or 'pddf' for pandas dataframe Returns ----------- object of type output_format information about the given statement for the given ticker at the given times in the specified output format Example ----------- >>> gather_financial_statement_time_series(api_key, ticker='AAPL', statement='income_statement', year=['2018', '2019'], period=['Q1'], output_format='dict') """ # https://data.intrinio.com/data-tags available_statements = [ 'income_statement', 'cash_flow_statement', 'balance_sheet_statement' ] inputs = {'api_key': api_key, 'ticker': ticker, 'statement': statement} # Check if api_key, ticker and statement are strings for inst in inputs.keys(): if isinstance(inputs[inst], int): raise TypeError( "Invalid data format: " + inst + " must be a string") elif isinstance(inputs[inst], float): raise TypeError( "Invalid data format: " + inst + " must be a string") elif not isinstance(inputs[inst], str): raise NameError("Invalid data format: " + inst + " must be a string") # Check if the output_format is either 'dict' or 'pddf' if output_format not in ['dict', 'pddf']: raise Exception( "Invalid data format: output_format" + "must be 'dict' or 'pddf'") # Check that the value of statement is valid if statement not in available_statements: raise Exception( "Invalid data format: statement must be one of" + "'income_statement', 'cash_flow_statement' or " + "'balance_sheet_statement'") # Check that year is a list if isinstance(year, int): raise TypeError("Invalid data format: year must be a string") elif isinstance(year, float): raise TypeError("Invalid data format: year must be a string") if not type(year) is list: raise NameError("Invalid data format: year must be a list of strings") # Check that period is a list if not type(period) is list: raise NameError( "Invalid data format: " + "period must be a list of strings") # Check that the length of year is 4 for y in year: if not len(y) == 4: raise Exception( "Invalid data format: " + "year must be a string of 4 digits") # Initialize API key intrinio_sdk.ApiClient().configuration.api_key['api_key'] = api_key fundamentals_api = intrinio_sdk.FundamentalsApi() # Empty list to store results: reformat later to dataframe results = [] # Outer loop over years, inner loop over quarters for i in year: for j in period: # define key to obtain relevant information key = str(ticker) + '-' + str(statement) + \ '-' + str(i) + '-' + str(j) # Obtain req. object from API try: # put stock prices into a variable funda = fundamentals_api.get_fundamental_reported_financials( key) except Exception: print( "Invalid API Key: please input a valid API key as a string" ) return my_fund = funda.reported_financials # Empty dictionary to append the results : convert to df at the # last stage my_dict = {} my_dict['ticker'] = ticker my_dict['statement'] = statement my_dict['year'] = i my_dict['period'] = j for n in range(0, len(my_fund)): my_dict[str(my_fund[n].xbrl_tag.tag)] = [] # add values to the dictionary for k in range(0, len(my_fund)): for key, val in my_dict.items(): if my_fund[k].xbrl_tag.tag == key: my_dict[key].append(my_fund[k].value) my_dict[key] = [sum(my_dict[key])] results.append(my_dict) final_df = pd.DataFrame(results) # if_else for output format if output_format == 'pddf': return final_df else: return results
from __future__ import print_function import time import intrinio_sdk from intrinio_sdk.rest import ApiException from pprint import pprint, pformat import json intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = 'OjMwMDZjOWUwNjMzY2FlZjhlNjdkY2NkMTMzZmFhZDhj' company_api = intrinio_sdk.CompanyApi() identifier = '$SIC.20' # str | A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID) security_api = intrinio_sdk.SecurityApi() #identifier = 'AAPL' # str | A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID) #start_date = '2018-01-01' # date | Return prices on or after the date (optional) #end_date = '2019-01-01' # date | Return prices on or before the date (optional) #frequency = 'daily' # str | Return stock prices in the given frequency (optional) (default to daily) #page_size = 100 # int | The number of results to return (optional) (default to 100) #next_page = '' # str | Gets the next page of data from a previous API call (optional) try: companyInfo = company_api.get_company(identifier) #stockInfo = security_api.get_security_stock_prices(identifier, start_date=start_date, end_date=end_date, frequency=frequency, page_size=page_size, next_page=next_page) f = open("Company Info.json", "w") pprint(companyInfo) f.write(str(pformat(companyInfo))) #s = open("Stock Info.json", "w") #s.write(str(pformat(stockInfo))) f.close()
def gather_stock_time_series( api_key, ticker, start_date=None, end_date=None, output_format='dict', allow_max_rows=False): """ Given the ticker, start date, and end date, return from the Intrinio API stock data for that time frame in either a dictionary or a pandas dataframe format. Parameters ----------- api_key : str API key (sandbox or production) from Intrinio ticker : str the ticker symbol you would like to get stock data for start_date : str (optional) the earliest date in the format of "%Y-%m-%d", e.g. "2019-12-31" to get data for end_date : str (optional) the most recent date in the format of "%Y-%m-%d", e.g. "2019-12-31" to get data for output_format : str (optional, default = 'dict') the output format for the data, options are 'dict' for dictionary or 'pddf' for pandas dataframe allow_max_rows : bool (optional, default = False) if False, then only 100 rows will show in the output, otherwise up to 10000 rows will show (based on dates) Returns ----------- object of type output_format stock data for the specific timeframe in the specified output format Example ----------- >>> gather_stock_time_series(api_key, 'AAPL', start_date="2020-01-15", end_date="2020-01-30", output_format="pddf") """ # error messages msg1 = "Invalid data format: ticker must be a string" msg2 = "Invalid Date format: date must be a string in the format %Y-%m-%d" msg3 = "Invalid Input: end_date must be later than start_date" msg4 = "Invalid API Key: please input a valid API key as a string" # ensure the type of the ticker is a string if type(ticker) != str: return msg1 try: # change dates to datetime objects if start_date is not None: start_date = datetime.strptime(start_date, '%Y-%m-%d').date() if end_date is not None: end_date = datetime.strptime(end_date, '%Y-%m-%d').date() except Exception: return msg2 if start_date is not None and end_date is not None: if start_date >= end_date: return msg3 # initialize API key intrinio_sdk.ApiClient().configuration.api_key['api_key'] = api_key # initialize security API security_api = intrinio_sdk.SecurityApi() # if allow_max_rows=False if allow_max_rows is False: rows = 100 else: rows = 10000 try: # put stock prices into a variable stock_prices = security_api.get_security_stock_prices( ticker, start_date=start_date, end_date=end_date, page_size=rows).stock_prices except Exception: return msg4 # initialize a results dictionary results = {'date': [], 'close': [], 'adj_close': [], 'high': [], 'adj_high': [], 'low': [], 'adj_low': [], 'open': [], 'adj_open': [], 'volume': [], 'adj_volume': [], 'frequency': [], 'intraperiod': []} # fill in dictionary for i in list(range(0, len(stock_prices), 1)): results['date'].append(stock_prices[i].date) results['close'].append(stock_prices[i].close) results['adj_close'].append(stock_prices[i].adj_close) results['high'].append(stock_prices[i].high) results['adj_high'].append(stock_prices[i].adj_high) results['low'].append(stock_prices[i].low) results['adj_low'].append(stock_prices[i].adj_low) results['open'].append(stock_prices[i].open) results['adj_open'].append(stock_prices[i].adj_open) results['volume'].append(stock_prices[i].volume) results['adj_volume'].append(stock_prices[i].adj_volume) results['frequency'].append(stock_prices[i].frequency) results['intraperiod'].append(stock_prices[i].intraperiod) # if the ouput format is a dataframe, change to that if output_format == 'pddf': results = pd.DataFrame(results) return results
def gather_financial_statement_company_compare(api_key, ticker, statement, year, period, output_format='dict'): """ Given the tickers, statement, year and period returns all the information from the Intrinio API fundamental reported financials for that time and those tickers in either a dictionary or a pandas dataframe format. Parameters ----------- api_key : str API key (sandbox or production) from Intrinio ticker : list a list of the ticker symbols you would like to study statement : str the statement that you want to study options: 'income_statement', 'cash_flow_statement', 'balance_sheet_statement' year : str the year you want the information from period : str the period you want the information from output_format : str (optional, default = 'dict') the output format for the data, options are 'dict' for dictionary or 'pddf' for pandas dataframe Returns ----------- object of type output_format information about the given statement for the given tickers at the given time in the specified output format Example ----------- >>> gather_financial_statement_company_compare(api_key, ['AAPL', 'CSCO'], 'income_statement', '2019', 'Q1') """ statements = ['income_statement', 'balance_sheet_statement', 'cash_flow_statement'] inputs = {'api_key': api_key, 'statement': statement, 'year': year, 'period': period} intrinio_sdk.ApiClient().configuration.api_key['api_key'] = api_key fundamentals_api = intrinio_sdk.FundamentalsApi() # Check if api_key, statement, year, period are strings for inst in inputs.keys(): if not isinstance(inputs[inst], str): raise TypeError("Invalid data format: " + inst + " must be a string") # test if the API Key works try: fundamentals_api.get_fundamental_reported_financials( 'AAPL-income_statement-2019-Q1') except Exception: msg_apy = "Invalid API Key: please input a valid API key as a string" return msg_apy # Check if ticker is a list if not isinstance(ticker, list): raise TypeError("Invalid data format: ticker must be a list") # Check if the elements in the ticker list are strings for comp in ticker: if not isinstance(comp, str): raise TypeError( 'Invalid data format: ticker must be a list of strings') # Check if the year is a 4-digits number if not len(year) == 4: raise Exception( "Invalid data format: year must be a string of 4 digits") # Check if the output_format is either 'dict' or 'pddf' if output_format not in ['dict', 'pddf']: raise Exception( "Invalid data format: output_format must be 'dict' or 'pddf'" ) # Check if the statement is valid if statement not in statements: raise Exception( "Invalid data format: statement must be a valid type" ) # link with the API intrinio_sdk.ApiClient().configuration.api_key['api_key'] = api_key fundamentals_api = intrinio_sdk.FundamentalsApi() # result will contain a dictionnary for each company. # This dictionnary will contain all the information for one company result = [] # for every company for comp in ticker: # key is the appropriate key to select the information we want key = comp + '-' + str(statement) + '-' + str(year) + '-' + str(period) try: # get the object that we want from the API fund = fundamentals_api.get_fundamental_reported_financials( key) except Exception: msg = "Invalid agruments: please make sure that your statement" msg = msg + "/year/period are valid" return msg my_fund = fund.reported_financials # This dictionary will contain all the information for one company dict = {} dict['ticker'] = comp dict['statement'] = statement dict['year'] = year dict['period'] = period # we store all the values, balances, names and the tags for i in range(len(my_fund)): value = my_fund[i].value tag_dic = my_fund[i].xbrl_tag balance = tag_dic.balance name = tag_dic.name tag = tag_dic.tag # tag is a key of this dictionnary # if the tag is several times in the original object, we keep # one tag and the value is the sum or the substraction of # all the values of this tag (depending on the value of balance) if tag in dict.keys(): if balance == 'credit': value = dict[tag]['value'] - value else: value = dict[tag]['value'] + value dict[tag] = {'value': value, 'balance': balance, 'name': name} result.append(dict) if output_format == 'dict': return result # if the wanted type of the output is a dataframe else: # initialize a new empty dictionnary that we will convert into a # dataframe # this dictionnary will have the following structure # {'name': [name1, name2], 'revenue' : # [revenu_company_1, revenue_company_2], ...} df = {} # for every company for i in range(len(result)): # select all the information about this company sub_dict = result[i] # For all the tags that we have for this company for val in sub_dict.keys(): # if the key is already in the df dictionary if val in df.keys(): # if the value that corresponds to the key is a string # which means that the key is 'ticker', 'statement', # 'year' or 'period' if type(sub_dict[val]) == str: # We append the value of the key df[val].append(sub_dict[val]) # if the value of the key is a dictionary else: # only take the value that corresponds to the key # 'value' df[val].append(sub_dict[val]['value']) # This step is to make sure that all the values in this # dictionary (which are lists) are the same length # if the tag of the company is not already in the df dictionary else: if type(sub_dict[val]) == str: # We have to put as many 'None' as the number of # companies for which we already collected the # information df[val] = [None for j in range(i)] + [sub_dict[val]] else: df[val] = [None for j in range( i)] + [sub_dict[val]['value']] # We add some 'None' to make sure that all the values # are the same length in this dictionary for val in df.keys(): # The length of each value should be i+1 # (=number of companies we studied) if len(df[val]) != i+1: df[val].append(None) return pd.DataFrame(df)
Created on Thu Jun 18 14:38:41 2020 @author: Max """ import numpy as np import pandas as pd import yfinance as yf import quandl #Yahoo df_yahoo = yf.download(['AAPL', 'MSFT'], actions='inline', progress=True) print(df_yahoo) #Intrinsio set-up import intrinio_sdk intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = "OjZkMThlZjVjOWUyMjk1ZjBmMDhjNGVjZTRhOTYzYjUw" security_api = intrinio_sdk.SecurityApi() #Intrinsio call r = security_api.get_security_stock_prices(identifier='AAPL', start_date='2000-01-01', end_date='2010-12-31', frequency='daily', page_size=1000) response_list = [x.to_dict() for x in r.stock_prices] df_intrinio = pd.DataFrame(response_list).sort_values('date') df_intrinio.set_index('date', inplace=True) print(df_intrinio)
import os import requests import pandas as pd import sqlalchemy from dotenv import load_dotenv, find_dotenv load_dotenv(find_dotenv()) import intrinio_sdk from intrinio_sdk.rest import ApiException intrinio_sdk.ApiClient().configuration.api_key['api_key'] = os.getenv( 'INTRINIO_PROD_KEY') security_api = intrinio_sdk.SecurityApi() from helper import (ingest_security) # open sqllite db engine = sqlalchemy.create_engine('sqlite:///securities.db') db_session = sqlalchemy.orm.Session(bind=engine) # Ingest ETF Data for ETF in ['SPY', 'IEF', 'GLD']: ingest_security(intrinio_security=security_api, db_session=db_session, ticker=ETF, name=None, type='etf') # write s&p 500 companies resp = requests.get('https://datahub.io/core/s-and-p-500-companies/r/0.csv')
from future import print_function import time import intrinio_sdk from intrinio_sdk.rest import ApiException intrinio_sdk.ApiClient( ).configuration.api_key['api_key'] = 'OjE3ZWZmZjFhMGJkMmI2ZjQ0ZjcwMDdjMGVjNjA4ZDQw' fundamentals_api = intrinio_sdk.FundamentalsApi() identifier = 'DIS' statement_code = 'income_statement' # str | The statement code fiscal_year = 2017 # int | The fiscal year fiscal_period = 'FY' # str | The fiscal period try: api_response = fundamentals_api.lookup_fundamental( identifier, statement_code, fiscal_year, fiscal_period) with open('outputfile.json', 'w') as outf: outf.write(str(api_response).replace("\'", "\"").replace('None', '"None"').replace( 'False', '"False"').replace("datetime.date", "\"datetime.date").replace(")", ")\"")) except ApiException as e: print("Exception when calling IndexApi->get_economic_index_by_id: %s\n" % e)
from __future__ import print_function import time import intrinio_sdk as intrinio from intrinio_sdk.rest import ApiException intrinio.ApiClient().configuration.api_key[ 'api_key'] = 'OjUwYjk1NjVhZTY4YWFmODRkOGZmZTAwNmQ2N2ExMzli' class StockIndex: def __init__(self, ticker): pass def main(): identifier = '^GSPC' start_date = '2018-01-01' end_date = '2019-01-01' frequency = 'daily' page_size = 100 next_page = '' response = intrinio.SecurityApi().get_security_stock_prices( identifier, start_date=start_date, end_date=end_date, frequency=frequency, page_size=page_size, next_page=next_page) print(response)
from __future__ import print_function import time import intrinio_sdk from intrinio_sdk.rest import ApiException intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = 'OmI0YTRmNmFiYzI3NDQ5ZGY5MDRjYmE2NGYzNzZmNGZl' company_api = intrinio_sdk.CompanyApi() page_size = 100 # float | The number of results to return (optional) (default to 100) next_page = '' # str | Gets the next page of data from a previous API call (optional) try: api_response = company_api.get_all_company_news(page_size=page_size, next_page=next_page) print(api_response) except ApiException as e: print("Exception when calling CompanyApi->get_all_company_news: %s\n" % e)
import csv import intrinio_sdk APIKEY = 'YOUR_API_KEY' # List sourced from DOW30 # https://docs.intrinio.com/developer-sandbox STOCKS = [ 'AAPL', 'AXP', 'BA', 'CAT', 'CSCO', 'CVX', 'DIS', 'DWDP', 'GE', 'GS', 'HD', 'IBM', 'INTC', 'JNJ', 'JPM', 'KO', 'MCD', 'MMM', 'MRK', 'MSFT', 'NKE', 'PFE', 'PG', 'TRV', 'UNH', 'UTX', 'V', 'VZ', 'WMT', 'XOM' ] intrinio_sdk.ApiClient().configuration.api_key['api_key'] = APIKEY, security_api = intrinio_sdk.SecurityApi() for stock in STOCKS: # Loop through the API response creating a list in the format we need. print(stock) api_response = security_api.get_security_stock_prices(stock) prices = [] for row in api_response.stock_prices_dict: date = row['date'] o = row['adj_open'] h = row['adj_high'] l = row['adj_low'] c = row['adj_close'] v = row['adj_volume'] prices.append([date, o, h, l, c, v])
from __future__ import print_function import time import intrinio_sdk from intrinio_sdk.rest import ApiException from pprint import pprint intrinio_sdk.ApiClient().configuration.api_key['api_key'] = 'YOUR_API_KEY' crypto_api = intrinio_sdk.CryptoApi() exchange = 'gemini' # str | Returns stats for Crypto Currencies that trade on the specified Crypto Exchange. (optional) currency = 'BTC' # str | Returns stats for the specified Crypto Currency. (optional) try: api_response = crypto_api.get_crypto_stats(exchange=exchange, currency=currency) stats = api_response.stats print("%s stats found!" % (len(stats))) for stat in stats: print("Name: %s" % (stat.name)) print("Code: %s" % (stat.code)) print("Symbol: %s" % (stat.symbol)) print("Market cap(USD): %s" % (stat.market_cap_usd)) print("Available supply: %s" % (stat.available_supply)) print("Total supply: %s" % (stat.total_supply)) print("Max supply: %s" % (stat.max_supply)) print("Last updated: %s" % (stat.last_updated)) print("") except ApiException as e: print("Exception when calling CryptoApi->get_crypto_stats: %s\n" % e)
# get list of intrinio ids to pull the company info for comp_list = pd.read_sql( sql="select distinct company_id from dbo.company_list where is_current = 1", con=conn, parse_dates=['insert_date', 'update_date'], chunksize=None) # companies currently in the details sql table comp_dets = pd.read_sql( sql="select * from dbo.company_details where is_current = 1", con=conn, parse_dates=['insert_date', 'update_date'], chunksize=None) # connect to intrino intrinio_sdk.ApiClient().configuration.api_key['api_key'] = password_file.get( 'intrinio', {}).get('API_sandbox', '') # loop thru company list and make api calls while updating database for int_id in comp_list.loc[:, 'company_id'].to_list(): # make the api call to get the company info temp_dict = intrinio_sdk.CompanyApi().get_company( identifier=int_id).to_dict() # convert to dataframe and rename columns to match columns in database temp_pd = pd.DataFrame( temp_dict, index=[0]).rename(columns={ 'id': 'company_id', 'name': 'company', 'template': 'finstate_template' }).loc[:, comp_dets. columns[~comp_dets.columns.
def gather_stock_returns(api_key, ticker, buy_date, sell_date): """ Given the tickers, buy-in date, sell-out date, returns the historical prices and profit/loss (based on the adjusted closing prices). Parameters ----------- api_key : str API key (sandbox or production) from Intrinio tickers : list or str a single ticker or a list containing tickers. e.g. 'AAPL' or ['AAPL', 'CSCO'] buy_date : str the buy-in date in the format of "%Y-%m-%d", e.g. "2019-12-31". If the input date is not a trading day, it will be automatically changed to the next nearest trading day. sell_date : str the sell-out date in the format of "%Y-%m-%d", e.g. "2019-12-31". If the input date is not a trading day, it will be automatically changed to the last nearest trading day. Returns ----------- pandas.core.frame.DataFrame a dataframe that contains the companies, historical prices and corresponding profit/loss Example ----------- >>> gather_stock_returns(api_key, ['AAPL', 'CSCO'], "2017-12-31", "2019-03-01") """ msg1 = "Invalid Input: sell_date must be later than buy_date" msg2 = "Invalid Date format: date must be a string in the format %Y-%m-%d" msg3 = "Invalid API Key: please input a valid API key as a string" # test whether the input dates are in the right format try: buy_date = datetime.strptime(buy_date, '%Y-%m-%d').date() sell_date = datetime.strptime(sell_date, '%Y-%m-%d').date() if buy_date >= sell_date: return msg1 except Exception: return msg2 if type(ticker) == str: # if user gives just one ticker ticker = [ticker] # initialize API key intrinio_sdk.ApiClient().configuration.api_key['api_key'] = api_key # initialize security API security_api = intrinio_sdk.SecurityApi() # test if the API Key works try: security_api.get_security_stock_prices(ticker[0], start_date=buy_date, end_date=sell_date) except Exception: return msg3 # create the result DataFrame to record and report results = pd.DataFrame(columns=['Stock', 'Buy date', 'Buy price', 'Sell date', 'Sell price', 'Return (%)'], index=range(len(ticker))) # iterate through all the tickers and record the results i = 0 # if buy_date it not a trading day (holiday), we'll get the nearest next # trading day instead buy_date_upper = buy_date + timedelta(days=10) # the same idea for sell_date, but we'll get the nearest **last** trading # day instead. sell_date_lower = sell_date - timedelta(days=10) for ticker in ticker: api_response = security_api.get_security_stock_prices( ticker, start_date=buy_date, end_date=buy_date_upper ) buy_price = api_response.stock_prices[-1].adj_close buy_date = api_response.stock_prices[-1].date.strftime("%Y-%m-%d") api_response = security_api.get_security_stock_prices( ticker, start_date=sell_date_lower, end_date=sell_date) sell_price = api_response.stock_prices[0].adj_close sell_date = api_response.stock_prices[0].date.strftime("%Y-%m-%d") rtn = ((sell_price - buy_price) / buy_price)*100 rtn = round(rtn, 2) results.iloc[i, :] = [ticker, buy_date, buy_price, sell_date, sell_price, rtn] i += 1 return results
import requests import json import intrinio_sdk from intrinio_sdk.rest import ApiException from pprint import pprint intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = 'OmFlZDI5OGJlZjY0YzkzNTk5OGIwYTZlZWQ3NWQwZjY5' security_api = intrinio_sdk.SecurityApi() def writeHTML(data): myfile = open("playerAPI.html", "w") # use "a" to "append" ############### CSS myfile.write(""" <html> <head> <title> MY PAGE </title> </head> <body> <font size="3" color="red">This is some text!</font> <font size="2" color="blue">This is some text!</font> <font face="verdana" color="green">This is some text!</font> <h1>Welcome to My Soccer Home Page</h1> <p>Go to <a href='https://apilist.fun/api/the-sports-db'>The Sports DB</a> for API Info.</p>
from dateutil.parser import parse from stock_price.models import Stock from stock_price.imgloader import draw_line_chart, make_bar_chart from django.http import FileResponse from reportlab.lib import colors from reportlab.platypus import SimpleDocTemplate, Table, TableStyle tag = '' start_date = '' order = '' identifier_group = [] intrinio_sdk.ApiClient().configuration.api_key['api_key'] = '' filename = 'stock_price/initiation.json' historical_data_api = None company_api = None with open(os.path.abspath(filename), 'r') as f: datastore = json.load(f) intrinio_sdk.ApiClient().configuration.api_key['api_key'] = datastore["api_key"] identifier_group = datastore["default_identifiers"] tag = datastore["tag"] start_date = datastore["default_date"] order = datastore["order"] historical_data_api = intrinio_sdk.HistoricalDataApi()
import pandas as pd import intrinio_sdk intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = 'OjJiZDM3OWU0ZTI0YmM5YTdhNzY1NjIwZjczZGRjMjg0' security_api = intrinio_sdk.SecurityApi() company_api = intrinio_sdk.CompanyApi() fundamentals_api = intrinio_sdk.FundamentalsApi() def get_intrinio_hp(query): identifier = str(query).upper() tag = 'adj_close_price' api_response = security_api.get_security_historical_data(identifier, tag, page_size=100) hist_prices = pd.DataFrame(api_response.historical_data_dict) return hist_prices def get_intrinio_volume(query): identifier = str(query).upper() api_response = security_api.get_security_price_technicals_adtv(identifier, page_size=1, period=20) volume = pd.DataFrame(api_response.technicals_dict) return volume def get_intrinio_wr(query): identifier = str(query).upper()
@author: danielbartolomeo """ import pandas as pd import numpy as np import sys import intrinio_sdk from intrinio_sdk.rest import ApiException from pprint import pprint sandbox_key = 'Ojg5Y2Q0M2Y1YjVlNjdlMWMzYjY4M2NkZDc2MTQ0ODM3' colist = intrinio_sdk.CompanyApi().get_all_companies() intrinio_sdk.ApiClient().configuration.api_key['api_key'] = sandbox_key security_api = intrinio_sdk.SecurityApi() identifier = 'AAPL' # str | A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID) start_date = '2018-01-01' # date | Return prices on or after the date (optional) end_date = '2019-01-01' # date | Return prices on or before the date (optional) frequency = 'daily' # str | Return stock prices in the given frequency (optional) (default to daily) page_size = 100 # int | The number of results to return (optional) (default to 100) next_page = '' # str | Gets the next page of data from a previous API call (optional) try: api_response = security_api.get_security_stock_prices( identifier, start_date=start_date, end_date=end_date,
from __future__ import print_function import time from datetime import datetime, date, timedelta import intrinio_sdk from intrinio_sdk.rest import ApiException from pprint import pprint intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = 'OmNhZTYyZjhlZTc4MTc5MTg5ZTMzYzg1NTYzZGJhOWZj' security_api = intrinio_sdk.SecurityApi() identifier = 'AAPL' # str | A Security identifier (Ticker, FIGI, ISIN, CUSIP, Intrinio ID) start_date = str(date.today() - timedelta( days=90)) # date | Get historical data on or after this date (optional) end_date = str(date.today( )) # date | Get historical date on or before this date (optional) frequency = 'daily' # str | Sort by date `asc` or `desc` (optional) next_page = '' # str | Gets the next page of data from a previous API call (optional) try: api_response = security_api.get_security_stock_prices( identifier, start_date=start_date, end_date=end_date, frequency=frequency) pprint(api_response) except ApiException as e: print( "Exception when calling SecurityApi->get_security_historical_data: %s\n" % e)
# prep the sql call dbname='stockmaster' host=password_file.get('postgres',{}).get('server',{}).get(dbname,{}).get('host','') user=password_file.get('postgres',{}).get('server',{}).get(dbname,{}).get('user','') password=password_file.get('postgres',{}).get('server',{}).get(dbname,{}).get('password','') port=password_file.get('postgres',{}).get('server',{}).get(dbname,{}).get('port','') # use sql alchemy conn string AND connect to database conn = sqlalchemy.create_engine('postgresql://'+user+':'+password+'@'+host+':'+port+'/'+dbname).connect() # get list of intrinio ids to pull the security (US ONLY) price data for sec_list = pd.read_sql(sql = "select distinct intrinio_id from dbo.security_list where is_current = 1 and composite_ticker like '%%:US'", con = conn, chunksize=None) # connect to intrino intrinio_sdk.ApiClient().configuration.api_key['api_key'] = password_file.get('intrinio', {}).get('API_sandbox','') # a place to store errors from API CALLS err = pd.DataFrame(columns = ['identifier', 'start_date', 'end_date', 'frequency', 'page_size', 'next_page', 'err_msg']) # loop over the secuirties to get the proce info for sec in sec_list.loc[:,'intrinio_id'].to_list(): # all the dates in the table for the security // will be used to set the start date and to avoid duplicates being added into the database dates_in_table = pd.read_sql(sql = "select asofdate from dbo.security_price where intrinio_id = '"+sec+"'", parse_dates = ['asofdate'],con = conn).loc[:,'asofdate'] # id comes for security list // intrinio_id identifier = sec # use the max in the database or the min in the API start_date = dt.datetime.strftime(dates_in_table.max() + dt.timedelta(days = 1), '%Y-%m-%d') if len(dates_in_table) != 0 else '' # set end date as most recent date end_date = dt.datetime.strftime(dt.date.today(),'%Y-%m-%d') # data freq --> 'daily' is the most granular
import intrinio_sdk import pandas as pd intrinio_sdk.ApiClient().configuration.api_key[ 'api_key'] = '{OjBkNDgwZTRhODgwMzgzNzU0OWI1NTM0YTA4NGNhYjI1}' security_api = intrinio_sdk.SecurityApi() r = security_api.get_security_stock_prices(identifier='AAPL', start_date='2000-01-01', end_date='2010-12-31', frequency='daily', page_size=10000) response_list = [x.to_dict() for x in r.stock_prices] df_intrinio = pd.DataFrame(response_list).sort_values('date') df_intrinio.set_index('date', inplace=True) df_intrinio.to_csv('/Users/chelseaw/Desktop/intrinio.csv') fileIntrinio = open('/Users/chelseaw/Desktop/intrinio.csv') print(fileIntrinio.read())
def find_fundamentals(tkr_id, sandbox=False, nocomm=False): """ Returns a list of available fundamental financial indicators for the specified company. -- tkr_id: stock ticker name. 'AAPL' for Apple inc, 'XOM' for Exxon Mobile Corp. etc. (if using a developer sandbox key, only DOW 30 will be available) -- sandbox: Use this to turn sandbox mode on and off if you have a developers sandbox api key. Limited to DOW 30, but much less strict limits on api calls. *In .env file name main key INTRINIO_KEY and developer sandbox key INTRINIO_SANDBOX_KEY """ # Sandbox check and get env key if sandbox == False: intrinio_sdk.ApiClient().configuration.api_key['api_key'] = config( 'INTRINIO_KEY') security_api = intrinio_sdk.SecurityApi() elif sandbox == True: intrinio_sdk.ApiClient().configuration.api_key['api_key'] = config( 'INTRINIO_SANDBOX_KEY') security_api = intrinio_sdk.SecurityApi() # Initialize api's capi = intrinio_sdk.CompanyApi() fapi = intrinio_sdk.FundamentalsApi() # Set parameters to get most recent financial report fund_params = { 'identifier': tkr_id, 'filed_after': '2018-06-01', 'filed_before': '2018-11-01', 'reported_only': False, # 'fiscal_year' :fiscal_year, 'statement_code': 'income_statement', 'type': '', 'start_date': '', 'end_date': '', 'page_size': 1, 'next_page': '' } # Get most recent financials report fundamentals = capi.get_company_fundamentals(**fund_params) id_to_check = fundamentals.fundamentals[0].id fun_check = fapi.get_fundamental_standardized_financials(id_to_check) available_fun = [] common = ['date', 'fiscal_year', 'quarter'] # Make list of available fundamentals and add above for fun in fun_check.standardized_financials: available_fun.append(fun.data_tag.tag) if nocomm == False: for fun in common: available_fun.append(fun) else: available_fun.append('date') return (available_fun)