def __init__(self, tickers: list, tf: str = None, name: str = None, strategy: ta.Strategy = None, ds: object = None, **kwargs): self.tickers = tickers self.tf = tf self.verbose = kwargs.pop("verbose", False) self.debug = kwargs.pop("debug", False) self.name = name self.data = None self.kwargs = kwargs self.strategy = strategy if ds is not None: self.ds = ds elif isinstance(ds, str) and ds.lower() == "yahoo": self.ds = yf else: AVkwargs = { "api_key": "YOUR API KEY", "clean": True, "export": True, "export_path": ".", "output_size": "full", "premium": False } av_kwargs = kwargs.pop("av_kwargs", AVkwargs) self.ds = AlphaVantage(**av_kwargs)
def setUpClass(cls): cls.test_data_path = C.TEST_DATA_PATH # Set premium to True to avoid API throttling for testing av = AlphaVantage(api_key=C.API_KEY_TEST, premium=True) # Minimum parameters cls.batch_parameters = { 'function': 'BATCH_STOCK_QUOTES', 'symbols': C.API_BATCH_TEST } cls.fx_parameters = { 'function': 'CURRENCY_EXCHANGE_RATE', 'from_currency': 'USD', 'to_currency': 'JPY' } cls.sector_parameters = {'function': 'SECTOR'} cls.data_parameters = { 'function': 'TIME_SERIES_DAILY_ADJUSTED', 'symbol': C.API_DATA_TEST } cls.intraday_parameters = { 'function': 'TIME_SERIES_INTRADAY', 'symbol': C.API_DATA_TEST } cls.indicator_parameters = { 'function': 'RSI', 'symbol': C.API_DATA_TEST, 'interval': 'weekly', 'series_type': 'open', 'time_period': 10 } cls.digital_parameters = { 'function': 'DIGITAL_CURRENCY_DAILY', 'symbol': C.API_DIGITAL_TEST, 'market': 'CNY' } # json files of sample data cls.json_batch = load_json(cls.test_data_path / 'mock_batch.json') cls.json_fx = load_json(cls.test_data_path / 'mock_fx.json') cls.json_sectors = load_json(cls.test_data_path / 'mock_sectors.json') cls.json_data = load_json(cls.test_data_path / 'mock_data.json') cls.json_indicator = load_json(cls.test_data_path / 'mock_indicator.json') cls.json_digital = load_json(cls.test_data_path / 'mock_digital.json') # Pandas DataFrames of sample data cls.df_batch = av._to_dataframe('BATCH_STOCK_QUOTES', cls.json_batch) cls.df_fx = av._to_dataframe('CURRENCY_EXCHANGE_RATE', cls.json_fx) cls.df_sectors = av._to_dataframe('SECTOR', cls.json_sectors) cls.df_data = av._to_dataframe('TIME_SERIES_DAILY_ADJUSTED', cls.json_data) cls.df_indicator = av._to_dataframe('RSI', cls.json_indicator) cls.df_digital = av._to_dataframe('DIGITAL_CURRENCY_DAILY', cls.json_digital)
# -*- coding: utf-8 -*- import time import math import re import numpy as np import pandas as pd from os import getenv as os_getenv from ._base_pandas_object import * from alphaVantageAPI.alphavantage import AlphaVantage # Load an instance of AV with user's environment variable 'AV_API_KEY' # Force Clean _AV_ = AlphaVantage(api_key=None, clean=True) @pd.api.extensions.register_dataframe_accessor('av') class AlphaVantageDownloader(BasePandasObject): def __call__(self, q=None, output_size='compact', timed=False, *args, **kwargs): try: if isinstance(q, str): q = q.lower() fn = getattr(self, q) if timed: stime = time.time()
# -*- coding: utf-8 -*- import datetime as dt from pathlib import Path from random import random import pandas as pd # pip install pandas from alphaVantageAPI.alphavantage import AlphaVantage # pip install alphaVantage-api import pandas_ta as ta # pip install pandas_ta AV = AlphaVantage(api_key="YOUR API KEY", premium=False, clean=True, output_size="full") class Watchlist(object): """Watchlist Class (** This is subject to change! **) ============================================================================ A simple Class to load/download financial market data and automatically apply Technical Analysis indicators with a Pandas TA Strategy. Default Strategy: pandas_ta.AllStrategy. Requirements: - Pandas TA (pip install pandas_ta) - AlphaVantage (pip install alphaVantage-api) for the Default Data Source. To use another Data Source, update the load() method after AV. Required Arguments: - tickers: A list of strings containing tickers. Example: ['SPY', 'AAPL']
def setUp(self): self.API_KEY_TEST = C.API_KEY_TEST self.av = AlphaVantage(api_key=self.API_KEY_TEST)
class TestAlphaVantageAPIProperties(TestCase): def setUp(self): self.API_KEY_TEST = C.API_KEY_TEST self.av = AlphaVantage(api_key=self.API_KEY_TEST) @patch('os.getenv') @patch('sys.exit') def test_apikey(self, mock_sys_exit, mock_os_getenv): self.assertEqual(self.API_KEY_TEST, 'demo') mock_os_getenv.return_value = None self.av.api_key = None self.assertIsNone(self.av.api_key) mock_sys_exit.return_value = True self.av.api_key = 13 self.assertIsNone(self.av.api_key) self.assertTrue(mock_sys_exit) self.assertEqual(mock_sys_exit.call_count, 1) # How to mock the print())? def test_premium_property(self): self.av.premium = True self.assertTrue(self.av.premium) self.av.premium = False self.assertFalse(self.av.premium) def test_export_property(self): self.av.export = True self.assertTrue(self.av.export) self.av.export = False self.assertFalse(self.av.export) def test_export_path_property(self): self.av.export_path = None self.assertIsInstance(self.av.export_path, Path) self.av.export_path = '' self.assertIsInstance(self.av.export_path, Path) subdir = 'av_test' self.av.export_path = '~/{}'.format(subdir) self.assertIsInstance(self.av.export_path, Path) self.assertEqual(str(self.av.export_path), str(Path().home() / subdir)) self.av.export_path = '/tmp/av_test' self.assertIsInstance(self.av.export_path, Path) def test_output_property(self): json = 'json' self.av.output = json self.assertEqual(self.av.output, json) csv = 'csv' self.av.output = csv self.assertEqual(self.av.output, csv) other = 'other' self.av.output = other self.assertNotEqual(self.av.output, other) self.assertEqual(self.av.output, csv) def test_datatype_property(self): csv = 'csv' self.av.datatype = csv self.assertEqual(self.av.datatype, csv) json = 'json' self.av.datatype = json self.assertEqual(self.av.datatype, json) other = 'other' self.av.datatype = other self.assertEqual(self.av.datatype, json) def test_output_size_property(self): full = 'full' self.av.output_size = full self.assertEqual(self.av.output_size, full) compact = 'compact' self.av.output_size = compact self.assertEqual(self.av.output_size, compact) compact = 'compacT' self.av.output_size = compact self.assertEqual(self.av.output_size, compact.lower()) other = None self.av.output_size = other self.assertEqual(self.av.output_size, 'compact') def test_proxy_property(self): self.assertIsInstance(self.av.proxy, dict) self.av.proxy = None self.assertIsNotNone(self.av.proxy) self.assertIsInstance(self.av.proxy, dict) def test_clean_property(self): self.av.clean = True self.assertTrue(self.av.clean) self.av.clean = False self.assertFalse(self.av.clean) def test_api_initial_parameters(self): self.assertIsInstance(self.av.api_key, str) self.assertEqual(self.av.api_key, self.API_KEY_TEST) self.assertIsInstance(self.av.premium, bool) self.assertEqual(self.av.premium, False) self.assertIsInstance(self.av.export, bool) self.assertEqual(self.av.export, False) self.assertIsInstance(self.av.export_path, Path) self.assertEqual(self.av.export_path, Path().home() / 'av_data') self.assertIsInstance(self.av.output, str) self.assertEqual(self.av.output, 'csv') self.assertIsInstance(self.av.datatype, str) self.assertEqual(self.av.datatype, 'json') self.assertIsInstance(self.av.output_size, str) self.assertEqual(self.av.output_size, 'compact') self.assertIsInstance(self.av.proxy, dict) self.assertEqual(self.av.proxy, {}) self.assertIsInstance(self.av.clean, bool) self.assertEqual(self.av.clean, False) @patch('alphaVantageAPI.alphavantage.AlphaVantage.export_path') def test_init_export_path_method(self, mock_export_path): mock_export_path.side_effect = [OSError, PermissionError] self.assertRaises(OSError, mock_export_path) self.assertRaises(PermissionError, mock_export_path) def test_parameters_method(self): self.assertIsInstance( self.av._parameters('TIME_SERIES_INTRADAY', 'required'), list) self.assertIsInstance( self.av._parameters('TIME_SERIES_INTRADAY', 'optional'), list) self.assertIsInstance(self.av._parameters('SMA', 'required'), list) self.assertIsInstance(self.av._parameters('SMA', 'optional'), list) def test_function_alias_method(self): self.assertEqual(self.av._function_alias('TIME_SERIES_INTRADAY'), 'I') self.assertEqual(self.av._function_alias('TIME_SERIES_DAILY'), 'D') self.assertEqual(self.av._function_alias('TIME_SERIES_DAILY_ADJUSTED'), 'DA') self.assertEqual(self.av._function_alias('TIME_SERIES_WEEKLY'), 'W') self.assertEqual( self.av._function_alias('TIME_SERIES_WEEKLY_ADJUSTED'), 'WA') self.assertEqual(self.av._function_alias('TIME_SERIES_MONTHLY'), 'M') self.assertEqual( self.av._function_alias('TIME_SERIES_MONTHLY_ADJUSTED'), 'MA') self.assertEqual(self.av._function_alias('DIGITAL_CURRENCY_INTRADAY'), 'CI') self.assertEqual(self.av._function_alias('DIGITAL_CURRENCY_DAILY'), 'CD') self.assertEqual(self.av._function_alias('DIGITAL_CURRENCY_WEEKLY'), 'CW') self.assertEqual(self.av._function_alias('DIGITAL_CURRENCY_MONTHLY'), 'CM') self.assertEqual(self.av._function_alias('BATCH_STOCK_QUOTES'), 'B') self.assertEqual(self.av._function_alias('CURRENCY_EXCHANGE_RATE'), 'FX') self.assertEqual(self.av._function_alias('SECTOR'), 'S') self.assertEqual(self.av._function_alias('SMA'), 'SMA') self.assertEqual(self.av._function_alias('DEMA'), 'DEMA') ### and more indicators ... self.assertEqual(self.av._function_alias('Qwerty'), 'Qwerty')
if (Hist_Y < 0 and Hist_T > 0): print('We have a MACD golden cross in weekly time frame. Buy ' + cell.value) # send an e-mail alert ezgmail.send( '*****@*****.**', cell.value + ' shows a MACD golden cross this week', 'There is a MACD golden cross for ' + cell.value + ' during this week!') else: print('No signal') # alphavantage API key ts = AlphaVantage(api_key='##############', datatype='pandas') for x in range(2, 103): try: cell = sheet['A' + str(x)] Macd = ts.data(function='MACD', symbol=cell.value, interval='weekly', series_type='close', fastperiod=12, slowperiod=26, signalperiod=9) Checking_MACD_cross() except: print("An error ocurred while trying to connect to Alphavantage API")
temp_dividends[dividend_days[n]] = dividend_amounts[n] dividends[company] = temp_dividends # create Days with date, high, low print("step1 done") calc = DividendCalculator(days) #start calculations # get_prices(calc, company, name, dividends, market, currency) if __name__ == "__main__": AV = AlphaVantage( api_key="5UV3KMIGR8VPA5AW", premium=True, output_size='full', datatype='json', clean=True, ) db_connection = sqlite3.connect('databases/div_trade_v7.db') db_cursor = db_connection.cursor() db_cursor.execute(f"SELECT Ticker FROM Companies") db_ticker = db_cursor.fetchall() db_connection.close() total_ticker = [] for ticker in db_ticker: if ticker[0] not in total_ticker: total_ticker.append(ticker[0]) total_ticker = total_ticker[total_ticker.index("T") + 2:] for company in total_ticker: start(company)
class Watchlist(object): """Watchlist Class (** This is subject to change! **) ============================================================================ A simple Class to load/download financial market data and automatically apply Technical Analysis indicators with a Pandas TA Strategy. Default Strategy: pandas_ta.AllStrategy. Requirements: - Pandas TA (pip install pandas_ta) - AlphaVantage (pip install alphaVantage-api) for the Default Data Source. To use another Data Source, update the load() method after AV. Required Arguments: - tickers: A list of strings containing tickers. Example: ['SPY', 'AAPL'] ============================================================================ """ def __init__(self, tickers: list, tf: str = None, name: str = None, strategy: ta.Strategy = None, ds: object = None, **kwargs): self.tickers = tickers self.tf = tf self.verbose = kwargs.pop("verbose", False) self.debug = kwargs.pop("debug", False) self.name = name self.data = None self.kwargs = kwargs self.strategy = strategy if ds is not None: self.ds = ds elif isinstance(ds, str) and ds.lower() == "yahoo": self.ds = yf else: AVkwargs = { "api_key": "YOUR API KEY", "clean": True, "export": True, "export_path": ".", "output_size": "full", "premium": False } av_kwargs = kwargs.pop("av_kwargs", AVkwargs) self.ds = AlphaVantage(**av_kwargs) def _drop_columns(self, df: pd.DataFrame, cols: list = [ "Unnamed: 0", "date", "split_coefficient", "dividend" ]): """Helper methods to drop columns silently.""" df_columns = list(df.columns) if any(_ in df_columns for _ in cols): if self.debug: print(f"[i] Possible columns dropped: {', '.join(cols)}") df = df.drop(cols, axis=1, errors="ignore") return df def _load_all(self, **kwargs) -> dict: """Updates the Watchlist's data property with a dictionary of DataFrames keyed by ticker.""" if self.tickers is not None and isinstance(self.tickers, list) and len( self.tickers): self.data = { ticker: self.load(ticker, **kwargs) for ticker in self.tickers } return self.data def load(self, ticker: str = None, tf: str = None, index: str = "date", drop: list = ["dividend", "split_coefficient"], file_path: str = ".", **kwargs) -> pd.DataFrame: """Loads or Downloads (if a local csv does not exist) the data from the Data Source. When successful, it returns a Data Frame for the requested ticker. If no tickers are given, it loads all the tickers.""" tf = self.tf if tf is None else tf.upper() if ticker is not None and isinstance(ticker, str): ticker = str(ticker).upper() else: print(f"[!] Loading All: {', '.join(self.tickers)}") self._load_all(**kwargs) return filename_ = f"{ticker}_{tf}.csv" current_file = Path(file_path) / filename_ # Load local or from Data Source if current_file.exists(): df = pd.read_csv(filename_, index_col=index) if not df.ta.datetime_ordered: df = df.set_index(pd.DatetimeIndex(df.index)) print(f"[i] Loaded['{tf}']: {filename_}") else: print(f"[+] Downloading['{tf}']: {ticker}") if isinstance(self.ds, AlphaVantage): df = self.ds.data(tf, ticker) if not df.ta.datetime_ordered: df = df.set_index(pd.DatetimeIndex(df[index])) elif isinstance(self.ds, yfinance): print("[!] In Development") yf_data = self.ds.Ticker(ticker) df = yf_data.history(period="max") print(yf_data.info) print(df) # Remove select columns df = self._drop_columns(df) if kwargs.pop("analyze", True): if self.debug: print(f"[+] TA[{len(self.strategy.ta)}]: {self.strategy.name}") df.ta.strategy(self.strategy, **kwargs) df.ticker = ticker # Attach ticker to the DataFrame return df @property def data(self) -> dict: """When not None, it contains a dictionary of DataFrames keyed by ticker. data = {"SPY": pd.DataFrame, ...}""" return self._data @data.setter def data(self, value: dict) -> None: # Later check dict has string keys and DataFrame values if value is not None and isinstance(value, dict): if self.verbose: print(f"[+] New data") self._data = value else: self._data = None @property def name(self) -> str: """The name of the Watchlist. Default: "Watchlist: {Watchlist.tickers}".""" return self._name @name.setter def name(self, value: str) -> None: if isinstance(value, str): self._name = str(value) else: self._name = f"Watchlist: {', '.join(self.tickers)}" @property def strategy(self) -> ta.Strategy: """Sets a valid Strategy. Default: pandas_ta.CommonStrategy""" return self._strategy @strategy.setter def strategy(self, value: ta.Strategy) -> None: if value is not None and isinstance(value, ta.Strategy): self._strategy = value else: self._strategy = ta.CommonStrategy @property def tf(self) -> str: """Alias for timeframe. Default: 'D'""" return self._tf @tf.setter def tf(self, value: str) -> None: if isinstance(value, str): value = str(value) self._tf = value else: self._tf = "D" @property def tickers(self) -> list: """tickers If a string, it it converted to a list. Example: "AAPL" -> ["AAPL"] * Does not accept, comma seperated strings. If a list, checks if it is a list of strings. """ return self._tickers @tickers.setter def tickers(self, value: (list, str)) -> None: if value is None: print(f"[X] {value} is not a value in Watchlist ticker.") return elif isinstance(value, list) and [isinstance(_, str) for _ in value]: self._tickers = list(map(str.upper, value)) elif isinstance(value, str): self._tickers = [value.upper()] self.name = self._tickers @property def verbose(self) -> bool: """Toggle the verbose property. Default: False""" return self._verbose @verbose.setter def verbose(self, value: bool) -> None: if isinstance(value, bool): self._verbose = bool(value) else: self._verbose = False def indicators(self, *args, **kwargs) -> any: """Returns the list of indicators that are available with Pandas Ta.""" pd.DataFrame().ta.indicators(*args, **kwargs) def __repr__(self) -> str: s = f"Watch(name='{self.name}', tickers[{len(self.tickers)}]='{', '.join(self.tickers)}', tf='{self.tf}', strategy[{self.strategy.total_ta()}]='{self.strategy.name}'" if self.data is not None: s += f", data[{len(self.data.keys())}])" return s return s + ")"
import openpyxl import os import pandas as pd from alphaVantageAPI.alphavantage import AlphaVantage #from openpyxl import workbook import ezgmail os.chdir('C:\\Automate the stock & bitcoin trading with Python\\Data') workbook = openpyxl.load_workbook('SnP_100.xlsx') sheet = workbook["SnP100"] # alphavantage API key ts = AlphaVantage(api_key='###########', datatype = 'pandas') def Checking_cross(): #calculation for today's difference TEMA_50 = EMA_50.iloc[-1].loc['EMA'] TEMA_200 = EMA_200.iloc[-1].loc['EMA'] TDiff = TEMA_50-TEMA_200 #calculation for yesterday's difference YEMA_50 = EMA_50.iloc[-2].loc['EMA'] YEMA_200 = EMA_200.iloc[-2].loc['EMA'] YDiff = YEMA_50-YEMA_200 if ( YDiff<0 and TDiff>0 ): print('We have a golden cross of 50 EMA and 200 EMA! Buy '+cell.value) # Send an email alert ezgmail.send('*****@*****.**',cell.value+' shows a golden cross today ', 'There was a golden cross of 50 and 200 EMAs for '+cell.value+' It is good time for buying it!') else:
# -*- coding: utf-8 -*- """ Created on Mon Mar 30 12:49:13 2020 @author: esaeri-1122 """ import openpyxl import os import pandas as pd from alphaVantageAPI.alphavantage import AlphaVantage import ezgmail # Alphavantage API key ts = AlphaVantage(api_key='##############', datatype='pandas') Bit = ts.digital(symbol='BTC', market='USD') def calculate_ma(start, end): sum = 0 for x in range(start, end): temp = Bit.iloc[x].loc['4a. close (USD)'] sum = sum + temp average = sum / abs((start - end)) return (average) MA200_T = calculate_ma(-200, 0) MA50_T = calculate_ma(-50, 0) MA200_Y = calculate_ma(-201, -1) MA50_Y = calculate_ma(-51, -1)
from bokeh.layouts import gridplot from bokeh.plotting import figure from bokeh.embed import components from bokeh.models import DatetimeTickFormatter, HoverTool, ColumnDataSource, BasicTickFormatter import pandas as pd import wikipedia, os from alphaVantageAPI.alphavantage import AlphaVantage from stockstats import StockDataFrame key = "U5HDNUUWSMV4P355" AV = AlphaVantage(api_key=key, premium=True, output_size='Full', datatype='json', export=False, export_path='~/av_data', output='csv', clean=False, proxy={}) def chart(stock, sname, wikiD): #set title for all graphs title = 'Latest prices for' + sname #get data data = AV.data(function='DA', symbol=stock) #reshaping the arrays to a fixed length s = 5321
class TestAlphaVantageAPIProperties(TestCase): def setUp(self): self.API_KEY_TEST = C.API_KEY_TEST self.av = AlphaVantage(api_key=self.API_KEY_TEST) @patch("os.getenv") @patch("sys.exit") def test_apikey(self, mock_sys_exit, mock_os_getenv): self.assertEqual(self.API_KEY_TEST, "demo") mock_os_getenv.return_value = None self.av.api_key = None self.assertIsNone(self.av.api_key) mock_sys_exit.return_value = True self.av.api_key = 13 self.assertIsNone(self.av.api_key) self.assertTrue(mock_sys_exit) self.assertEqual(mock_sys_exit.call_count, 1) def test_premium_property(self): self.av.premium = True self.assertTrue(self.av.premium) self.av.premium = False self.assertFalse(self.av.premium) def test_export_property(self): self.av.export = True self.assertTrue(self.av.export) self.av.export = False self.assertFalse(self.av.export) def test_export_path_property(self): self.av.export_path = None self.assertIsInstance(self.av.export_path, Path) self.av.export_path = "" self.assertIsInstance(self.av.export_path, Path) subdir = "av_test" self.av.export_path = "~/{}".format(subdir) self.assertIsInstance(self.av.export_path, Path) self.assertEqual(str(self.av.export_path), str(Path().home() / subdir)) self.av.export_path = "/tmp/av_test" self.assertIsInstance(self.av.export_path, Path) def test_output_property(self): json = "json" self.av.output = json self.assertEqual(self.av.output, json) csv = "csv" self.av.output = csv self.assertEqual(self.av.output, csv) other = "other" self.av.output = other self.assertNotEqual(self.av.output, other) self.assertEqual(self.av.output, csv) def test_datatype_property(self): csv = "csv" self.av.datatype = csv self.assertEqual(self.av.datatype, csv) json = "json" self.av.datatype = json self.assertEqual(self.av.datatype, json) other = "other" self.av.datatype = other self.assertEqual(self.av.datatype, json) def test_output_size_property(self): full = "full" self.av.output_size = full self.assertEqual(self.av.output_size, full) compact = "compact" self.av.output_size = compact self.assertEqual(self.av.output_size, compact) compact = "compacT" self.av.output_size = compact self.assertEqual(self.av.output_size, compact.lower()) other = None self.av.output_size = other self.assertEqual(self.av.output_size, "compact") def test_proxy_property(self): self.assertIsInstance(self.av.proxy, dict) self.av.proxy = None self.assertIsNotNone(self.av.proxy) self.assertIsInstance(self.av.proxy, dict) def test_clean_property(self): self.av.clean = True self.assertTrue(self.av.clean) self.av.clean = False self.assertFalse(self.av.clean) def test_api_initial_parameters(self): self.assertIsInstance(self.av.api_key, str) self.assertEqual(self.av.api_key, self.API_KEY_TEST) self.assertIsInstance(self.av.premium, bool) self.assertEqual(self.av.premium, False) self.assertIsInstance(self.av.export, bool) self.assertEqual(self.av.export, False) self.assertIsInstance(self.av.export_path, Path) self.assertEqual(self.av.export_path, Path().home() / "av_data") self.assertIsInstance(self.av.output, str) self.assertEqual(self.av.output, "csv") self.assertIsInstance(self.av.datatype, str) self.assertEqual(self.av.datatype, "json") self.assertIsInstance(self.av.output_size, str) self.assertEqual(self.av.output_size, "compact") self.assertIsInstance(self.av.proxy, dict) self.assertEqual(self.av.proxy, {}) self.assertIsInstance(self.av.clean, bool) self.assertEqual(self.av.clean, False) @patch("alphaVantageAPI.alphavantage.AlphaVantage.export_path") def test_init_export_path_method(self, mock_export_path): mock_export_path.side_effect = [OSError, PermissionError] self.assertRaises(OSError, mock_export_path) self.assertRaises(PermissionError, mock_export_path) def test_parameters_method(self): self.assertIsInstance( self.av._parameters("TIME_SERIES_INTRADAY", "required"), list) self.assertIsInstance( self.av._parameters("TIME_SERIES_INTRADAY", "optional"), list) self.assertIsInstance(self.av._parameters("SMA", "required"), list) self.assertIsInstance(self.av._parameters("SMA", "optional"), list) def test_function_alias_method(self): self.assertEqual(self.av._function_alias("TIME_SERIES_INTRADAY"), "I") self.assertEqual(self.av._function_alias("TIME_SERIES_DAILY"), "D") self.assertEqual(self.av._function_alias("TIME_SERIES_DAILY_ADJUSTED"), "DA") self.assertEqual(self.av._function_alias("TIME_SERIES_WEEKLY"), "W") self.assertEqual( self.av._function_alias("TIME_SERIES_WEEKLY_ADJUSTED"), "WA") self.assertEqual(self.av._function_alias("TIME_SERIES_MONTHLY"), "M") self.assertEqual( self.av._function_alias("TIME_SERIES_MONTHLY_ADJUSTED"), "MA") self.assertEqual(self.av._function_alias("DIGITAL_CURRENCY_DAILY"), "CD") self.assertEqual(self.av._function_alias("DIGITAL_CURRENCY_WEEKLY"), "CW") self.assertEqual(self.av._function_alias("DIGITAL_CURRENCY_MONTHLY"), "CM") self.assertEqual(self.av._function_alias("CURRENCY_EXCHANGE_RATE"), "FX") self.assertEqual(self.av._function_alias("FX_DAILY"), "FXD") self.assertEqual(self.av._function_alias("FX_INTRADAY"), "FXI") self.assertEqual(self.av._function_alias("FX_WEEKLY"), "FXW") self.assertEqual(self.av._function_alias("FX_MONTHLY"), "FXM") self.assertEqual(self.av._function_alias("GLOBAL_QUOTE"), "Q") self.assertEqual(self.av._function_alias("CRYPTO_RATING"), "CR") self.assertEqual(self.av._function_alias("LISTING_STATUS"), "LS") self.assertEqual(self.av._function_alias("OVERVIEW"), "OVER") self.assertEqual(self.av._function_alias("INCOME_STATEMENT"), "IS") self.assertEqual(self.av._function_alias("BALANCE_SHEET"), "BS") self.assertEqual(self.av._function_alias("CASH_FLOW"), "CF") self.assertEqual(self.av._function_alias("EARNINGS_CALENDAR"), "EC") self.assertEqual(self.av._function_alias("IPO_CALENDAR"), "IC") self.assertEqual(self.av._function_alias("SMA"), "SMA") self.assertEqual(self.av._function_alias("DEMA"), "DEMA") ### and more indicators ... self.assertEqual(self.av._function_alias("Qwerty"), "Qwerty")
class TestAlphaVantageAPI(TestCase): @classmethod def setUpClass(cls): cls.test_data_path = C.TEST_DATA_PATH # Set premium to True to avoid API throttling for testing av = AlphaVantage(api_key=C.API_KEY_TEST, premium=True) # Minimum parameters cls.batch_parameters = { 'function': 'BATCH_STOCK_QUOTES', 'symbols': C.API_BATCH_TEST } cls.fx_parameters = { 'function': 'CURRENCY_EXCHANGE_RATE', 'from_currency': 'USD', 'to_currency': 'JPY' } cls.sector_parameters = {'function': 'SECTOR'} cls.data_parameters = { 'function': 'TIME_SERIES_DAILY_ADJUSTED', 'symbol': C.API_DATA_TEST } cls.intraday_parameters = { 'function': 'TIME_SERIES_INTRADAY', 'symbol': C.API_DATA_TEST } cls.indicator_parameters = { 'function': 'RSI', 'symbol': C.API_DATA_TEST, 'interval': 'weekly', 'series_type': 'open', 'time_period': 10 } cls.digital_parameters = { 'function': 'DIGITAL_CURRENCY_DAILY', 'symbol': C.API_DIGITAL_TEST, 'market': 'CNY' } # json files of sample data cls.json_batch = load_json(cls.test_data_path / 'mock_batch.json') cls.json_fx = load_json(cls.test_data_path / 'mock_fx.json') cls.json_sectors = load_json(cls.test_data_path / 'mock_sectors.json') cls.json_data = load_json(cls.test_data_path / 'mock_data.json') cls.json_indicator = load_json(cls.test_data_path / 'mock_indicator.json') cls.json_digital = load_json(cls.test_data_path / 'mock_digital.json') # Pandas DataFrames of sample data cls.df_batch = av._to_dataframe('BATCH_STOCK_QUOTES', cls.json_batch) cls.df_fx = av._to_dataframe('CURRENCY_EXCHANGE_RATE', cls.json_fx) cls.df_sectors = av._to_dataframe('SECTOR', cls.json_sectors) cls.df_data = av._to_dataframe('TIME_SERIES_DAILY_ADJUSTED', cls.json_data) cls.df_indicator = av._to_dataframe('RSI', cls.json_indicator) cls.df_digital = av._to_dataframe('DIGITAL_CURRENCY_DAILY', cls.json_digital) @classmethod def tearDownClass(cls): del cls.test_data_path del cls.batch_parameters del cls.fx_parameters del cls.sector_parameters del cls.data_parameters del cls.intraday_parameters del cls.indicator_parameters del cls.digital_parameters del cls.json_batch del cls.json_fx del cls.json_sectors del cls.json_data del cls.json_indicator del cls.json_digital del cls.df_batch del cls.df_fx del cls.df_sectors del cls.df_data del cls.df_indicator del cls.df_digital def setUp(self): self.av = AlphaVantage(api_key=C.API_KEY_TEST) def tearDown(self): del self.av # tests of: batch, fx, sectors, data, intraday, and digital @patch('alphaVantageAPI.alphavantage.AlphaVantage._av_api_call') def test_batch(self, mock_av_api_call): mock_av_api_call.side_effect = [None, self.df_batch, self.json_batch] self.assertIsNone(self.av.batch(C.API_BATCH_TEST)) self.assertIsInstance(self.av.batch(C.API_BATCH_TEST), DataFrame) self.assertIsInstance(self.av.batch(C.API_BATCH_TEST), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._av_api_call') def test_fx(self, mock_av_api_call): mock_av_api_call.side_effect = [None, self.df_fx, self.json_fx] self.assertIsNone(self.av.fx(C.API_FX_TEST)) # 4/7/2019 Stopped passing!? # self.assertIsInstance(self.av.fx(C.API_FX_TEST), DataFrame) # self.assertIsInstance(self.av.fx(C.API_FX_TEST), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._av_api_call') def test_sectors(self, mock_av_api_call): mock_av_api_call.side_effect = [ None, self.df_sectors, self.json_sectors ] self.assertIsNone(self.av.sectors()) self.assertIsInstance(self.av.sectors(), DataFrame) self.assertIsInstance(self.av.sectors(), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._av_api_call') def test_digital(self, mock_av_api_call): mock_av_api_call.side_effect = [ None, self.df_digital, self.json_digital ] self.assertIsNone(self.av.digital(C.API_DIGITAL_TEST)) self.assertIsInstance(self.av.digital(C.API_DIGITAL_TEST), DataFrame) self.assertIsInstance(self.av.digital(C.API_DIGITAL_TEST), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._av_api_call') def test_intraday(self, mock_av_api_call): mock_av_api_call.side_effect = [ None, self.df_sectors, self.json_sectors ] self.assertIsNone(self.av.intraday(C.API_DATA_TEST)) self.assertIsInstance(self.av.intraday(C.API_DATA_TEST), DataFrame) self.assertIsInstance(self.av.intraday(C.API_DATA_TEST), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._av_api_call') def test_data(self, mock_av_api_call): mock_av_api_call.side_effect = [None, self.df_data, self.json_data] self.assertIsNone(self.av.data('D', C.API_DATA_TEST)) self.assertIsInstance(self.av.data('D', C.API_DATA_TEST), DataFrame) self.assertIsInstance(self.av.data('D', C.API_DATA_TEST), dict) # av_api_call tests @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_batch(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response( json_data=self.json_batch) mock_to_dataframe.return_value = self.df_batch av_api_call = self.av._av_api_call(self.batch_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_batch_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = 'csv' mock_requests_get.return_value = _mock_response( text_data=self.json_batch) av_api_call = self.av._av_api_call(self.batch_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_fx(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_fx) mock_to_dataframe.return_value = self.df_fx av_api_call = self.av._av_api_call(self.fx_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_fx_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = 'csv' mock_requests_get.return_value = _mock_response(text_data=self.json_fx) av_api_call = self.av._av_api_call(self.fx_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_sectors(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response( json_data=self.json_sectors) mock_to_dataframe.return_value = self.df_sectors av_api_call = self.av._av_api_call(self.sector_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_sectors_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = 'csv' mock_requests_get.return_value = _mock_response( text_data=self.json_sectors) av_api_call = self.av._av_api_call(self.sector_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_data(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response( json_data=self.json_data) mock_to_dataframe.return_value = self.df_data av_api_call = self.av._av_api_call(self.data_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_data_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = 'csv' mock_requests_get.return_value = _mock_response( text_data=self.json_data) av_api_call = self.av._av_api_call(self.data_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_intraday(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response( json_data=self.json_data) mock_to_dataframe.return_value = self.df_data av_api_call = self.av._av_api_call(self.intraday_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_intraday_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = 'csv' mock_requests_get.return_value = _mock_response( text_data=self.json_data) av_api_call = self.av._av_api_call(self.intraday_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_indicator(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response( json_data=self.json_indicator) mock_to_dataframe.return_value = self.df_indicator av_api_call = self.av._av_api_call(self.indicator_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_indicator_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = 'csv' mock_requests_get.return_value = _mock_response( text_data=self.json_indicator) av_api_call = self.av._av_api_call(self.indicator_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_digital(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response( json_data=self.json_digital) mock_to_dataframe.return_value = self.df_digital av_api_call = self.av._av_api_call(self.digital_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch('alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe') @patch('alphaVantageAPI.alphavantage.requests.get') def test_av_api_call_digital_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = 'csv' mock_requests_get.return_value = _mock_response( text_data=self.json_digital) av_api_call = self.av._av_api_call(self.digital_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) # save_df tests @patch('alphaVantageAPI.alphavantage.AlphaVantage.last') @patch('alphaVantageAPI.alphavantage.DataFrame.to_csv') def test_save_df_to_csv(self, mock_to_csv, mock_last): self.av.output = 'csv' mock_last.return_value = self.sector_parameters mock_to_csv.return_result = True self.av._save_df(self.sector_parameters['function'], self.df_sectors) self.assertEqual(mock_last.call_count, 1) self.assertEqual(mock_to_csv.call_count, 1) @patch('alphaVantageAPI.alphavantage.AlphaVantage.last') @patch('alphaVantageAPI.alphavantage.DataFrame.to_json') def test_save_df_to_json(self, mock_to_json, mock_last): self.av.output = 'json' mock_last.return_value = self.sector_parameters mock_to_json.return_result = True self.av._save_df(self.sector_parameters['function'], self.df_sectors) self.assertEqual(mock_last.call_count, 1) self.assertEqual(mock_to_json.call_count, 1) @patch('alphaVantageAPI.alphavantage.AlphaVantage.last') @patch('alphaVantageAPI.alphavantage.DataFrame.to_pickle') def test_save_df_to_pickle(self, mock_to_pickle, mock_last): self.av.output = 'pkl' mock_last.return_value = self.sector_parameters mock_to_pickle.return_result = True self.av._save_df(self.sector_parameters['function'], self.df_sectors) self.assertEqual(mock_last.call_count, 1) self.assertEqual(mock_to_pickle.call_count, 1) @patch('alphaVantageAPI.alphavantage.AlphaVantage.last') @patch('alphaVantageAPI.alphavantage.DataFrame.to_html') def test_save_df_to_html(self, mock_to_html, mock_last): self.av.output = 'html' mock_last.return_value = self.sector_parameters mock_to_html.return_result = True self.av._save_df(self.sector_parameters['function'], self.df_sectors) self.assertEqual(mock_last.call_count, 1) self.assertEqual(mock_to_html.call_count, 1) @patch('alphaVantageAPI.alphavantage.AlphaVantage.last') @patch('alphaVantageAPI.alphavantage.Path.write_text') def test_save_df_to_txt(self, mock_write_text, mock_last): self.av.output = 'txt' mock_last.return_value = self.sector_parameters mock_write_text.return_result = True self.av._save_df(self.sector_parameters['function'], self.df_sectors) self.assertEqual(mock_last.call_count, 1) self.assertEqual(mock_write_text.call_count, 1)
# -*- coding: utf-8 -*- import telebot from telebot import types from alphaVantageAPI.alphavantage import AlphaVantage import matplotlib.pyplot as plt import matplotlib from matplotlib import pyplot from alpha_vantage.timeseries import TimeSeries import pandas as pd from alpha_vantage.foreignexchange import ForeignExchange from newsapi import NewsApiClient AV = AlphaVantage(api_key='ZBRM5PCHPIYQV8BY', output_size='full', output='pandas') token = "450574969:AAF-KNL1FkSEsLlDg0xuQJpkpvw4WLs-Y3Q" bot = telebot.TeleBot(token) items = [] @bot.message_handler(func=lambda message: True, commands=['start']) def Start(message): try: markup = types.ReplyKeyboardMarkup() markup.row('Информация о боте', 'Котировки','Форекс','Портфель') bot.send_message(message.chat.id, "Выберите действие:", reply_markup=markup) except Exception as e: m = types.ReplyKeyboardMarkup() m.row('Информация о боте', 'Котировки', 'Форекс', 'Портфель') bot.send_message(message.chat.id, 'Что-то пошло не так...', reply_markup=m) @bot.message_handler(regexp="Назад") def back(message):
import pandas as pd from fbprophet import Prophet import pandas as pd import matplotlib.pyplot as plt import pandas_ta as ta from alphaVantageAPI.alphavantage import AlphaVantage ticker='CW' AV = AlphaVantage( api_key='PUT YOUR API KEY HERE', premium=False, datatype='json', export=False, export_path= 'C:/Users/Andy/Downloads', output='csv', output_size='full', clean=True, proxy={}) df = AV.data(symbol=ticker, function='DA') # daily adjusted predper = 60 #number of days to predict ahead print(f"Shape: {df.shape}") df.set_index(['date'], inplace=True) df.fillna(0.0, inplace=True) df.to_csv (r'C:/Users/Andy/Downloads/pricedataCW.csv', index = 'date', header=True) df = pd.read_csv('C:/Users/Andy/Downloads/pricedataCW.csv', usecols=['date','close']) df.columns = ['ds', 'y']
class TestAlphaVantageAPI(TestCase): @classmethod def setUpClass(cls): cls.test_data_path = C.TEST_DATA_PATH # Set premium to True to avoid API throttling for testing av = AlphaVantage(api_key=C.API_KEY_TEST, premium=True) # Minimum parameters cls.fx_parameters = {"function":"CURRENCY_EXCHANGE_RATE", "from_currency":"USD", "to_currency":"JPY"} cls.fx_daily_parameters = {"function":"FX_DAILY", "from_currency":"EUR", "to_currency":"USD"} cls.fx_intraday_parameters = {"function":"FX_INTRADAY", "from_currency":"EUR", "to_currency":"USD"} cls.fx_monthly_parameters = {"function":"FX_MONTHLY", "from_currency":"EUR", "to_currency":"USD"} cls.fx_weekly_parameters = {"function":"FX_WEEKLY", "from_currency":"EUR", "to_currency":"USD"} cls.data_parameters = {"function":"TIME_SERIES_DAILY_ADJUSTED", "symbol": C.API_DATA_TEST} cls.intraday_parameters = {"function":"TIME_SERIES_INTRADAY", "symbol": C.API_DATA_TEST} cls.indicator_parameters = {"function":"RSI", "symbol": C.API_DATA_TEST, "interval":"weekly", "series_type":"open", "time_period":10} cls.digital_parameters = {"function":"DIGITAL_CURRENCY_DAILY", "symbol": C.API_DIGITAL_TEST, "market":"CNY"} cls.digital_rating_parameters = {"function":"CRYPTO_RATING", "symbols": C.API_DIGITAL_TEST} cls.global_quote_parameters = {"function":"GLOBAL_QUOTE", "symbols": C.API_DIGITAL_TEST} cls.overview_parameters = {"function":"OVERVIEW", "symbols": C.API_FUNDA_TEST} cls.balance_parameters = {"function":"BALANCE_SHEET", "symbols": C.API_FUNDA_TEST} cls.income_parameters = {"function":"INCOME_STATEMENT", "symbols": C.API_FUNDA_TEST} cls.cashflow_parameters = {"function":"CASH_FLOW", "symbols": C.API_FUNDA_TEST} cls.earnings_parameters = {"function": "EARNINGS_CALENDAR"} cls.ipos_parameters = {"function": "IPO_CALENDAR"} cls.listing_parameters = {"function": "LISTING_STATUS"} cls.intraday_ext_parameters = {"function": "TIME_SERIES_INTRADAY_EXTENDED", "symbol": C.API_FUNDA_TEST, "interval": 15} # json files of sample data cls.json_fx = load_json(cls.test_data_path / "mock_fx.json") cls.json_fx_daily = load_json(cls.test_data_path / "mock_fx_daily.json") cls.json_fx_intraday = load_json(cls.test_data_path / "mock_fx_intraday.json") cls.json_fx_monthly = load_json(cls.test_data_path / "mock_fx_monthly.json") cls.json_fx_weekly = load_json(cls.test_data_path / "mock_fx_weekly.json") cls.json_data = load_json(cls.test_data_path / "mock_data.json") cls.json_indicator = load_json(cls.test_data_path / "mock_indicator.json") cls.json_digital = load_json(cls.test_data_path / "mock_digital.json") cls.json_digital_rating = load_json(cls.test_data_path / "mock_digital_rating.json") cls.json_global_quote = load_json(cls.test_data_path / "mock_global_quote.json") cls.json_overview = load_json(cls.test_data_path / "mock_overview.json") cls.json_balance = load_json(cls.test_data_path / "mock_balance_sheet.json") cls.json_income = load_json(cls.test_data_path / "mock_income_statement.json") cls.json_cashflow = load_json(cls.test_data_path / "mock_cash_flow.json") # csv files of sample data cls.csv_earnings_cal = read_csv(cls.test_data_path / "mock_earnings_cal.csv") cls.csv_ipos_cal = read_csv(cls.test_data_path / "mock_ipos_cal.csv") cls.csv_delisted = read_csv(cls.test_data_path / "mock_delisted_status.csv") cls.csv_listed = read_csv(cls.test_data_path / "mock_listed_status.csv") cls.csv_intra_ext_adj = read_csv(cls.test_data_path / "mock_intra_ext_adj_15min_y1m1.csv") cls.csv_intra_ext_adj_slice = read_csv(cls.test_data_path / "mock_intra_ext_adj_15min_y1m2.csv") cls.csv_intra_ext_raw_slice = read_csv(cls.test_data_path / "mock_intra_ext_raw_60min_y1m3.csv") # Pandas DataFrames of sample data cls.df_fx = av._to_dataframe("CURRENCY_EXCHANGE_RATE", cls.json_fx) cls.df_fx_daily = av._to_dataframe("FX_DAILY", cls.json_fx_daily) cls.df_fx_intraday = av._to_dataframe("FX_INTRADAY", cls.json_fx_intraday) cls.df_fx_monthly = av._to_dataframe("FX_MONTHLY", cls.json_fx_monthly) cls.df_fx_weekly = av._to_dataframe("FX_WEEKLY", cls.json_fx_weekly) cls.df_data = av._to_dataframe("TIME_SERIES_DAILY_ADJUSTED", cls.json_data) cls.df_indicator = av._to_dataframe("RSI", cls.json_indicator) cls.df_digital = av._to_dataframe("DIGITAL_CURRENCY_DAILY", cls.json_digital) cls.df_digital_rating = av._to_dataframe("CRYPTO_RATING", cls.json_digital_rating) cls.df_global_quote = av._to_dataframe("GLOBAL_QUOTE", cls.json_global_quote) cls.df_overview = av._to_dataframe("OVERVIEW", cls.json_overview) cls.df_balance = av._to_dataframe("BALANCE_SHEET", cls.json_balance) cls.df_income = av._to_dataframe("INCOME_STATEMENT", cls.json_income) cls.df_cashflow = av._to_dataframe("CASH_FLOW", cls.json_cashflow) cls.df_earnings = DataFrame(cls.csv_earnings_cal) cls.df_ipos = DataFrame(cls.csv_ipos_cal) cls.df_delisted = DataFrame(cls.csv_delisted) cls.df_listed = DataFrame(cls.csv_listed) cls.df_intraday_ext_adj = DataFrame(cls.csv_intra_ext_adj) cls.df_intraday_ext_adj_slice = DataFrame(cls.csv_intra_ext_adj_slice) cls.df_intraday_ext_raw_slice = DataFrame(cls.csv_intra_ext_raw_slice) @classmethod def tearDownClass(cls): del cls.test_data_path del cls.fx_parameters del cls.fx_daily_parameters del cls.fx_intraday_parameters del cls.fx_monthly_parameters del cls.fx_weekly_parameters # del cls.sector_parameters del cls.data_parameters del cls.intraday_parameters del cls.intraday_ext_parameters del cls.indicator_parameters del cls.digital_parameters del cls.digital_rating_parameters del cls.global_quote_parameters del cls.overview_parameters del cls.balance_parameters del cls.income_parameters del cls.cashflow_parameters del cls.earnings_parameters del cls.ipos_parameters del cls.listing_parameters del cls.json_fx del cls.json_fx_daily del cls.json_fx_intraday del cls.json_fx_monthly del cls.json_fx_weekly del cls.json_data del cls.json_indicator del cls.json_digital del cls.json_digital_rating del cls.json_global_quote del cls.json_overview del cls.json_balance del cls.json_income del cls.json_cashflow del cls.df_fx del cls.df_fx_daily del cls.df_fx_intraday del cls.df_fx_monthly del cls.df_fx_weekly del cls.df_data del cls.df_indicator del cls.df_intraday_ext_adj del cls.df_intraday_ext_adj_slice del cls.df_intraday_ext_raw_slice del cls.df_digital del cls.df_digital_rating del cls.df_global_quote del cls.df_overview del cls.df_balance del cls.df_income del cls.df_cashflow del cls.csv_earnings_cal del cls.csv_ipos_cal del cls.csv_delisted del cls.csv_listed del cls.csv_intra_ext_adj del cls.csv_intra_ext_adj_slice del cls.csv_intra_ext_raw_slice def setUp(self): self.av = AlphaVantage(api_key=C.API_KEY_TEST) def tearDown(self): del self.av # tests of: fx, sectors, data, intraday, and digital @patch("alphaVantageAPI.alphavantage.AlphaVantage._av_api_call") def test_fx(self, mock_av_api_call): mock_av_api_call.side_effect = [None, self.df_fx, self.json_fx] self.assertIsNone(self.av.fx(C.API_FX_TEST)) # 4/7/2019 Stopped passing!? # self.assertIsInstance(self.av.fx(C.API_FX_TEST), DataFrame) # self.assertIsInstance(self.av.fx(C.API_FX_TEST), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._av_api_call") def test_digital(self, mock_av_api_call): mock_av_api_call.side_effect = [None, self.df_digital, self.json_digital] self.assertIsNone(self.av.digital(C.API_DIGITAL_TEST)) self.assertIsInstance(self.av.digital(C.API_DIGITAL_TEST), DataFrame) self.assertIsInstance(self.av.digital(C.API_DIGITAL_TEST), dict) # @patch("alphaVantageAPI.alphavantage.AlphaVantage._av_api_call") # def test_intraday(self, mock_av_api_call): # mock_av_api_call.side_effect = [None, self.df_sectors, self.json_sectors] # self.assertIsNone(self.av.intraday(C.API_DATA_TEST)) # self.assertIsInstance(self.av.intraday(C.API_DATA_TEST), DataFrame) # self.assertIsInstance(self.av.intraday(C.API_DATA_TEST), dict) # @patch("alphaVantageAPI.alphavantage.AlphaVantage._av_api_call") # def test_data(self, mock_av_api_call): # mock_av_api_call.side_effect = [None, self.df_data, self.json_data] # self.assertIsNone(self.av.data("D", C.API_DATA_TEST)) # self.assertIsInstance(self.av.data("D", C.API_DATA_TEST), DataFrame) # self.assertIsInstance(self.av.data("D", C.API_DATA_TEST), dict) # av_api_call tests @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_fx) mock_to_dataframe.return_value = self.df_fx av_api_call = self.av._av_api_call(self.fx_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_fx) av_api_call = self.av._av_api_call(self.fx_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_daily(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_fx_daily) mock_to_dataframe.return_value = self.df_fx_daily av_api_call = self.av._av_api_call(self.fx_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_daily_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_fx_daily) av_api_call = self.av._av_api_call(self.fx_daily_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_intraday(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_fx_intraday) mock_to_dataframe.return_value = self.df_fx av_api_call = self.av._av_api_call(self.fx_intraday_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_intraday_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_fx_intraday) av_api_call = self.av._av_api_call(self.fx_intraday_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_monthly(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_fx_monthly) mock_to_dataframe.return_value = self.df_fx_monthly av_api_call = self.av._av_api_call(self.fx_monthly_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_monthly_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_fx_monthly) av_api_call = self.av._av_api_call(self.fx_monthly_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_weekly(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_fx_weekly) mock_to_dataframe.return_value = self.df_fx_weekly av_api_call = self.av._av_api_call(self.fx_weekly_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_fx_weekly_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_fx_weekly) av_api_call = self.av._av_api_call(self.fx_weekly_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_data(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_data) mock_to_dataframe.return_value = self.df_data av_api_call = self.av._av_api_call(self.data_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_data_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_data) av_api_call = self.av._av_api_call(self.data_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_intraday(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_data) mock_to_dataframe.return_value = self.df_data av_api_call = self.av._av_api_call(self.intraday_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_intraday_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_data) av_api_call = self.av._av_api_call(self.intraday_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_intraday_ext_adj_csv(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(text_data=self.csv_intra_ext_adj) mock_to_dataframe.return_value = self.df_intraday_ext_adj av_api_call = self.av._av_api_call(self.intraday_ext_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_intraday_ext_adj_slice_csv(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(text_data=self.csv_intra_ext_adj_slice) mock_to_dataframe.return_value = self.df_intraday_ext_adj_slice _params = self.intraday_ext_parameters.copy() _params.update({"interval": 15, "slice": "year1month2"}) av_api_call = self.av._av_api_call(_params) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_intraday_ext_raw_slice_csv(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(text_data=self.csv_intra_ext_raw_slice) mock_to_dataframe.return_value = self.df_intraday_ext_raw_slice _params = self.intraday_ext_parameters.copy() _params.update({"interval": 60, "slice": "year1month3", "adjusted": False}) av_api_call = self.av._av_api_call(_params) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_indicator(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_indicator) mock_to_dataframe.return_value = self.df_indicator av_api_call = self.av._av_api_call(self.indicator_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_indicator_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_indicator) av_api_call = self.av._av_api_call(self.indicator_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_digital(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_digital) mock_to_dataframe.return_value = self.df_digital av_api_call = self.av._av_api_call(self.digital_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_digital_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_digital) av_api_call = self.av._av_api_call(self.digital_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) # @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_digital_rating(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_digital_rating) mock_to_dataframe.return_value = self.df_digital_rating av_api_call = self.av._av_api_call(self.digital_rating_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_digital_rating_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_digital_rating) av_api_call = self.av._av_api_call(self.digital_rating_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_global_quote(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_global_quote) mock_to_dataframe.return_value = self.df_global_quote av_api_call = self.av._av_api_call(self.global_quote_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_global_quote_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_global_quote) av_api_call = self.av._av_api_call(self.global_quote_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_overview(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_overview) mock_to_dataframe.return_value = self.df_overview av_api_call = self.av._av_api_call(self.overview_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_overview_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_overview) av_api_call = self.av._av_api_call(self.overview_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_overview(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_overview) mock_to_dataframe.return_value = self.df_overview av_api_call = self.av._av_api_call(self.overview_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_overview_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_overview) av_api_call = self.av._av_api_call(self.overview_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_balance_sheet(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_balance) mock_to_dataframe.return_value = self.df_balance av_api_call = self.av._av_api_call(self.balance_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), list) self.assertIsInstance(mock_to_dataframe()[0], DataFrame) self.assertIsInstance(mock_to_dataframe()[1], DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_balance_sheet_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_balance) av_api_call = self.av._av_api_call(self.balance_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_income_statement(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_income) mock_to_dataframe.return_value = self.df_income av_api_call = self.av._av_api_call(self.income_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), list) self.assertIsInstance(mock_to_dataframe()[0], DataFrame) self.assertIsInstance(mock_to_dataframe()[1], DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_income_statement_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.json_income) av_api_call = self.av._av_api_call(self.income_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_cashflow(self, mock_requests_get, mock_to_dataframe): mock_requests_get.return_value = _mock_response(json_data=self.json_cashflow) mock_to_dataframe.return_value = self.df_cashflow av_api_call = self.av._av_api_call(self.cashflow_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 1) self.assertIsInstance(mock_to_dataframe(), list) self.assertIsInstance(mock_to_dataframe()[0], DataFrame) self.assertIsInstance(mock_to_dataframe()[1], DataFrame) @patch("alphaVantageAPI.alphavantage.AlphaVantage._to_dataframe") @patch("alphaVantageAPI.alphavantage.requests.get") def test_cashflow_csv(self, mock_requests_get, mock_to_dataframe): self.av.datatype = "csv" mock_requests_get.return_value = _mock_response(text_data=self.cashflow_parameters) av_api_call = self.av._av_api_call(self.cashflow_parameters) self.assertEqual(mock_requests_get.call_count, 1) self.assertEqual(mock_to_dataframe.call_count, 0) self.assertIsInstance(av_api_call(), dict)
def setUpClass(cls): cls.test_data_path = C.TEST_DATA_PATH # Set premium to True to avoid API throttling for testing av = AlphaVantage(api_key=C.API_KEY_TEST, premium=True) # Minimum parameters cls.fx_parameters = {"function":"CURRENCY_EXCHANGE_RATE", "from_currency":"USD", "to_currency":"JPY"} cls.fx_daily_parameters = {"function":"FX_DAILY", "from_currency":"EUR", "to_currency":"USD"} cls.fx_intraday_parameters = {"function":"FX_INTRADAY", "from_currency":"EUR", "to_currency":"USD"} cls.fx_monthly_parameters = {"function":"FX_MONTHLY", "from_currency":"EUR", "to_currency":"USD"} cls.fx_weekly_parameters = {"function":"FX_WEEKLY", "from_currency":"EUR", "to_currency":"USD"} cls.data_parameters = {"function":"TIME_SERIES_DAILY_ADJUSTED", "symbol": C.API_DATA_TEST} cls.intraday_parameters = {"function":"TIME_SERIES_INTRADAY", "symbol": C.API_DATA_TEST} cls.indicator_parameters = {"function":"RSI", "symbol": C.API_DATA_TEST, "interval":"weekly", "series_type":"open", "time_period":10} cls.digital_parameters = {"function":"DIGITAL_CURRENCY_DAILY", "symbol": C.API_DIGITAL_TEST, "market":"CNY"} cls.digital_rating_parameters = {"function":"CRYPTO_RATING", "symbols": C.API_DIGITAL_TEST} cls.global_quote_parameters = {"function":"GLOBAL_QUOTE", "symbols": C.API_DIGITAL_TEST} cls.overview_parameters = {"function":"OVERVIEW", "symbols": C.API_FUNDA_TEST} cls.balance_parameters = {"function":"BALANCE_SHEET", "symbols": C.API_FUNDA_TEST} cls.income_parameters = {"function":"INCOME_STATEMENT", "symbols": C.API_FUNDA_TEST} cls.cashflow_parameters = {"function":"CASH_FLOW", "symbols": C.API_FUNDA_TEST} cls.earnings_parameters = {"function": "EARNINGS_CALENDAR"} cls.ipos_parameters = {"function": "IPO_CALENDAR"} cls.listing_parameters = {"function": "LISTING_STATUS"} cls.intraday_ext_parameters = {"function": "TIME_SERIES_INTRADAY_EXTENDED", "symbol": C.API_FUNDA_TEST, "interval": 15} # json files of sample data cls.json_fx = load_json(cls.test_data_path / "mock_fx.json") cls.json_fx_daily = load_json(cls.test_data_path / "mock_fx_daily.json") cls.json_fx_intraday = load_json(cls.test_data_path / "mock_fx_intraday.json") cls.json_fx_monthly = load_json(cls.test_data_path / "mock_fx_monthly.json") cls.json_fx_weekly = load_json(cls.test_data_path / "mock_fx_weekly.json") cls.json_data = load_json(cls.test_data_path / "mock_data.json") cls.json_indicator = load_json(cls.test_data_path / "mock_indicator.json") cls.json_digital = load_json(cls.test_data_path / "mock_digital.json") cls.json_digital_rating = load_json(cls.test_data_path / "mock_digital_rating.json") cls.json_global_quote = load_json(cls.test_data_path / "mock_global_quote.json") cls.json_overview = load_json(cls.test_data_path / "mock_overview.json") cls.json_balance = load_json(cls.test_data_path / "mock_balance_sheet.json") cls.json_income = load_json(cls.test_data_path / "mock_income_statement.json") cls.json_cashflow = load_json(cls.test_data_path / "mock_cash_flow.json") # csv files of sample data cls.csv_earnings_cal = read_csv(cls.test_data_path / "mock_earnings_cal.csv") cls.csv_ipos_cal = read_csv(cls.test_data_path / "mock_ipos_cal.csv") cls.csv_delisted = read_csv(cls.test_data_path / "mock_delisted_status.csv") cls.csv_listed = read_csv(cls.test_data_path / "mock_listed_status.csv") cls.csv_intra_ext_adj = read_csv(cls.test_data_path / "mock_intra_ext_adj_15min_y1m1.csv") cls.csv_intra_ext_adj_slice = read_csv(cls.test_data_path / "mock_intra_ext_adj_15min_y1m2.csv") cls.csv_intra_ext_raw_slice = read_csv(cls.test_data_path / "mock_intra_ext_raw_60min_y1m3.csv") # Pandas DataFrames of sample data cls.df_fx = av._to_dataframe("CURRENCY_EXCHANGE_RATE", cls.json_fx) cls.df_fx_daily = av._to_dataframe("FX_DAILY", cls.json_fx_daily) cls.df_fx_intraday = av._to_dataframe("FX_INTRADAY", cls.json_fx_intraday) cls.df_fx_monthly = av._to_dataframe("FX_MONTHLY", cls.json_fx_monthly) cls.df_fx_weekly = av._to_dataframe("FX_WEEKLY", cls.json_fx_weekly) cls.df_data = av._to_dataframe("TIME_SERIES_DAILY_ADJUSTED", cls.json_data) cls.df_indicator = av._to_dataframe("RSI", cls.json_indicator) cls.df_digital = av._to_dataframe("DIGITAL_CURRENCY_DAILY", cls.json_digital) cls.df_digital_rating = av._to_dataframe("CRYPTO_RATING", cls.json_digital_rating) cls.df_global_quote = av._to_dataframe("GLOBAL_QUOTE", cls.json_global_quote) cls.df_overview = av._to_dataframe("OVERVIEW", cls.json_overview) cls.df_balance = av._to_dataframe("BALANCE_SHEET", cls.json_balance) cls.df_income = av._to_dataframe("INCOME_STATEMENT", cls.json_income) cls.df_cashflow = av._to_dataframe("CASH_FLOW", cls.json_cashflow) cls.df_earnings = DataFrame(cls.csv_earnings_cal) cls.df_ipos = DataFrame(cls.csv_ipos_cal) cls.df_delisted = DataFrame(cls.csv_delisted) cls.df_listed = DataFrame(cls.csv_listed) cls.df_intraday_ext_adj = DataFrame(cls.csv_intra_ext_adj) cls.df_intraday_ext_adj_slice = DataFrame(cls.csv_intra_ext_adj_slice) cls.df_intraday_ext_raw_slice = DataFrame(cls.csv_intra_ext_raw_slice)
import numpy as np import matplotlib.pyplot as plt from matplotlib.pyplot import plot, draw, show import matplotlib.animation as animation import matplotlib.image as mpimg from matplotlib.widgets import Button, TextBox import os.path import sys from skimage import draw # Initialize the AlphaVantage Class with default values AV = AlphaVantage(api_key="S45HPVH3ZGG9U18Z", premium=False, output_size='compact', datatype='json', export=False, export_path='~/av_data', output='csv', clean=False, proxy={}) df_AAPL = AV.data(symbol='AAPL', function='D') # Daily #df_AAPL = AV.intraday(symbol='AAPL', interval='15min') # Intraday as str df_AAPL.drop("1. open", axis=1, inplace=True) df_AAPL.drop("2. high", axis=1, inplace=True) df_AAPL.drop("3. low", axis=1, inplace=True) df_AAPL.drop("5. volume", axis=1, inplace=True) df_AAPL["Date"] = df_AAPL["date"]