def are_for_stock(inputs: calc.CalcInputs) -> str:
if not inputs:
raise errors.InvalidArgumentError('Cannot get stock for empty input')
symbol = inputs[0].symbol
for input in inputs:
if input.data_space != DataEntry.STOCK_DATA or input.symbol != symbol:
raise errors.InvalidArgumentError(
f'Expecting data series all for stock: {symbol}, got: {input}')
return symbol
def sort_to_inputs_shape(data_entries: List[DataEntry],
inputs_shape: calc.CalcInputs) -> calc.CalcInputs:
data_entry_dict = {_make_input_shape_key(d): d for d in data_entries}
try:
return [
data_entry_dict[_make_input_shape_key(input_shape)]
for input_shape in inputs_shape
]
except KeyError as e:
nl = '\n'
raise errors.InvalidArgumentError(
f'Cannot sort inputs to the given shape: {e}{nl}'
f'Inputs are: {nl.join(str(d) for d in data_entries)}')
def call(self, *args, **kwargs):
params = self._param_builder(*args, **kwargs)
params['token'] = self._token
endpoint_url = self._endpoint_url_builder(*args, **kwargs)
response = self._session.get(url=self._API_URL + endpoint_url,
params=params)
try:
response.raise_for_status()
except request_exceptions.HTTPError as e:
if response.status_code >= 500:
raise errors.InternalError(e)
raise errors.InvalidArgumentError(e)
return response.json()
def get_data(
self,
symbol: str,
start_date: Optional[time.CivilTime] = None,
end_date: Optional[time.CivilTime] = None,
) -> Dict[int, List[_DataEntry]]:
if not symbol:
raise errors.InvalidArgumentError('Symbol not specified')
if not end_date:
end_date = time.ToCivil(time.Now())
if not start_date:
start_date = end_date
if start_date > end_date:
raise errors.InvalidArgumentError(
f'start_date {start_date} is later than end_date {end_date}')
if end_date > time.ToCivil(time.Now()):
raise errors.InvalidArgumentError(
f'end_date {end_date} must be in the past')
data = self._batch_api.get_batch_quotes(symbol, start_date, end_date)
chart_series = data[symbol]['chart']
now = time.Now()
data_types_to_import = _DATA_TYPE_TO_CHART_FIELD_MAP.keys()
results = {data_type: [] for data_type in data_types_to_import}
for chart_data in chart_series:
data_date = time.ParseCivilTime(chart_data['date'])
for data_type in data_types_to_import:
data = self._make_data_base(symbol, data_date, now)
data.data_type = data_type
data.value = chart_data[
_DATA_TYPE_TO_CHART_FIELD_MAP[data_type]]
results[data_type].append(data)
return results
def calculate(self, inputs: calc.CalcInputs) -> DataEntry:
if not inputs:
raise errors.InvalidArgumentError('Inputs cannot be empty')
symbol = input_util.are_for_stock(inputs)
t = time_util.to_time(inputs[-1].timestamp)
try:
input_util.validate_inputs(inputs, self.recursive_inputs_shape(t))
ema = self._recur(inputs)
except errors.InvalidArgumentError:
input_util.validate_inputs(inputs, self.source_inputs_shape(t))
ema = self._initial(inputs)
except errors.InvalidArgumentError as e:
raise e
return DataEntry(
symbol=symbol,
data_space=data_entry_pb2.DataEntry.STOCK_DATA,
data_type=self._calc_type,
value=ema,
timestamp=time_util.from_time(t),
)
def _get_shortest_historical_ranges(start_date: time.CivilTime) -> str:
"""Get the shortest API range string that covers the requested number of
days for the time period ending today.
See: https://iexcloud.io/docs/api/#historical-prices.
"""
num_days = 1 + time.ToCivil(time.Now()).diff(start_date).in_days()
if num_days <= 5:
return '5d'
if num_days <= 28: # Shortest month has 28 days
return '1m'
if num_days <= 90:
return '3m'
if num_days <= 182:
return '6m'
if num_days <= 365:
return '1y'
if num_days <= 730:
return '2y'
if num_days <= 365 * 5 + 1:
return '5y'
if num_days <= 365 * 15 + 3:
return 'max'
raise errors.InvalidArgumentError(
'IEX does not support historical data older than 15 years')
def validate_inputs(inputs: calc.CalcInputs, inputs_shapes: calc.CalcInputs):
for input, input_shape in itertools.zip_longest(inputs, inputs_shapes):
if not is_same_input_shape(input, input_shape):
raise errors.InvalidArgumentError(
f'Expecting data with input shape: {input_shape}, got: {input}'
)