def on_data(self, packet): channel = packet.get("ch", None) if channel in self._callback_dict: callback = self._callback_dict[channel] callback(packet) else: logger.info('%s got unhandled message %s', self, packet)
def check_order(self, order: OrderData): notional = abs(order.price * order.volume) if notional > self.max_notional: logger.info("Order notional %f excess the maximum value %f\n%s", order.volume, self.max_notional, order) return False return True
def _process_order_request(self, order: OrderData): exchange = order.contract.exchange if exchange in self._gateway_dict: gateway = self._gateway_dict[exchange] logger.debug('%s send %s', gateway, order) gateway.send_order(order) else: logger.info("No such %s gateway exist", exchange)
def run(self): try: while self.active: self._process_jobs() except KeyboardInterrupt: logger.info('KeyboardInterrupt Caught!!') except Exception as e: logger.exception(e)
def __init__(self, order: OrderData): super(AlgorithmTemplate, self).__init__() self._trading_mode = EnumTradingMode.AUTO self._target_order = order self._subject: BrokerInterface = BrokerInterface() self._sid = 0 self._datetime = order.datetime logger.info('New algorithm is added for order %s', order)
def configure(self, broker_config: dict): super(RealBroker, self).configure(broker_config) for gateway_name, gateway_config in broker_config['gateway'].items(): gateway = GatewayFactory(gateway_name) gateway.set_callback(self.send) gateway.configure(gateway_config) self._gateway_dict[gateway_name] = gateway logger.info('%s configuration finished', gateway)
def __call__(self, *args, **kwargs): try: return self.job_func(*args, **kwargs) except Exception as e: logger.exception(e) logger.info(f'Error happen when trigger {self.job_func} with params {args} and {kwargs}') if self.cancel_on_exception: return CancelJob
def modify_strategy(self, strategy_config: dict): strategy_info = StrategyConfigInfo.from_dict(strategy_config) strategy_id = strategy_info.strategy_id if strategy_id in self.strategy_dict: strategy = self.strategy_dict[strategy_id] strategy.configure(strategy_info) else: logger.info('There is no such strategy exist with id %s', strategy_id)
def add_strategy(self, strategy: StrategyTemplate): id_ = strategy.id_ if id_ not in self._strategy_dict: self._strategy_dict[id_] = strategy strategy.attach_with(self._broker) strategy.algorithm_engine = self._algorithm_engine logger.info('%s was added to %s', strategy, self) else: logger.info('%s already exists in %s', strategy, self)
def on_send_order_failed(self, status_code: str, request: Request): """ Callback when sending order failed on server. """ order = request.extra order.status = EnumOrderStatus.REJECTED self.on_order(order) msg = f"委托失败,状态码:{status_code},信息:{request.response.text}" logger.info(msg)
def handle_message(self, msg: BaseData): event_type = msg.EVENT_TYPE if event_type in self._event_process_map: process_func = self._event_process_map[event_type] else: process_func = self._process_general_event try: process_func(msg) except Exception as e: logger.exception(e) logger.info(f'Error occurred when handling {msg}') raise e
def on_packet(self, packet): if "ping" in packet: req = {"pong": packet["ping"]} self.send_packet(req) elif "op" in packet and packet["op"] == "ping": req = { "op": "pong", "ts": packet["ts"] } self.send_packet(req) elif "err-msg" in packet: code = packet["err-code"] msg = packet["err-msg"] logger.warning(f'{self} got error code {code} with message {msg}') elif "op" in packet and packet["op"] == "auth": logger.info(f'{self} connected') else: self.on_data(packet) """"""
def configure(self, strategy_config: StrategyConfigInfo): self._strategy_id = strategy_config.strategy_id self._universe = strategy_config.universe self._portfolio = Portfolio(self._strategy_id, strategy_config.accounting_unit) for key, value in strategy_config.positions.items(): self._portfolio.adjust_asset(key, value) for key, value in strategy_config.arguments.items(): setattr(self, key, value) self._risk_list.clear() for key, value in strategy_config.risks.items(): risk = RiskControlFactory(key, **value) self._risk_list.append(risk) logger.info('Risk Control %s is added to %s', risk, self) logger.info("Configure %s with %s", self, strategy_config.pretty_string()) self.on_init()
def _trade_by_cubic_data(self, cubic_data): self.cancel_all() factor_df = self.factor.predict(cubic_data) factor_series = factor_df.iloc[-1].sort_values().dropna() to_buy_list = list(factor_series.iloc[-self.top_count:].index) self._to_hold = to_buy_list self._factor_series = factor_series if self.trading_mode < EnumTradingMode.AUTO: logger.info('{} not in auto trading mode: {}'.format( self, self.trading_mode.name)) return to_buy_set = set(self._get_cross_symbol_list(to_buy_list)) logger.info('{} plan to hold {}'.format(self, to_buy_set)) available_cash = self.portfolio.get_cash_value() for position in self.portfolio: direction = EnumOrderDirection.SELL symbol = position.symbol # volume = self.portfolio[symbol].amount volume = self.portfolio.available_base_amount(symbol) if volume > 0 and self.check_notional(symbol, volume): if symbol in to_buy_set: to_buy_set.remove(symbol) else: available_cash += position.asset_value self._trade(symbol, direction, volume) # cash will be get after seconds in real time trading if len(to_buy_set): value = available_cash / len(to_buy_set) direction = EnumOrderDirection.BUY for symbol in to_buy_set: price = self.choose_price(symbol, direction, self.price_level) volume = value / price if volume > 0 and self.check_notional(symbol, volume): self._trade(symbol, direction, volume)
def cancel_order(self, order_cancel: OrderData): self.throttle() self._local_order_manager.on_order(order_cancel) order_id = order_cancel.order_id contract = self._contracts[order_cancel.symbol] symbol_root = contract.symbol_root logger.debug('%s cancel order %s', self, order_cancel.client_order_id) try: self._exchange.cancel_order(order_id, symbol_root) logger.debug('%s canceled order %s successfully', self, order_cancel.client_order_id) order_cancel.status = EnumOrderStatus.CANCELLED except ccxt.errors.OrderNotFound as e: logger.info("Order already been closed or cancelled before: %s\n%s", e.args, order_cancel) order_status = self.fetch_order_status(order_cancel) order_cancel.on_order(order_status) except ccxt.errors.NetworkError as e: logger.info("Network error: %s\n%s", e.args, order_cancel) order_cancel.status = EnumOrderStatus.CANCEL_ERROR self._local_order_manager.on_order(order_cancel) self.on_order(order_cancel) return order_cancel
def cancel_order(self, client_order_id): if not self._trading_mode: logger.info( 'Cancel request not send, Reason: %s is in trading state %s', self, self._trading_mode) return if client_order_id not in self._working_order_dict: logger.debug( 'Cancel request not send, Reason: order %s is not in working order list', client_order_id) return working_order = self._working_order_dict[client_order_id] if working_order.is_closed(): logger.info( 'Cancel request not send, Reason: order %s is already finished with status %s', working_order.client_order_id, working_order.status) return if working_order.status == EnumOrderStatus.CANCELLING: logger.debug( 'Cancel request not send, Reason: order %s has been sent before', client_order_id) return if not working_order.order_id: logger.info( 'Cancel request not send, Reason: order %s is not alive in exchange yet (no order id)', client_order_id) return cancel_req = copy.copy(working_order) cancel_req.status = EnumOrderStatus.CANCELLING logger.debug('%s cancel order with client order id %s', self, client_order_id) self.broker.send_order(cancel_req)
def remove_strategy(self, id_: str): if id_ in self._strategy_dict: strategy = self._strategy_dict[id_] strategy.detach() del self._strategy_dict[id_] logger.info('%s was removed from %s', strategy, self)
def adjust_asset(self, asset, volume): balance = self._get_balance(asset) balance.total_amount += volume logger.info('%s processed asset %s %s\n' 'Present positions is:\n%s', self, asset, volume, balance.total_amount)
def _order_check(self, order: OrderData): if self._trading_mode <= EnumTradingMode.OFF: logger.info('Request not send: %s is in trading state %s', self, self._trading_mode) return False return order.contract_check()
def on_cancel_order_failed(self, status_code: str, request: Request): msg = f"撤单失败,状态码:{status_code},信息:{request.response.text}" logger.info(msg)
def set_mode(self, mode): if isinstance(mode, EnumTradingMode): logger.info('%s mode changed: %s --> %s', self, self._trading_mode, mode) self._trading_mode = mode