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
