def run(self):
"""
Loads data, thus enabling get_similarity_matrix and
get_covariance_matrix methods in the base class.
"""
self.check_provider_valid()
if self._token:
quandl.ApiConfig.api_key = self._token
quandl.ApiConfig.api_version = '2015-04-09'
self._data = []
for _, __s in enumerate(self._tickers):
try:
__d = quandl.get("WIKI/" + __s,
start_date=self._start,
end_date=self._end)
except NotFoundError as ex:
raise QiskitFinanceError(
"Cannot retrieve Wikipedia data due to an invalid token."
) from ex
# The exception will be urllib3 NewConnectionError, but it can get dressed by quandl
except Exception as ex: # pylint: disable=broad-except
raise QiskitFinanceError(
"Cannot retrieve Wikipedia data.") from ex
try:
self._data.append(__d["Adj. Close"])
except KeyError as ex:
raise QiskitFinanceError("Cannot parse quandl output.") from ex
def check_provider_valid():
""" checks if provider is valid """
err_msg = 'quandl is not installed.'
try:
spec = importlib.util.find_spec('quandl')
if spec is not None:
return
except Exception as ex: # pylint: disable=broad-except
logger.debug('quandl check error %s', str(ex))
raise QiskitFinanceError(err_msg) from ex
raise QiskitFinanceError(err_msg)
def run(self):
"""
Loads data, thus enabling get_similarity_matrix and get_covariance_matrix
methods in the base class.
"""
http = urllib3.PoolManager(cert_reqs='CERT_REQUIRED',
ca_certs=certifi.where())
url = 'https://dataondemand.nasdaq.com/api/v1/quotes?'
self._data = []
for ticker in self._tickers:
values = {
'_Token': self._token,
'symbols': [ticker],
'start': self._start.strftime("%Y-%m-%d'T'%H:%M:%S.%f'Z'"),
'end': self._end.strftime("%Y-%m-%d'T'%H:%M:%S.%f'Z'"),
'next_cursor': 0
}
encoded = url + urlencode(values)
try:
if self._verify is None:
response = http.request(
'POST', encoded
) # this runs certificate verification, as per the set-up of the urllib3
else:
# this disables certificate verification (False)
# or forces the certificate path (str)
response = http.request('POST',
encoded,
verify=self._verify)
if response.status != 200:
msg = "Accessing NASDAQ Data on Demand with parameters {} encoded into ".format(
values)
msg += encoded
msg += " failed. Hint: Check the _Token. Check the spelling of tickers."
raise QiskitFinanceError(msg)
quotes = json.loads(response.data.decode('utf-8'))["quotes"]
price_evolution = []
for q in quotes:
price_evolution.append(q["ask_price"])
self._data.append(price_evolution)
except Exception as ex: # pylint: disable=broad-except
raise QiskitFinanceError(
'Accessing NASDAQ Data on Demand failed.') from ex
http.clear()
def run(self):
"""
Loads data, thus enabling get_similarity_matrix and get_covariance_matrix
methods in the base class.
"""
self._check_provider_valid()
import quandl # pylint: disable=import-outside-toplevel
self._data = []
quandl.ApiConfig.api_key = self._token
quandl.ApiConfig.api_version = '2015-04-09'
for _, __s in enumerate(self._tickers):
try:
__d = quandl.get(self._stockmarket + "/" + __s,
start_date=self._start,
end_date=self._end)
# The exception will be AuthenticationError, if the token is wrong
except Exception as ex: # pylint: disable=broad-except
raise QiskitFinanceError(
"Cannot retrieve Exchange Data data.") from ex
try:
self._data.append(__d["Adj. Close"])
except KeyError as ex:
raise QiskitFinanceError("Cannot parse quandl output.") from ex
def __init__(self,
token: str,
tickers: Union[str, List[str]],
stockmarket: StockMarket = StockMarket.NASDAQ,
start: datetime = datetime.datetime(2016, 1, 1),
end: datetime = datetime.datetime(2016, 1, 30),
verify: Optional[Union[str, bool]] = None) -> None:
"""
Args:
token: quandl access token
tickers: tickers
stockmarket: NYSE or NASDAQ
start: first data point
end: last data point precedes this date
verify: if verify is None, certify certificates
will be used (default);
if this is False, no certificates will be checked; if this is a string,
it should be pointing
to a certificate for the HTTPS connection to NASDAQ (dataondemand.nasdaq.com),
either in the
form of a CA_BUNDLE file or a directory wherein to look.
Raises:
QiskitFinanceError: invalid data
"""
# if not isinstance(atoms, list) and not isinstance(atoms, str):
# raise QiskitFinanceError("Invalid atom input for DOD Driver '{}'".format(atoms))
super().__init__()
if isinstance(tickers, list):
self._tickers = tickers
else:
self._tickers = tickers.replace('\n', ';').split(";")
self._n = len(self._tickers)
if stockmarket not in [StockMarket.NASDAQ, StockMarket.NYSE]:
msg = "NASDAQ Data on Demand does not support "
msg += stockmarket.value
msg += " as a stock market."
raise QiskitFinanceError(msg)
# This is to aid serialization; string is ok to serialize
self._stockmarket = str(stockmarket.value)
self._token = token
self._start = start
self._end = end
self._verify = verify
def __init__(
self,
token: str,
tickers: Union[str, List[str]],
stockmarket: StockMarket = StockMarket.LONDON,
start: datetime = datetime.datetime(2016, 1, 1),
end: datetime = datetime.datetime(2016, 1, 30)
) -> None:
"""
Initializer
Args:
token: quandl access token
tickers: tickers
stockmarket: LONDON, EURONEXT, or SINGAPORE
start: first data point
end: last data point precedes this date
Raises:
QiskitFinanceError: provider doesn't support stock market
"""
super().__init__()
if isinstance(tickers, list):
self._tickers = tickers
else:
self._tickers = tickers.replace('\n', ';').split(";")
self._n = len(self._tickers)
if stockmarket not in [
StockMarket.LONDON, StockMarket.EURONEXT, StockMarket.SINGAPORE
]:
msg = "ExchangeDataProvider does not support "
msg += stockmarket.value
msg += " as a stock market."
raise QiskitFinanceError(msg)
# This is to aid serialization; string is ok to serialize
self._stockmarket = str(stockmarket.value)
self._token = token
self._tickers = tickers
self._start = start
self._end = end
def __init__(self,
token=None,
tickers=None,
stockmarket=StockMarket.NASDAQ,
start=datetime.datetime(2016, 1, 1),
end=datetime.datetime(2016, 1, 30)):
"""
Initializer
Args:
token (str): quandl access token, which is not needed, strictly speaking
tickers (str or list): tickers
stockmarket (StockMarket): NASDAQ, NYSE
start (datetime.datetime): start time
end (datetime.datetime): end time
Raises:
QiskitFinanceError: provider doesn't support stock market input
"""
# if not isinstance(atoms, list) and not isinstance(atoms, str):
# raise QiskitFinanceError("Invalid atom input for Wikipedia Driver '{}'".format(atoms))
super().__init__()
tickers = tickers if tickers is not None else []
if isinstance(tickers, list):
self._tickers = tickers
else:
self._tickers = tickers.replace('\n', ';').split(";")
self._n = len(self._tickers)
if stockmarket not in [StockMarket.NASDAQ, StockMarket.NYSE]:
msg = "WikipediaDataProvider does not support "
msg += stockmarket.value
msg += " as a stock market."
raise QiskitFinanceError(msg)
# This is to aid serialization; string is ok to serialize
self._stockmarket = str(stockmarket.value)
self._token = token
self._tickers = tickers
self._start = start
self._end = end
self._data = []
def __init__(
self,
token: Optional[str] = None,
tickers: Optional[Union[str, List[str]]] = None,
stockmarket: StockMarket = StockMarket.NASDAQ,
start: datetime = datetime.datetime(2016, 1, 1),
end: datetime = datetime.datetime(2016, 1, 30)
) -> None:
"""
Initializer
Args:
token: quandl access token, which is not needed, strictly speaking
tickers: tickers
stockmarket: NASDAQ, NYSE
start: start time
end: end time
Raises:
QiskitFinanceError: provider doesn't support stock market input
"""
super().__init__()
tickers = tickers if tickers is not None else []
if isinstance(tickers, list):
self._tickers = tickers
else:
self._tickers = tickers.replace('\n', ';').split(";")
self._n = len(self._tickers)
if stockmarket not in [StockMarket.NASDAQ, StockMarket.NYSE]:
msg = "WikipediaDataProvider does not support "
msg += stockmarket.value
msg += " as a stock market."
raise QiskitFinanceError(msg)
# This is to aid serialization; string is ok to serialize
self._stockmarket = str(stockmarket.value)
self._token = token
self._tickers = tickers
self._start = start
self._end = end
self._data = []
def init_from_input(cls, section):
"""
Initialize via section dictionary.
Args:
section (dict): section dictionary
Returns:
WikipediaDataProvider: data provider object
Raises:
QiskitFinanceError: Invalid section
"""
if section is None or not isinstance(section, dict):
raise QiskitFinanceError(
'Invalid or missing section {}'.format(section))
# params = section
kwargs = {}
# for k, v in params.items():
# if k == ExchangeDataDriver. ...: v = UnitsType(v)
# kwargs[k] = v
logger.debug('init_from_input: %s', kwargs)
return cls(**kwargs)
def __init__(self,
tickers: Optional[Union[str, List[str]]] = None,
stockmarket: StockMarket = StockMarket.RANDOM,
start: datetime = datetime.datetime(2016, 1, 1),
end: datetime = datetime.datetime(2016, 1, 30),
seed: Optional[int] = None) -> None:
"""
Initializer
Args:
tickers: tickers
stockmarket: RANDOM
start: first data point
end: last data point precedes this date
seed: shall a seed be used?
Raises:
QiskitFinanceError: provider doesn't support stock market value
"""
super().__init__()
tickers = tickers if tickers is not None else ["TICKER1", "TICKER2"]
if isinstance(tickers, list):
self._tickers = tickers
else:
self._tickers = tickers.replace('\n', ';').split(";")
self._n = len(self._tickers)
if stockmarket not in [StockMarket.RANDOM]:
msg = "RandomDataProvider does not support "
msg += stockmarket.value
msg += " as a stock market. Please use Stockmarket.RANDOM."
raise QiskitFinanceError(msg)
# This is to aid serialization; string is ok to serialize
self._stockmarket = str(stockmarket.value)
self._start = start
self._end = end
self._seed = seed