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)