class OracleServer: def __init__(self, api_key=alpha_vantage_api_key, ticker_symbol=alpha_vantage_ticker_symbol, tezos_key=tezos_user_key, oracle_contract_address=oracle_address): self.oracle_contract_address = oracle_contract_address self.pytezos_instance = pytezos.using(key=tezos_key, shell='carthagenet') self.time_series = TimeSeries(key=api_key, output_format='json') self.ticker_symbol = ticker_symbol def oracle_contract(self): return self.pytezos_instance.contract(self.oracle_contract_address) def update_value(self): try: now_utc = datetime.now(tz=timezone.utc) operation_group = self.oracle_contract().updateValue(now_utc, self.price()).operation_group # hi operation_str = f"<p> Last operation:\n{operation_group.autofill().sign().inject()} </p>" storage_str = f"<p> Current storage:\n{self.oracle_contract().storage()} </p>" return (operation_str + storage_str) except Exception as e: exception_doc = f"<p> Exception: {str(e.__doc__)} </p>" exception_message = None try: exception_message = f"<p> {str(e.message)} </p>" except: exception_message = f"(unknown message: {e.__class__.__name__})" return (exception_doc + exception_message) def price(self): quote_data, expected_none = self.time_series.get_quote_endpoint(self.ticker_symbol) if expected_none is None: try: return int(float(quote_data['05. price']) * 100) except KeyError: raise f"expected key: '05. price' in {str(quote_data)}" else: raise f"expected_none not None: {str(expected_none)}"
def main(): # get API keys key = s3_read(bucket='trader-con', key='secrets/alpha_vantage_secrets.txt') # read in portfolio (TO DO: switch to s3 location portfolio = get_portfolio() # get cash value cash = portfolio['cash'] print(cash) # get stock value ts = TimeSeries(key) stock_value = 0 for ticker in portfolio['stock'].keys(): print(ticker) # get number of shares shares = portfolio['stock'][ticker] # get stock price prices, meta = ts.get_quote_endpoint(symbol=ticker) price = float(prices['05. price']) print(f'Shares: {shares}, Share Price: {price} \n') stock_value += 1 * (shares * price) # compute total total = cash + stock_value print(f'Total Portfolio Value: {total}') return total
def get_object(self): symbol = self.kwargs.get("symbol") try: stock = Stock.objects.get(symbol__iexact=symbol) except Stock.DoesNotExist: print("Stock does not exist!") raise Http404(f"Stock symbol <{symbol}> does not exist!") ts = TimeSeries(key=_AV_LIVE_API_QUOTE_KEY, output_format="json") try: av_response = ts.get_quote_endpoint(symbol=symbol) av_quote = av_response[0] except: print("Error contacting API") raise Http404("Error contacting alphavantage API.") # TODO(jonas): check if a quote with same prices already exists quote, created = Price.objects.get_or_create( symbol=stock, interval="quote", date=dateutil.parser.parse( av_quote["07. latest trading day"]).date(), # TODO(jonas): if this is the prev. day # we need to write midnight as timestamp instead p_low=float(av_quote["04. low"]), p_open=float(av_quote["02. open"]), p_high=float(av_quote["03. high"]), p_close=float(av_quote["05. price"]), p_adjusted_close=float(av_quote["05. price"]), volume=int(av_quote["06. volume"]), ) if not created: quote.exchange_time = timezone.now().time() return quote
def quote_val_by_symbol(symba): #import pandas as bear #from alpha_vantage.timeseries import TimeSeries #https://alpha-vantage.readthedocs.io/en/latest/genindex.html #keys = 'BGDF14R9D6NKLQ19' #get free API Key here: https://www.alphavantage.co/support/#api-key output_format = TimeSeries(key=keys, output_format='pandas') x = output_format.get_symbol_search(keywords=symba) x[0].reset_index(inplace=True) x[0].columns = ['date','symbol','name','type','region','marketOpen','marketClose','timezone','currency','matchScore'] base_currency = x[0][x[0]['symbol']==symba]['currency'].to_string(index=False) base_currency = base_currency.replace(" ","") rate = convert_currency(base_currency) output_format = TimeSeries(key=keys, output_format='pandas') y = output_format.get_quote_endpoint(symbol=symba) y[0].reset_index(inplace=True) y[0].columns = ['index','symbol','open','high','low','price','volume','latest trading day','previous close','change','change percent'] y[0] quote_in_usd=y[0] quote_in_usd['open'] = (float(quote_in_usd['open']) * rate ) quote_in_usd['high'] = (float(quote_in_usd['high']) * rate ) quote_in_usd['low'] = (float(quote_in_usd['low']) * rate ) quote_in_usd['price'] = (float(quote_in_usd['price']) * rate) return quote_in_usd
def get_prices(): # Your key here - keep it key = '6LGG0QGAGBROB2M6' ts = TimeSeries(key=key, output_format='pandas') start_time = time.time() count = 0 # track these throughout sell_value = 0.0 curr_value = 0.0 for stock in TICKERS: print(stock[0], end=' ', flush=True) count += 1 stock[3] = float(ts.get_quote_endpoint(symbol=stock[0])[0]['05. price']['Global Quote']) if count == 5: print(' [ delay ]', flush=True) for i in range(0, 60): time.sleep(1) print(' .', end='', flush=True) count = 0 print('', flush=True) # update values of holdings sell_value += stock[1]*stock[2] curr_value += stock[1]*stock[3] print("\n\nValue at sell time: $", sell_value, flush=True) print("Value now : $", curr_value, flush=True) print("Change in value : $", curr_value - sell_value, flush=True)
def getQuoteFromMarket(self): #ti = TechIndicators(self.key, output_format='pandas') try: #self.script = self.exchange_text.get() + ":" + self.symbol_text.get() curr_selection = self.search_symbol_combo.current() if (curr_selection >= 0): self.script = self.searchTuple[0].values[curr_selection][0] else: msgbx.showerror('Get Quote', 'No script selected') self.search_symbol_combo.focus_force() return ts = TimeSeries(self.key, output_format='pandas') quote_tuple = ts.get_quote_endpoint(symbol=self.script) #quote_tuple[0].values[0][1] #for i in range(1, 1, quote_tuple[0].size): self.open_val_label.configure(text=quote_tuple[0].values[0][1]) self.high_val_label.configure(text=quote_tuple[0].values[0][2]) self.low_val_label.configure(text=quote_tuple[0].values[0][3]) self.price_val_label.configure(text=quote_tuple[0].values[0][4]) self.volume_val_label.configure(text=quote_tuple[0].values[0][5]) self.latesttradingday_val_label.configure( text=quote_tuple[0].values[0][6]) self.prevclose_val_label.configure( text=quote_tuple[0].values[0][7]) self.change_val_label.configure(text=quote_tuple[0].values[0][8]) self.changepct_val_label.configure( text=quote_tuple[0].values[0][9]) except Exception as e: msgbx.showerror("Get Quote Error", str(e)) self.search_symbol_combo.focus_force() return
def update_values(request): try: portfolio = Portfolio.objects.get(user=request.user) current_value = 0 unrealized_pnl = 0 growth = 0 holding_companies = StockHolding.objects.filter(portfolio=portfolio) stockdata = {} for c in holding_companies: ts = TimeSeries(key=get_alphavantage_key(), output_format='json') data, meta_data = ts.get_quote_endpoint(symbol=c.company_symbol) last_trading_price = float(data['05. price']) pnl = (last_trading_price * c.number_of_shares) - c.investment_amount net_change = pnl / c.investment_amount stockdata[c.company_symbol] = { 'LastTradingPrice': last_trading_price, 'PNL': pnl, 'NetChange': net_change * 100 } current_value += (last_trading_price * c.number_of_shares) unrealized_pnl += pnl growth = unrealized_pnl / portfolio.total_investment return JsonResponse({ "StockData": stockdata, "CurrentValue": current_value, "UnrealizedPNL": unrealized_pnl, "Growth": growth * 100 }) except Exception as e: return JsonResponse({"Error": str(e)})
def get_data_latest(symbol, savingtoCsv=True): # reads the latest data of the API # get changes of the last day from alpha_vantage.timeseries import TimeSeries API_KEY, waiting_times = api_key_finder() ts = TimeSeries(key=API_KEY, output_format='pandas') data = ts.get_quote_endpoint(symbol=symbol) return data # , waiting_times
def get_realtime_price_single(symbol): ts = TimeSeries(key=ALPHA_VANTAGE_KEY, output_format='pandas', indexing_type='date') data, meta_data = ts.get_quote_endpoint(symbol) price = data.reset_index(drop=True) price = price[['01. symbol', '05. price', '10. change percent']] price.rename(columns={'01. symbol': 'SymbolCode', '05. price': 'Close', '10. change percent': 'DayRatio'}, inplace=True) price.iat[0, 2] = float(price.iat[0, 2].split('%')[0].strip())/100 return price
def company_stock_valuation(company): ts = TimeSeries(key=settings.ALPHA_VANTAGE_API_KEY) data, _ = ts.get_quote_endpoint(company.symbol) return { 'open': data['02. open'], 'high': data['03. high'], 'low': data['04. low'], 'close': data['05. price'], 'price': data['05. price'], 'volume': data['06. volume'] }
def get_fin_quotes(ticker_symbol): ts = TimeSeries(key="QG9CQILAD7ASQXK0") data = ts.get_quote_endpoint(ticker_symbol) symbol_search = ts.get_symbol_search(ticker_symbol) try: return str(symbol_search[0][0]['2. name']) \ + ": Цена - " + str(data[0]['05. price']) \ + " Объем - " + str(data[0]['06. volume']) \ + " Процент изменений с последнего торгового дня - " + str(data[0]['10. change percent']) except ValueError: print("Неверный тикет") finally: print("Конец обработки исключения")
def get_price(ticker): ts = TimeSeries(key=AV_KEY) data, meta_data = ts.get_quote_endpoint(symbol=ticker) # json_file = json.loads(data) json_dict = {} for key in data: k = key.split(' ')[1:] k = ' '.join(k) v = data[key] json_dict[k] = v return json_dict
def StockQuote(request, pk, format=None): try: symbol = Stock.objects.get(pk=pk).symbol except symbol.DoesNotExist: return Response(status=status.HTTP_404_NOT_FOUND) if request.method == 'GET': from alpha_vantage.timeseries import TimeSeries ts = TimeSeries(key=key) try: data, meta_data = ts.get_quote_endpoint(symbol=symbol) except Exception: return Response(status=status.HTTP_404_NOT_FOUND) return Response(data)
def getStockInfo(self): api_key = key.returnKey() try: ts = TimeSeries(key=api_key, output_format='pandas') data, meta_data = ts.get_quote_endpoint(symbol=self.symbol) except: return False self.open = float(data['02. open'][0]) self.high = float(data['03. high'][0]) self.low = float(data['04. low'][0]) self.close = float(data['05. price'][0]) self.volume = float(data['06. volume'][0]) self.date = str(data['07. latest trading day'][0]) self.change = float(data['09. change']) return True
def get_price_curr(ticker): """ Pulls data from Alphavantage using ticker. Returns back close for today (latest value). """ ts = TimeSeries(api_keys.AV_KEY) attempts = 1 while attempts <= 2: try: data = ts.get_quote_endpoint(symbol=ticker) price = float(data[0]['05. price']) return price except ValueError: sleep(61) attempts += 1
def getStockLatestInfo(cls, symbol): api_key = key.returnKey() try: ts = TimeSeries(key=api_key, output_format='pandas') data, meta_data = ts.get_quote_endpoint(symbol=symbol) except: return False stock = StockModel(data['01. symbol'][0]) stock.open = float(data['02. open'][0]) stock.high = float(data['03. high'][0]) stock.low = float(data['04. low'][0]) stock.close = float(data['05. price'][0]) stock.volume = float(data['06. volume'][0]) stock.date = str(data['07. latest trading day'][0]) stock.change = float(data['09. change']) return stock.json()
def getCurrentStockPrice(api_key, symbols): """Get Current Stock Price for a list of symbols.""" if app_mode == 'debug': print("Starting Alpha Vantage Call...\n") timeseries = TimeSeries(key=api_key) try: with ThreadPoolExecutor(max_workers=10) as executor: generator = executor.map(lambda stock:timeseries.get_quote_endpoint(symbol=stock), symbols) for data in generator: # Lets publish this to MQTT.... publishToMqtt(data[0]['01. symbol'], data[0]['05. price']) if app_mode == 'debug': print("{} - {}".format(data[0]['01. symbol'],data[0]['05. price'])) except ValueError: if app_mode == 'debug': print("API Key is not valid or symbols not known") if app_mode == 'debug': print("Alpha Vantage Call Complete...\n") return data
def get_price(stock): if stock in const.CRYPTO_CURRENCIES: fe = ForeignExchange(key=environ["ALPHA_VANTAGE_API_KEY"]) data, _ = fe.get_currency_exchange_rate(stock, "USD") full_price = data["5. Exchange Rate"] return float(full_price[:-2]) else: try: ts = TimeSeries(key=environ["ALPHA_VANTAGE_API_KEY"]) if nasdaq_is_open(): data, meta_data = ts.get_intraday(stock) key = list(data.keys())[0] full_price = data[key]["4. close"] return float(full_price[:-2]) else: data, _ = ts.get_quote_endpoint(stock) full_price = data["05. price"] return float(full_price[:-2]) except ValueError: response = requests.get(f"{const.FMP_API_GET_PRICE_ENDPOINT}" f'{stock}?apikey={environ["FMP_API_KEY"]}') return response.json()[0]["price"]
def get_data(ticker): APIkey = AV_func.GetAPIkey( KEYS) # get a new API key each time the script runs TEMPdf = pd.DataFrame() # create empty dataframe print("Gather data for {}".format(ticker)) ts = TimeSeries(key=APIkey, output_format='pandas') data = ts.get_quote_endpoint(symbol=ticker) data = data[0] df = pd.DataFrame(data) df.append(data) ti = TechIndicators(key=APIkey, output_format='pandas') dataRSI = ti.get_rsi(symbol=ticker, interval=RSI_INT, time_period=RSI_PERIOD) dataRSI = dataRSI[0] TEMPdf = TEMPdf.append(dataRSI) RS = TEMPdf.last('1D') RS = RS.iat[0, 0] RSR = round(RS, 2) df['11. RSI'] = RSR # add to df df = df.transpose() print(df)
def crawl( module_id: str, app, api_key: str, symbols: List[Tuple[int, int]], mode: str = "table", ) -> None: ts = TimeSeries(key="YOUR_API_KEY") stocks_data: Dict[str, Any] = {"_timestamp": time.time(), "stocks": []} # Get the data from the alpha vantage API for symbol, alias in symbols: if mode == "table": LOGGER.info( "Requesting global quote for symbol '%s' with alias '%s'", symbol, alias ) try: data = ts.get_quote_endpoint(symbol) except ConnectionError: raise CrawlerDataError("Could not connect to Alpha Vantage API") stocks_data["stocks"].append( # TODO It looks like alpha_vantage returns a list with the data # at first element and a second element which is always None # TODO Normalize the data and get rid of all those 1., 2., 3. # in the dictionary keys {"symbol": symbol, "alias": alias, "data": data[0]} ) else: LOGGER.info( "Requesting intraday for symbol '%s' with alias '%s'", symbol, alias ) try: data, meta_data = ts.get_intraday(symbol) except ConnectionError: raise CrawlerDataError("Could not connect to Alpha Vantage API") # As the dictionary is already "sorted" by the time in chronologial # (desc) order, we could simply reformat it into a list and move # the time frame as a value inside the dictionary. This makes # visualizing the data much simpler. norm_values = [] times = [] for timeframe, values in data.items(): norm_values.append( { "open": values["1. open"], "high": values["2. high"], "low": values["3. low"], "close": values["4. close"], "volume": values["5. volume"], } ) times.append(timeframe) stocks_data["stocks"].append( { "symbol": symbol, "alias": alias, "data": {"values": norm_values[::-1], "times": times[::-1]}, "meta_data": meta_data, } ) # TODO Use meta_data to calculate correct timezone information # {'1. Information': 'Intraday (15min) open, high, low, close prices and volume', # '2. Symbol': 'GOOGL', '3. Last Refreshed': '2019-10-04 16:00:00', # '4. Interval': '15min', '5. Output Size': 'Compact', '6. Time Zone': 'US/Eastern'} app.store_module_data(module_id, stocks_data)
class AVInterface: """ AlphaVantage interface class, provides methods to call AlphaVantage API and return the result in useful format handling possible errors. """ def __init__(self, apiKey, config): self.read_configuration(config) self._last_call_ts = dt.datetime.now() self.TS = TimeSeries( key=apiKey, output_format="pandas", indexing_type="integer", treat_info_as_error=True, retries=0, ) self.TI = TechIndicators(key=apiKey, output_format="pandas", retries=0) logging.info("AlphaVantage initialised.") def read_configuration(self, config): self.enable = config["alpha_vantage"]["enable"] self.api_timeout = config["alpha_vantage"]["api_timeout"] def get_prices(self, market_id, interval): """ Return the price time series of the requested market with the interval granularity. Return None if the interval is invalid """ if ( interval == AVInterval.MIN_1 or interval == AVInterval.MIN_5 or interval == AVInterval.MIN_15 or interval == AVInterval.MIN_30 or interval == AVInterval.MIN_60 ): return self.intraday(market_id, interval) elif interval == AVInterval.DAILY: return self.daily(market_id) elif interval == AVInterval.WEEKLY: return self.weekly(market_id) # TODO implement monthly call else: return None def daily(self, marketId): """ Calls AlphaVantage API and return the Daily time series for the given market - **marketId**: string representing an AlphaVantage compatible market id - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call() market = self._format_market_id(marketId) try: data, meta_data = self.TS.get_daily(symbol=market, outputsize="full") return data except Exception as e: logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None def intraday(self, marketId, interval): """ Calls AlphaVantage API and return the Intraday time series for the given market - **marketId**: string representing an AlphaVantage compatible market id - **interval**: string representing an AlphaVantage interval type - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call() if interval is AVIntervals.DAILY: logging.error("AlphaVantage Intraday does not support DAILY interval") return None market = self._format_market_id(marketId) try: data, meta_data = self.TS.get_intraday( symbol=market, interval=interval.value, outputsize="full" ) return data except Exception as e: logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None def weekly(self, marketId): """ Calls AlphaVantage API and return the Weekly time series for the given market - **marketId**: string representing an AlphaVantage compatible market id - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call() market = self._format_market_id(marketId) try: data, meta_data = self.TS.get_weekly(symbol=market) return data except Exception as e: logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None def quote_endpoint(self, market_id): """ Calls AlphaVantage API and return the Quote Endpoint data for the given market - **market_id**: string representing the market id to fetch data of - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call() market = self._format_market_id(market_id) try: data, meta_data = self.TS.get_quote_endpoint( symbol=market, outputsize="full" ) return data except: logging.error("AlphaVantage wrong api call for {}".format(market)) return None # Technical indicators def macdext(self, marketId, interval): """ Calls AlphaVantage API and return the MACDEXT tech indicator series for the given market - **marketId**: string representing an AlphaVantage compatible market id - **interval**: string representing an AlphaVantage interval type - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call() market = self._format_market_id(marketId) try: data, meta_data = self.TI.get_macdext( market, interval=interval.value, series_type="close", fastperiod=12, slowperiod=26, signalperiod=9, fastmatype=2, slowmatype=1, signalmatype=0, ) if data is None: return None data.index = range(len(data)) return data except Exception as e: logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None def macd(self, marketId, interval): """ Calls AlphaVantage API and return the MACDEXT tech indicator series for the given market - **marketId**: string representing an AlphaVantage compatible market id - **interval**: string representing an AlphaVantage interval type - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call() market = self._format_market_id(marketId) try: data, meta_data = self.TI.get_macd( market, interval=interval.value, series_type="close", fastperiod=12, slowperiod=26, signalperiod=9, ) return data except Exception as e: logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None # Utils functions def _format_market_id(self, marketId): """ Convert a standard market id to be compatible with AlphaVantage API. Adds the market exchange prefix (i.e. London is LON:) """ return "{}:{}".format("LON", marketId.split("-")[0]) def _wait_before_call(self): """ Wait between API calls to not overload the server """ while (dt.datetime.now() - self._last_call_ts) <= dt.timedelta( seconds=self.api_timeout ): time.sleep(0.5) self._last_call_ts = dt.datetime.now()
class AVInterface(StocksInterface): """ AlphaVantage interface class, provides methods to call AlphaVantage API and return the result in useful format handling possible errors. """ def initialise(self) -> None: logging.info("Initialising AVInterface...") api_key = self._config.get_credentials()["av_api_key"] self.TS = TimeSeries(key=api_key, output_format="pandas", treat_info_as_error=True) self.TI = TechIndicators(key=api_key, output_format="pandas", treat_info_as_error=True) def _to_av_interval(self, interval: Interval) -> AVInterval: """ Convert the Broker Interval to AlphaVantage compatible intervals. Return the converted interval or None if a conversion is not available """ if interval == Interval.MINUTE_1: return AVInterval.MIN_1 elif interval == Interval.MINUTE_5: return AVInterval.MIN_5 elif interval == Interval.MINUTE_15: return AVInterval.MIN_15 elif interval == Interval.MINUTE_30: return AVInterval.MIN_30 elif interval == Interval.HOUR: return AVInterval.MIN_60 elif interval == Interval.DAY: return AVInterval.DAILY elif interval == Interval.WEEK: return AVInterval.WEEKLY elif interval == Interval.MONTH: return AVInterval.MONTHLY else: logging.error( "Unable to convert interval {} to AlphaVantage equivalent". format(interval.value)) raise ValueError("Unsupported Interval value: {}".format(interval)) def get_prices(self, market: Market, interval: Interval, data_range: int) -> MarketHistory: data = None av_interval = self._to_av_interval(interval) if (av_interval == AVInterval.MIN_1 or av_interval == AVInterval.MIN_5 or av_interval == AVInterval.MIN_15 or av_interval == AVInterval.MIN_30 or av_interval == AVInterval.MIN_60): data = self.intraday(market.id, av_interval) elif av_interval == AVInterval.DAILY: data = self.daily(market.id) elif av_interval == AVInterval.WEEKLY: data = self.weekly(market.id) # TODO implement monthly call else: raise ValueError("Unsupported Interval.{}".format(interval.name)) history = MarketHistory( market, data.index, data["2. high"].values, data["3. low"].values, data["4. close"].values, data["5. volume"].values, ) return history def daily(self, marketId: str) -> pandas.DataFrame: """ Calls AlphaVantage API and return the Daily time series for the given market - **marketId**: string representing an AlphaVantage compatible market id - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call(self._config.get_alphavantage_api_timeout()) market = self._format_market_id(marketId) try: data, meta_data = self.TS.get_daily(symbol=market, outputsize="full") return data except Exception as e: print(e) logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None def intraday(self, marketId: str, interval: AVInterval) -> pandas.DataFrame: """ Calls AlphaVantage API and return the Intraday time series for the given market - **marketId**: string representing an AlphaVantage compatible market id - **interval**: string representing an AlphaVantage interval type - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call(self._config.get_alphavantage_api_timeout()) market = self._format_market_id(marketId) try: data, meta_data = self.TS.get_intraday(symbol=market, interval=interval.value, outputsize="full") return data except Exception as e: logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None def weekly(self, marketId: str) -> pandas.DataFrame: """ Calls AlphaVantage API and return the Weekly time series for the given market - **marketId**: string representing an AlphaVantage compatible market id - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call(self._config.get_alphavantage_api_timeout()) market = self._format_market_id(marketId) try: data, meta_data = self.TS.get_weekly(symbol=market) return data except Exception as e: logging.error("AlphaVantage wrong api call for {}".format(market)) logging.debug(e) logging.debug(traceback.format_exc()) logging.debug(sys.exc_info()[0]) return None def quote_endpoint(self, market_id: str) -> pandas.DataFrame: """ Calls AlphaVantage API and return the Quote Endpoint data for the given market - **market_id**: string representing the market id to fetch data of - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call(self._config.get_alphavantage_api_timeout()) market = self._format_market_id(market_id) try: data, meta_data = self.TS.get_quote_endpoint(symbol=market, outputsize="full") return data except Exception: logging.error("AlphaVantage wrong api call for {}".format(market)) return None # Technical indicators def get_macd(self, market: Market, interval: Interval, datapoints_range: int) -> MarketMACD: av_interval = self._to_av_interval(interval) data = self.macdext(market.id, av_interval) macd = MarketMACD( market, data.index, data["MACD"].values, data["MACD_Signal"].values, data["MACD_Hist"].values, ) return macd def macdext(self, marketId: str, interval: AVInterval) -> pandas.DataFrame: """ Calls AlphaVantage API and return the MACDEXT tech indicator series for the given market - **marketId**: string representing an AlphaVantage compatible market id - **interval**: string representing an AlphaVantage interval type - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call(self._config.get_alphavantage_api_timeout()) market = self._format_market_id(marketId) data, meta_data = self.TI.get_macdext( market, interval=interval.value, series_type="close", fastperiod=12, slowperiod=26, signalperiod=9, fastmatype=2, slowmatype=1, signalmatype=0, ) return data def macd(self, marketId: str, interval: AVInterval) -> pandas.DataFrame: """ Calls AlphaVantage API and return the MACDEXT tech indicator series for the given market - **marketId**: string representing an AlphaVantage compatible market id - **interval**: string representing an AlphaVantage interval type - Returns **None** if an error occurs otherwise the pandas dataframe """ self._wait_before_call(self._config.get_alphavantage_api_timeout()) market = self._format_market_id(marketId) data, meta_data = self.TI.get_macd( market, interval=interval.value, series_type="close", fastperiod=12, slowperiod=26, signalperiod=9, ) return data # Utils functions def _format_market_id(self, marketId: str) -> str: """ Convert a standard market id to be compatible with AlphaVantage API. Adds the market exchange prefix (i.e. London is LON:) """ # TODO MarketProvider/IGInterface should return marketId without "-UK" return "{}:{}".format("LON", marketId.split("-")[0])
def index(request): form = nameofstock() price = 0.0 m = money.objects.get(pk=1) amount = m.mymoney amount = round(amount, 2) rem = 1000000 - amount rem = round(rem, 2) close = [] close1 = [] close2 = [] no = [] no1 = [] no2 = [] s = "" labels = [] datap = [] DataFrame3 = "Table for Particular Stock" #rem=investments.objects.filter(field_name__isnull=True).aggregate(Sum('price')) query_results = investments.objects.all().order_by('-id')[:10] if request.method == 'POST': if ('stockname' in request.POST): form = nameofstock(request.POST) n = form.data['stockname'] api_key = 'BJQZ9I2H012Q7FDD' ts = TimeSeries(key=api_key, output_format='json') data, meta_data = ts.get_quote_endpoint(n) price = float(data['05. price']) price = round(price, 2) if (price != 0.0): if (amount > price): amount = amount - price amount = round(amount, 2) m.mymoney = amount m.save() t = time.localtime() current_time = str(time.strftime("%H:%M:%S", t)) a = investments(name=n.upper(), price=price, date_created=str(date.today()), current_time=current_time) a.save() rem = 1000000 - amount rem = round(rem, 2) #rem=investments.objects.filter(price__isnull=True).aggregate(Sum('price')) #if form.is_valid(): # pass elif ('sn' in request.POST): DataFrame3 = yf.download(request.POST['sn'], request.POST['sdate1'], request.POST['edate1']) DataFrame3 = DataFrame3.to_html() else: DataFrame = yf.download(request.POST['s'], request.POST['sdate'], request.POST['edate']) DataFrame1 = yf.download("AAPL", request.POST['sdate'], request.POST['edate']) DataFrame2 = yf.download("TSLA", request.POST['sdate'], request.POST['edate']) close = DataFrame['Close'].tolist() close1 = DataFrame1['Close'].tolist() close2 = DataFrame2['Close'].tolist() s = str(request.POST['s']) for i in range(len(close)): no.append(i + 1) for i in range(len(close1)): no1.append(i + 1) for i in range(len(close2)): no2.append(i + 1) d = dict() queryset = investments.objects.order_by('name') for stock in queryset: labels.append(stock.name) datap.append(stock.price) for i in range(len(labels)): if (labels[i] in d.keys()): d[labels[i]] += datap[i] else: d[labels[i]] = datap[i] labels = list(d.keys()) datap = list(d.values()) return render( request, 'portfolio/index.html', { 'labels': labels, 'datap': datap, 'form': form, 'price': price, 'amount': amount, 'query_results': query_results, 'rem': rem, 'close': close, 'no': no, 's': s, 'close1': close1, 'close2': close2, 'no1': no1, 'no2': no2, 'DataFrame3': DataFrame3 })
def timeSeries(API_key, ticker): from alpha_vantage.timeseries import TimeSeries import matplotlib.pyplot as plt import mplfinance as mpf ts=TimeSeries(key=API_key, output_format='pandas') option=input('1. Intraday\n2. Daily\n3. Weekly\n4. Monthly\n5. Quote Endpoint\n6. Search Endpoint\n').lower() if option=='intraday' or option=='1': interval=int(input("Enter the interval:\n\t1. 1 minute\n\t2. 5 minutes\n\t3. 15 minutes\n\t4. 30 minutes\n\t5. 60 minutes\n")) inter=['','1min','5min','15min','30min','60min'] data=ts.get_intraday(symbol=ticker, interval=inter[interval])[0] data.columns = ['Open', 'High', 'Low', 'Close', 'Volume'] data.index.name = "Date" mpf.plot(data, type='candle', title=f"Intraday Time series for the {ticker} stock {inter[interval]}", mav=(20), volume=True, tight_layout=True, style='yahoo') return data elif option=='daily' or option=='2': data=ts.get_daily_adjusted(symbol=ticker)[0] data.columns = ['Open', 'High', 'Low', 'Close', 'Adjusted_close','Volume','Dividend Amount','Split Coefficient'] data.index.name = "Date" mpf.plot(data, type='candle', title=f'Daily Time series for the {ticker} stock', mav=(20), volume=True, tight_layout=True, style='yahoo') return data elif option=='weekly' or option=='3': data=ts.get_weekly_adjusted(symbol=ticker)[0] data.columns = ['Open', 'High', 'Low', 'Close', 'Adjusted_close','Volume','Dividend Amount'] data.index.name = "Date" mpf.plot(data, type='candle', title=f'Weekly Time series for the {ticker} stock', mav=(20), volume=True, tight_layout=True, style='yahoo') return data elif option=='monthly' or option=='4': data=ts.get_monthly_adjusted(symbol=ticker)[0] data.columns = ['Open', 'High', 'Low', 'Close', 'Adjusted_close','Volume','Dividend Amount'] data.index.name = "Date" mpf.plot(data, type='candle', title=f'Monthly Time series for the {ticker} stock', mav=(20), volume=True, tight_layout=True, style='yahoo') return data elif option=='quote endpoint' or option=='5': data=ts.get_quote_endpoint(symbol=ticker)[0] return data elif option=='search endpoint' or option=='6': keywords=input('Enter the Name of the Stock:\n') data=ts.get_symbol_search(keywords=keywords)[0] return data else: print("CANNOT RECOGNIZE")
class Strat(object): def __init__(self): self.key = 'your_alphavantage_key_here' self.ts = TimeSeries(self.key, output_format='pandas') self.ti = TechIndicators(self.key, output_format='pandas') self.secinfo = {} def dt64_to_dt(self, date): # Takes in the numpy dt64 and returns a dt object timestamp = ((date - np.datetime64('1970-01-01T00:00:00')) / np.timedelta64(1, 's')) return datetime.datetime.utcfromtimestamp(timestamp) def get_daily_ts(self, ticker): # Gets 5min intraday from alpha vantage, unless has an existing updated one stored within last 6.5h # That way, will still be updated if I try on the last minute of any trading day if was called at its start if self.secinfo.get(ticker) and self.is_up_to_date(ticker, 390): return self.secinfo[ticker][0] else: data, inf = self.ts.get_daily(symbol=ticker, outputsize='full') # Store data in dict to avoid API calls if possible, include timestamp to know when update needed data.index = data.index.map(self.dt64_to_dt) self.secinfo[ticker] = (data, datetime.datetime.now()) return data def get_intraday_ts(self, ticker, interv): # Gets 5min intraday from alpha vantage, unless has an existing updated one stored strint = str(interv) if self.secinfo.get(ticker + strint + 'min') and self.is_up_to_date( ticker + strint + 'min', 5): return self.secinfo[ticker + strint + 'min'][0] else: data, inf = self.ts.get_intraday(symbol=ticker, interval=strint + 'min', outputsize='full') # Store data in dict to avoid API calls if possible, include timestamp to know when update needed data.index = data.index.map(self.dt64_to_dt) self.secinfo[ticker + strint + 'min'] = (data, datetime.datetime.now()) return data def get_ts_for_day(self, ticker, interv, offset=0): data = self.get_intraday_ts(ticker, interv) tod = datetime.datetime.now().date() - datetime.timedelta(days=offset) todaydata = data[data.index.date == tod] return todaydata def get_curr_price_chng(self, ticker, offset=0): # Returns the percent price change since beginning of day if self.secinfo.get(ticker + 'price_change') and self.is_up_to_date( ticker + 'price_change', 5): return self.secinfo[ticker + 'price_change'][0] else: # Alpha vantage doesn't have a way to select just current day's price, so # Get 5 min intraday and select first entry, calculate % difference todaydata = self.get_ts_for_day(ticker, 5, offset) price_change = (todaydata['4. close'].values[-1] - todaydata['4. close'].values[0] ) / todaydata['4. close'].values[0] self.secinfo[ticker + 'price_change'] = (price_change, datetime.datetime.now()) return price_change def get_quote(self, ticker): # Gets quote from alpha vantage, unless has an existing updated one stored if self.secinfo.get(ticker + 'quote') and self.is_up_to_date( ticker + 'quote', 5): return self.secinfo[ticker + 'quote'][0] else: data = self.ts.get_quote_endpoint(symbol=ticker) # Store data in dict to avoid API calls if possible, include timestamp to know when update needed self.secinfo[ticker + 'quote'] = (data, datetime.datetime.now()) return data def get_curr_price_vol(self, ticker): # returns current price and volume of stock data = self.get_quote(ticker) price = float(data[0]['05. price'].values[0]) vol = float(data[0]['06. volume'].values[0]) self.secinfo[ticker + 'price_vol'] = (price, vol, datetime.datetime.now()) return (price, vol) def is_up_to_date(self, info, recency): # Takes type of info (ticker+price_change,quote,price_vol,etc), and recency in minutes # Checks whether data has been updated in the last 5 min return datetime.datetime.now( ) - self.secinfo[info][-1] <= datetime.timedelta(minutes=recency) def has_bodyless_sticks(self, ticker, offset=0): # Checks if and how many bodyless sticks the stock has since day start if self.secinfo.get(ticker + 'bodyless') and self.is_up_to_date( ticker + 'bodyless', 5): return self.secinfo[ticker + 'bodyless'][0] else: # Alpha vantage doesn't have a way to select just current day's price, so # Get 5 min intraday and select first entry, calculate % difference todaydata = self.get_ts_for_day(ticker, 5, offset=offset) body = (todaydata['4. close'].values - todaydata['1. open'].values) / todaydata['1. open'].values noofbodyless = len([b for b in body if abs(b) < 1.0e-4]) too_many_bodyless = noofbodyless >= 2 self.secinfo[ticker + 'bodyless'] = (too_many_bodyless, datetime.datetime.now()) return too_many_bodyless def get_intra_sma(self, ticker, interv, period, plot=False, offset=0): # Takes ticker, period, and interval as strings, and returns the daily sma as pd series for noof offset days ago strint, strper = str(interv), str(period) tod = (datetime.datetime.now() - datetime.timedelta(days=offset)).date() strtod = tod.strftime("%Y/%m/%d") # Check if updated data already exists in dict if self.secinfo.get(ticker+strint+'m_sma_'+strper+'p_'+strtod) and \ self.is_up_to_date(ticker+strint+'m_sma_'+strper+'p_'+strtod,5): return self.secinfo[ticker + strint + 'm_sma_' + strper + 'p_' + strtod][0] else: close = self.get_intraday_ts(ticker, interv)['4. close'] sma = talib.SMA(close, timeperiod=period) todsma = sma[sma.index.date == tod] smadf = pd.DataFrame({'SMA': todsma}) self.secinfo[ticker + strint + 'm_sma_' + strper + 'p_' + strtod] = (smadf, datetime.datetime.now()) if plot: plt.figure(figsize=(20, 6)) plt.plot(todaydata) plt.show() else: pass return smadf def get_daily_sma(self, ticker, period=20, plot=False): # Takes ticker, interval, period, plot, returns the sma as pd series for longer period strper = str(period) # Check if updated data exists in dict if self.secinfo.get(ticker+'daily_sma_'+strper+'p') and \ self.is_up_to_date(ticker+'daily_sma_'+strper+'p',5): return self.secinfo[ticker + 'daily_sma_' + strper + 'p'][0] else: close = self.get_daily_ts(ticker)['4. close'] sma = talib.SMA(close, timeperiod=period) self.secinfo[ticker + 'daily_sma_' + strper + 'p'] = (sma, datetime.datetime.now()) if plot: plt.figure(figsize=(20, 6)) plt.plot(sma) plt.show() return sma def check_sticks_sma(self, ticker, tolerance=80, mov=True, offset=0): # Checks if tolerance% of sticks for given day are above/below the SMA (depending on mov:1up,0down) # True if fe. 80% sticks are above sma on an upward trend data = self.get_ts_for_day(ticker, 5, offset) sma = self.get_intra_sma(ticker, 5, 8) datalen = len(data) newdata = pd.concat([data, sma], axis=1) if mov: sticks = newdata['4. close'] - newdata['SMA'] return len(sticks[sticks > 0]) >= 0.01 * tolerance * datalen else: sticks = newdata['SMA'] - newdata['1. open'] return len(sticks[sticks > 0]) >= 0.01 * tolerance * datalen def check_noof_plbcks(self, ticker, tolerance=80, mov=True, offset=0): # Returns true if pullbacks account for fe. 1-tolerance% or less of all 5min movements data = self.get_ts_for_day(ticker, 5, offset) datalen = len(data) if mov: mvmnt = data['4. close'] - data['1. open'] return len(mvmnt[mvmnt > 0]) >= 0.01 * tolerance * datalen else: mvmnt = data['1. open'] - newdata['4. close'] return len(mvmnt[mvmnt > 0]) >= 0.01 * tolerance * datalen def check_sizeof_plbcks(self, ticker, tolerance=3, mov=True, offset=0): #Returns true if each pullback ends no lower than the hit tolerance periods ago data = self.get_ts_for_day(ticker, 5, offset) datalen = len(data) if mov: myser = data['1. open'].shift(periods=tolerance) data = data.iloc[tolerance:].assign(before=myser.iloc[tolerance:]) checkdata = data[data['4. close'] < data['before']] return len(checkdata) == 0 else: myser = data['1. open'].shift(periods=tolerance) data = data.iloc[tolerance:].assign(before=myser.iloc[tolerance:]) checkdata = data[(data['4. close'] > data['before'])] return len(checkdata) == 0 def get_opt_info(self): # Expand to pass as params the ticker, date, other things that interest us atr = AllyTrader() res = atr.get_option_info() return res def analyze_stonks(self, l, offset=0): # Takes a list of stock tickers, prints dict of strategy stats for each, # The count of 5 is due to alpha vantage hits limitations dict = {} counter = 0 for s in l: if counter != 5: try: d={'prc_chng':st.get_curr_price_chng(s,offset=offset),\ 'bodyless_sticks':st.has_bodyless_sticks(s,offset=offset),\ 'sticks_sma':st.check_sticks_sma(s,offset=offset),\ 'noof_plbcks':st.check_noof_plbcks(s,offset=offset),\ 'sizeof_plbcks':st.check_sizeof_plbcks(s,offset=offset)} print("Got stats for", s) dict[s] = d counter += 1 except: print("could not get data for ", s) print(sys.exc_info()[0]) else: print("sleeping") time.sleep(60) counter = 0 for k, v in zip(dict.keys(), dict.values()): print(k, ":", v, '\n')
class REST(object): def __init__(self, api_key): self._api_key = get_alpha_vantage_credentials(api_key) self._session = requests.Session() self._timeseries = TimeSeries(key=self._api_key) self._cryptocurrencies = CryptoCurrencies(key=self._api_key) self._foreignexchange = ForeignExchange(key=self._api_key) self._sectorperformance = SectorPerformances(key=self._api_key) self._techindicators = TechIndicators(key=self._api_key) def _request(self, method, params=None): url = 'https://www.alphavantage.co/query?' params = params or {} params['apikey'] = self._api_key resp = self._session.request(method, url, params=params) resp.raise_for_status() return resp.json() def get(self, params=None): ''' Customizable endpoint, where you can pass all keywords/paramters from the documentation: https://www.alphavantage.co/documentation/# Returns: pandas, csv, or json ''' return self._request('GET', params=params) def historic_quotes(self, symbol, adjusted=False, outputsize='full', cadence='daily', output_format=None): ''' Returns the one of the TIME_SERIES_* endpoints of the Alpha Vantage API. Params: symbol: The ticker to return adjusted: Return the adjusted prices cadence: Choose between ['daily', 'weekly', 'monthly'], to return the cadence output_format: Choose between['json', 'csv', 'pandas'] Returns: pandas, csv, or json ''' if output_format: self._timeseries.output_format = output_format if cadence == 'daily': data, _ = self._timeseries.get_daily_adjusted( symbol=symbol, outputsize=outputsize) if adjusted else self._timeseries.get_daily(symbol=symbol, outputsize=outputsize) if cadence == 'weekly': data, _ = self._timeseries.get_weekly_adjusted( symbol=symbol) if adjusted else self._timeseries.get_weekly(symbol=symbol) if cadence == 'monthly': data, _ = self._timeseries.get_monthly_adjusted( symbol=symbol) if adjusted else self._timeseries.get_monthly(symbol=symbol) return data def intraday_quotes(self, symbol, interval='5min', outputsize='full', output_format=None): ''' Returns the TIME_SERIES_INTRADAY endpoint of the Alpha Vantage API. Params: symbol: The ticker to return interval: Choose between['1min', '5min', '15min', '30min', '60min'] output_format: Choose between['json', 'csv', 'pandas'] Returns: pandas, csv, or json ''' if output_format: self._timeseries.output_format = output_format data, _ = self._timeseries.get_intraday( symbol=symbol, interval=interval, outputsize=outputsize) return data def current_quote(self, symbol): ''' Returns the GLOBAL_QUOTE endpoint of the Alpha Vantage API. Params: symbol: The ticker to return output_format: Choose between['json', 'csv', 'pandas'] Returns: pandas, csv, or json ''' data, _ = self._timeseries.get_quote_endpoint(symbol=symbol) return data def last_quote(self, symbol): return self.current_quote(symbol) def company(self, symbol, datatype='json'): return self.search_endpoint(symbol, datatype=datatype) def search_endpoint(self, keywords, datatype='json'): '''Search endpoint returns a list of possible companies that correspond to keywords Params: datatype: csv, json, or pandas keywords: ex. keywords=microsoft Returns: pandas, csv, or json ''' params = {'function': 'SYMBOL_SEARCH', 'keywords': keywords, 'datatype': datatype} return self.get(params) def historic_fx_quotes(self, from_symbol, to_symbol, outputsize='full', cadence='daily', output_format=None): ''' Returns the one of the FX_* endpoints of the Alpha Vantage API. Params: from_currency: The symbol to convert to_currency: The symbol to convert to cadence: Choose between ['daily', 'weekly', 'monthly'], to return the cadence output_format: Choose between['json', 'csv', 'pandas'] Returns: pandas, csv, or json ''' if output_format: self._foreignexchange.output_format = output_format if cadence == 'daily': data, _ = self._foreignexchange.get_currency_exchange_daily( from_symbol=from_symbol, to_symbol=to_symbol, outputsize=outputsize) if cadence == 'weekly': data, _ = self._foreignexchange.get_currency_exchange_weekly( from_symbol=from_symbol, to_symbol=to_symbol, outputsize=outputsize) if cadence == 'monthly': data, _ = self._foreignexchange.get_currency_exchange_monthly( from_symbol=from_symbol, to_symbol=to_symbol, utputsize=outputsize) return data def intraday_fx_quotes(self, from_symbol, to_symbol, interval='5min', outputsize='full', output_format=None): ''' Returns the FX_INTRADAY endpoint of the Alpha Vantage API. Params: from_currency: The symbol to convert to_currency: The symbol to convert to interval: Choose between['1min', '5min', '15min', '30min', '60min'] output_format: Choose between['json', 'csv', 'pandas'] Returns: pandas, csv, or json ''' if output_format: self._foreignexchange.output_format = output_format data, _ = self._foreignexchange.get_currency_exchange_intraday( from_symbol=from_symbol, to_symbol=to_symbol, interval=interval, outputsize=outputsize) return data def exchange_rate(self, from_currency, to_currency): ''' Returns the exchange rate of two currencies, digital or physical. CURRENCY_EXCHANGE_RATE endpoint of the Alpha Vantage API Params: from_currency: The symbol to convert to_currency: The symbol to convert to Returns: json ''' params = {'function': "CURRENCY_EXCHANGE_RATE", 'from_currency': from_currency, 'to_currency': to_currency} data = self.get(params) return data def historic_cryptocurrency_quotes(self, symbol, market, cadence='daily', output_format=None): ''' Returns the one of the DIGITAL_CURRENCY_* endpoints of the Alpha Vantage API. Params: symbol: The cryptocurrency to return market: The market it's being sold on cadence: Choose between ['daily', 'weekly', 'monthly'], to return the cadence output_format: Choose between['json', 'csv', 'pandas'] Returns: pandas, csv, or json ''' if output_format: self._cryptocurrencies.output_format = output_format if cadence == 'daily': data, _ = self._cryptocurrencies.get_digital_currency_daily( symbol=symbol, market=market) if cadence == 'weekly': data, _ = self._cryptocurrencies.get_digital_currency_weekly( symbol=symbol, market=market) if cadence == 'monthly': data, _ = self._cryptocurrencies.get_digital_currency_monthly( symbol=symbol, market=market) return data def techindicators(self, techindicator='SMA', output_format='json', **kwargs): ''' Returns the one of the technical indicator endpoints of the Alpha Vantage API. Params: techindicator: The technical indicator of choice params: Each technical indicator has additional optional parameters Returns: pandas, csv, or json ''' if output_format: self._techindicators.output_format = output_format params = {'function': techindicator} for key, value in kwargs.items(): params[key] = value data = self.get(params) return data def sector(self): ''' Returns the sector performances Returns: pandas, csv, or json ''' data, _ = self._sectorperformance.get_sector() return data
from qifparse.parser import QifParser from alpha_vantage.timeseries import TimeSeries import time ts = TimeSeries(key='5I186NCN3TF27H5P', output_format='csv') file = open('QuickenExport.QIF') qif = QifParser.parse(file) print("Parsed it ...") quotes = set() for price in qif.get_prices(): quotes.add(price.name) print(quotes) newquotes = {} outstring = "" for quote in quotes: data, meta_data = ts.get_quote_endpoint(quote) data = list(data) if len(data) == 2: price = float(list(data)[1][4]) #print(quote) outstring += "%s, %.3f\n" % (quote, price) # unpayed acces to apha vantage needs 12 seconds between every parse time.sleep(12) outfile = open('LatestStockPrices.csv', 'w') outfile.write(outstring) file.close()
client.on_publish = on_publish ################################################################ # Main Loop # ################################################################ while True: # Start Time start = time.time() try: # Poll for data tickers = getConfigList(config.get("CONFIG", "tickers")) ts = TimeSeries(key=config.get("SECRET", "api_key")) with ThreadPoolExecutor() as executer: data = executer.map( lambda stock:ts.get_quote_endpoint(symbol=stock), tickers) for item in data: publish(item[0]["01. symbol"], item[0]["05. price"]) except Exception as e: log.error( "Error polling data: {}".format(e)) # Calculate Sleep Timer interval = time.time() - start sleep = config.getint("CONFIG", "interval") - interval if sleep > 0: time.sleep(sleep)
def stockQuote(symbol): ts = TimeSeries(key=key, output_format='pandas') data, meta_data = ts.get_quote_endpoint(symbol) cPrice = data.iloc[0, 4] currentPrice = float(cPrice)
class AlphaVantageClient: def __init__(self, api_key=None): if api_key is None: default_api_key = utils.get_api_key('AlphaVantage') if default_api_key is None: raise ValueError('No AlphaVantage API Key found.') else: self.ts = TimeSeries(key=default_api_key, output_format='pandas') else: self.ts = TimeSeries(key=api_key, output_format='pandas') def get_data(self, symbol, freq='daily', adjusted=True, interval='15min', outputsize='full'): """ Return time series in pandas formet. Keyword Arguments: symbol: the symbol for the equity we want to get its data freq: frequency of data, supported values are 'daily', 'weekly', 'monthly' (default 'daily'). Currently not support for 'intraday' adjusted: adjust the OHLC value (default True) interval: time interval between two conscutive values, used when freq is intraday supported values are '1min', '5min', '15min', '30min', '60min' (default '15min') outputsize: The size of the call, supported values are 'compact' and 'full; the first returns the last 100 points in the data series, and 'full' returns the full-length intraday times series, commonly above 1MB (default 'compact') """ key = '{}-{}'.format(freq, adjusted) # elif key == 'intraday-True': # data, _ = self.ts.get_intraday(symbol=symbol, interval=interval, outputsize=outputsize) # elif key == 'intraday-False': # data, _ = self.ts.get_intraday(symbol=symbol, interval=interval, outputsize=outputsize) if key == 'daily-True': data, _ = self.ts.get_daily_adjusted(symbol=symbol, outputsize=outputsize) elif key == 'daily-False': data, _ = self.ts.get_daily(symbol=symbol, outputsize=outputsize) elif key == 'weekly-True': data, _ = self.ts.get_weekly_adjusted(symbol=symbol) elif key == 'weekly-False': data, _ = self.ts.get_weekly(symbol=symbol) elif key == 'monthly-True': data, _ = self.ts.get_monthly_adjusted(symbol=symbol) elif key == 'monthly-False': data, _ = self.ts.get_monthly(symbol=symbol) else: raise Warning( 'Freq: {} or Adjusted: {} is not valid. Default to Daily Adjusted.' ) data, _ = self.ts.get_daily_adjusted(symbol=symbol, outputsize=outputsize) if freq == 'intraday': data.columns = ['Open', 'High', 'Low', 'Close', 'Volume'] else: columns_name = [ 'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume', 'Dividends', 'Stock Splits' ] data.columns = columns_name[:len(data.columns)] data = data.rename(index={'date': 'Date'}) return data.sort_index(ascending=True) def get_latest_data(self, symbol): """ Return the latest price and volume information for a security of your choice Keyword Arguments: symbol: the symbol for the equity we want to get its data """ data, _ = self.ts.get_quote_endpoint(symbol=symbol) columns_name = [ 'Open', 'High', 'Low', 'Price', 'Volume', 'Date', 'Previous Close', 'Change', 'Change Pct' ] data = data.iloc[:, 1:] data.columns = columns_name data = data.set_index(['Date']) return data