def run_scheduled_tasks():
for task in TASKS:
utc_now = DateTime.now()
task.next_run = utc_now.replace(hour=task.hour,
minute=task.minute,
second=0,
microsecond=0)
if task.next_run < utc_now:
task.next_run += task.interval
while flow.wait(60.0):
for task in TASKS:
if task.next_run < DateTime.now():
try:
LOG.info(f'Task: {task.function.__name__} has started')
task.running = True
task.function()
except:
LOG.fatal(
f'Task: {task.function.__name__} should always catch exceptions'
)
finally:
LOG.info(f'Task: {task.function.__name__} has finished')
if 'interval' in task:
task.next_run += task.interval
task.last_run = DateTime.now()
task.running = False
else:
TASKS.remove(task)
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 execute():
symbol = 'ABC.NYSE'
interval = tool.INTERVAL_1D
begin = DateTime(2014, 11, 18).to_timestamp()
end = DateTime.now().to_timestamp()
show_vma(symbol, interval, begin, end)
show_valid_swings(symbol, interval, begin, end)
show_candidate_swings(symbol, interval, begin, end)
show_strategy(symbol, interval, begin, end)
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 schedule_endpoint():
if request.method == 'POST':
LOG.info(f'Scheduling function {task_daily.__name__}')
task = Clazz(next_run=DateTime.now().replace(microsecond=0),
running=False,
function=task_daily)
TASKS.append(task)
LOG.info('Listing threads and tasks')
threads = [{
'name': thread.name,
'daemon': thread.daemon,
'alive': thread.is_alive()
} for thread in threading.enumerate()]
content = dict(threads=threads, tasks=TASKS)
return json.dumps(content,
option=json.OPT_INDENT_2,
default=tool.json_default).decode('utf-8')
def execute():
symbol = 'ABC.NYSE'
begin = DateTime(2017, 11, 1).to_timestamp()
end = DateTime.now().to_timestamp()
show_swings(symbol, begin, end)
value=config.EXCHANGES[0],
placeholder='exchange',
className='choice',
persistence=True)
engine_choice = dcc.Dropdown(id='engine-choice',
options=[{
'label': s,
'value': s
} for s in ENGINES],
value=list(ENGINES.keys())[0],
placeholder='engine',
className='choice',
persistence=True)
datetime_from = DateTime.now() - timedelta(days=3 * 365)
date_choice = dcc.DatePickerSingle(id='date-from',
date=datetime_from.date(),
display_format=DATE_PICKER_FORMAT,
className='choice',
persistence=True)
score_choice = dcc.Input(id='score-choice',
type='number',
min=1,
max=8,
step=1,
value=3,
className='score',
persistence=True)