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"]