def find_by(self) -> List[StrategyRun]:
self._connection.begin()
cursor = self._connection.cursor()
cursor.execute('SELECT * FROM `strategy_runs` ORDER BY `run_at` DESC')
result = []
for row in cursor.fetchall():
result.append(StrategyRun(
UUID(row[0]),
datetime.datetime.fromtimestamp(row[1], tz=datetime.timezone.utc),
deserialize_pair(row[2]),
deserialize_strategy_run_markets(json.loads(row[3])),
row[4],
json.loads(row[5]),
DateTimeInterval(
datetime.datetime.fromtimestamp(row[6], tz=datetime.timezone.utc),
datetime.datetime.fromtimestamp(row[7], tz=datetime.timezone.utc) \
if row[7] is not None else None,
),
row[8],
row[9],
))
cursor.close()
self._connection.commit()
return result
def orders(sid, data):
logger.info('RECEIVED: {}, {}'.format(EVENT_GET_ORDERS, data))
if 'order_storage' not in data:
return 'ERROR', {
'message': 'Missing "order_storage" field in request.'
}
order_storage = order_storage_plugins.get_order_storage(
data['order_storage'])
strategy_run_id = data[
'strategy_run_id'] if 'strategy_run_id' in data else None
result_orders = order_storage.find_by(
data['market'],
deserialize_pair(data['pair']),
interval=deserialize_datetime_interval(data['interval']),
strategy_run_id=strategy_run_id)
result_data = serialize_orders(result_orders)
if strategy_run_id is not None:
# Todo: Make this configurable, see https://github.com/Achse/coinrat/issues/47
portfolio_snapshot_storage = self._portfolio_snapshot_storage_plugins \
.get_portfolio_snapshot_storage('influx_db')
snapshots = portfolio_snapshot_storage.get_for_strategy_run(
strategy_run_id)
for row in result_data:
row['portfolio_snapshot'] = serialize_portfolio_snapshot(
snapshots[row[ORDER_FIELD_ORDER_ID]])
return 'OK', result_data
def on_subscribe(session_id, data):
if data['event'] == EVENT_LAST_CANDLE_UPDATED:
subscription = LastCandleSubscription(
session_id, data['storage'], data['market'],
deserialize_pair(data['pair']),
deserialize_candle_size(data['candle_size']))
elif data['event'] == EVENT_NEW_ORDER:
subscription = NewOrderSubscription(
session_id, data['storage'], data['market'],
deserialize_pair(data['pair']),
deserialize_datetime_interval(data['interval']))
elif data['event'] == EVENT_NEW_STRATEGY_RUN:
subscription = NewStrategyRunSubscription(session_id)
else:
raise ValueError('Event "{}" not supported'.format(
data['event']))
self._subscription_storage.subscribe(subscription)
return 'OK'
def deserialize_strategy_run(data: Dict) -> StrategyRun:
return StrategyRun(
UUID(data['strategy_run_id']),
dateutil.parser.parse(
data['run_at']).replace(tzinfo=datetime.timezone.utc),
deserialize_pair(data['pair']),
deserialize_strategy_run_markets(data['markets']),
data['strategy_name'],
data['strategy_configuration'],
deserialize_datetime_interval(data['interval']),
data['candle_storage_name'],
data['order_storage_name'],
)
def deserialize_candle(row: Dict) -> Candle:
if CANDLE_STORAGE_FIELD_SIZE in row and row[CANDLE_STORAGE_FIELD_SIZE] is not None:
candle_size = deserialize_candle_size(row[CANDLE_STORAGE_FIELD_SIZE])
else:
candle_size = CandleSize(CANDLE_SIZE_UNIT_MINUTE, 1)
return Candle(
row[CANDLE_STORAGE_FIELD_MARKET],
deserialize_pair(row[CANDLE_STORAGE_FIELD_PAIR]),
dateutil.parser.parse(row[CANDLE_STORAGE_FIELD_TIME]).replace(tzinfo=datetime.timezone.utc),
to_decimal(row[CANDLE_STORAGE_FIELD_OPEN]),
to_decimal(row[CANDLE_STORAGE_FIELD_HIGH]),
to_decimal(row[CANDLE_STORAGE_FIELD_LOW]),
to_decimal(row[CANDLE_STORAGE_FIELD_CLOSE]),
candle_size
)
def clear_orders(sid, data):
logger.info('RECEIVED: {}, {}'.format(EVENT_CLEAR_ORDERS, data))
if 'order_storage' not in data:
return 'ERROR', {
'message': 'Missing "order_storage" field in request.'
}
order_storage = order_storage_plugins.get_order_storage(
data['order_storage'])
order_storage.delete_by(data['market'],
deserialize_pair(data['pair']),
interval=deserialize_datetime_interval(
data['interval']))
return 'OK'
def candles(sid, data):
logger.info('RECEIVED: {}, {}'.format(EVENT_GET_CANDLES, data))
if 'candle_storage' not in data:
return 'ERROR', {
'message': 'Missing "candle_storage" field in request.'
}
candle_storage = candle_storage_plugins.get_candle_storage(
data['candle_storage'])
result_candles = candle_storage.find_by(
data['market'],
deserialize_pair(data['pair']),
deserialize_datetime_interval(data['interval']),
candle_size=deserialize_candle_size(data['candle_size']))
return 'OK', serialize_candles(result_candles)
def process_reply_strategy(self, data: Dict) -> None:
logger.info("[Rabbit] Processing task: %s | %r", TASK_REPLY_STRATEGY, data)
interval = deserialize_datetime_interval(data)
strategy_run = StrategyRun(
uuid.uuid4(),
self._date_time_factory.now(),
deserialize_pair(data['pair']),
[StrategyRunMarket(data['market_plugin_name'], data['market'], data['market_configuration'])],
data['strategy_name'],
data['strategy_configuration'],
interval,
data['candles_storage'],
data['orders_storage']
)
self._strategy_run_storage.insert(strategy_run)
self._event_emitter.emit_new_strategy_run(strategy_run)
self._strategy_replayer.run(strategy_run)
logger.info("[Rabbit] Finished task: %s | %r", TASK_REPLY_STRATEGY, data)
def deserialize_order(serialized: Dict) -> Order:
closed_at = serialized[ORDER_FIELD_CLOSED_AT]
if closed_at is not None:
closed_at = dateutil.parser.parse(closed_at).replace(
tzinfo=datetime.timezone.utc)
canceled_at = serialized[ORDER_FIELD_CANCELED_AT]
if canceled_at is not None:
canceled_at = dateutil.parser.parse(canceled_at).replace(
tzinfo=datetime.timezone.utc)
return Order(
UUID(serialized[ORDER_FIELD_ORDER_ID]),
UUID(serialized[ORDER_FIELD_STRATEGY_RUN_ID]),
serialized[ORDER_FIELD_MARKET], serialized[ORDER_FIELD_DIRECTION],
dateutil.parser.parse(serialized[ORDER_FIELD_CREATED_AT]).replace(
tzinfo=datetime.timezone.utc),
deserialize_pair(serialized[ORDER_FIELD_PAIR]),
serialized[ORDER_FIELD_TYPE],
Decimal(serialized[ORDER_FIELD_QUANTITY]),
Decimal(serialized[ORDER_FIELD_RATE]),
serialized[ORDER_FIELD_ID_ON_MARKET], serialized[ORDER_FIELD_STATUS],
closed_at, canceled_at)
