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}')