def security_analyse(engine: Any):
interval = tool.INTERVAL_1D
w_sizes = [50, 100, 200]
source_name = tool.source_name(engine, interval)
result_name = tool.result_name(engine, interval, tool.ENV_TEST)
LOG.info(f'>> {security_analyse.__name__} source: {source_name}')
for exchange_name in config.EXCHANGES:
with store.ExchangeSeries() as exchange_series:
securities = exchange_series[exchange_name]
entries = []
with flow.Progress(f'security-analyse {exchange_name}', securities) as progress:
for security in securities:
progress(security.symbol)
with engine.SecuritySeries(interval, editable=True) as security_series:
time_series = security_series[security.symbol]
analyse.clean(time_series)
swings.calculate(time_series)
for w_size in w_sizes:
analyse.sma(time_series, w_size)
analyse.vma(time_series, w_size)
action = analyse.action(time_series)
security_series *= time_series
entry = security.entry(result_name)
entry[result_name] = action
entries += [entry]
with store.ExchangeSeries(editable=True) as exchange_series:
exchange_series |= entries
LOG.info(f'Securities: {len(securities)} analysed in the exchange: {exchange_name}')
def security_verify(engine: Any):
interval = tool.INTERVAL_1D
source_name = tool.source_name(engine, interval)
health_name = tool.health_name(engine, interval)
LOG.info(f'>> {security_verify.__name__} source: {source_name}')
with engine.SecuritySeries(interval) as security_series:
time_range = security_series.time_range()
with store.File(health_name, editable=True) as health:
for exchange_name in config.EXCHANGES:
health[exchange_name] = {}
last_session = tool.last_session(exchange_name, interval, DateTime.now())
with store.ExchangeSeries() as exchange_series:
securities = exchange_series[exchange_name]
entries = []
with flow.Progress(health_name, securities) as progress:
for security in securities:
progress(security.symbol)
result = Clazz()
symbol_range = time_range.get(security.symbol)
if symbol_range:
overlap, missing = time_series_verify(engine,
security.symbol,
symbol_range.dt_from,
last_session,
interval)
if overlap:
result.overlap = overlap
if missing:
result.missing = missing
if len(missing) > config.HEALTH_MISSING_LIMIT:
result.message = f'The missing limit reached: {len(missing)}'
if last_session in missing:
result.message = f'The last session {symbol_range.dt_to} < {last_session}'
else:
result.message = 'There is no time series for this symbol'
if result:
short_symbol, _ = tool.symbol_split(security.symbol)
health[exchange_name][short_symbol] = result
entry = security.entry(health_name)
entry[health_name] = 'message' not in result
entries += [entry]
with store.ExchangeSeries(editable=True) as exchange_series:
exchange_series |= entries
LOG.info(f'Securities: {len(securities)} verified in the exchange: {exchange_name}')
def cb_security_table(exchange_name, engine_name, interval_name, env_name,
query):
if exchange_name and engine_name and interval_name and env_name:
LOG.debug(f'Loading symbols with query: "{query or "*"}"')
with store.ExchangeSeries() as exchange_series:
securities = exchange_series[exchange_name]
results = []
boolean = ['[-]', '[+]']
health_name = tool.health_name(engine_name, interval_name)
result_name = tool.result_name(engine_name, interval_name, env_name)
for security in securities:
health = security[health_name]
result = security[result_name]
profit_ratio = result.profit / result.total if result.total else 0.0
results += [
dict(symbol=security.symbol,
shortable=boolean[security.shortable],
health=boolean[health],
profit_ratio=round(100 * profit_ratio,
FLOAT_PRECISION - 2),
description=security.description,
profit=round(result.profit, FLOAT_PRECISION),
total=round(result.total, FLOAT_PRECISION),
volume=round(result.volume, FLOAT_PRECISION))
]
return select_securities(results, query)
return []
def security_update_by_interval(engine: Any, interval: timedelta):
LOG.info(f'>> {security_update.__name__} source: {tool.source_name(engine, interval)}')
default_range = Clazz(dt_to=config.datetime_from())
with engine.SecuritySeries(interval) as security_series:
time_range = security_series.time_range()
LOG.debug(f'Time range entries: {len(time_range)}')
for exchange_name in config.EXCHANGES:
with store.ExchangeSeries() as exchange_series:
securities = exchange_series[exchange_name]
with engine.Session() as session:
with flow.Progress(f'security-update: {exchange_name}', securities) as progress:
for security in securities:
progress(security.symbol)
dt_from = time_range.get(security.symbol, default_range).dt_to
dt_to = tool.last_session(exchange_name, interval, DateTime.now())
for slice_from, slice_to in tool.time_slices(dt_from, dt_to, interval, 4096):
time_series = session.series(security.symbol, slice_from, slice_to, interval)
with engine.SecuritySeries(interval, editable=True) as security_series:
security_series += time_series
LOG.info(f'Securities: {len(securities)} updated in the exchange: {exchange_name}')
def exchange_update():
LOG.info(f'>> {exchange_update.__name__}')
indices = read_major_indices()
shortables = exante.read_shortables()
with store.ExchangeSeries(editable=True) as exchange_series:
with exante.Session() as session:
for exchange_name in config.EXCHANGES:
exchange_index = indices[exchange_name]
exchange_securities = {s.symbol: s for s in exchange_series[exchange_name]}
new_documents = []
existing_documents = []
for security in session.securities(exchange_name):
shortable = shortables.get(security.symbol, False)
if security.short_symbol in exchange_index:
if security.symbol in exchange_securities:
document = exchange_securities[security.symbol]
document.shortable = shortable
existing_documents += [document]
else:
document = security
document.shortable = shortable
document.update(tool.ENV_RESULT_DEFAULT)
document.update(tool.HEALTH_RESULT_DEFAULT)
new_documents += [document]
exchange_series *= existing_documents
LOG.info(f'Securities: {len(existing_documents)} updated in the exchange: {exchange_name}')
exchange_series += new_documents
LOG.info(f'Securities: {len(new_documents)} imported to the exchange: {exchange_name}')
def test_exchanges():
data.exchange_update()
with store.ExchangeSeries() as exchange_series:
for name in config.EXCHANGES:
securities = exchange_series[name]
assert len(securities) > 16
for security in securities:
document = {k: v for k, v in security.items() if k not in ('_rev', '_id', '_key')}
jsonschema.validate(document, schema.EXCHANGE_SCHEMA['rule'])
def security_clean(engine: Any):
interval = tool.INTERVAL_1D
source_name = tool.source_name(engine, interval)
LOG.info(f'>> {security_clean.__name__} source: {source_name}')
for exchange_name in config.EXCHANGES:
with store.ExchangeSeries() as exchange_series:
securities = exchange_series[exchange_name]
with flow.Progress(f'security-clean {exchange_name}', securities) as progress:
for security in securities:
progress(security.symbol)
with engine.SecuritySeries(interval, editable=True) as security_series:
time_series = security_series[security.symbol]
analyse.clean(time_series)
security_series *= time_series
LOG.info(f'Securities: {len(securities)} cleaned in the exchange: {exchange_name}')