Refactor

Author: sinall

shipane_sdk/base_manager.py

@@ -161,22 +161,28 @@ def purchase_new_stocks(self):
         self._shipane_client.purchase_new_stocks()
 
     def execute(self, order=None, **kwargs):
-        if order is not None:
-            self._execute(order)
+        if order is None:
+            common_order = Order.from_e_order(**kwargs)
         else:
-            self._shipane_client.execute(**kwargs)
+            common_order = self._normalize_order(order)
+
+        self._logger.info("[实盘易] 跟单：" + str(common_order))
+        if not self._should_execute(common_order):
+            return
+
+        try:
+            actual_order = self._execute(common_order)
+            return actual_order
+        except Exception:
+            self._logger.exception("[实盘易] 下单异常")
 
     def cancel(self, order):
         if order is None:
             self._logger.info('[实盘易] 委托为空，忽略撤单请求')
             return
 
         try:
-            order_id = order if isinstance(order, int) else order.order_id
-            if order_id in self._order_id_map:
-                self._shipane_client.cancel(order_id=self._order_id_map[order_id])
-            else:
-                self._logger.warning('[实盘易] 未找到对应的委托编号')
+            self._cancel(order)
         except:
             self._logger.exception("[实盘易] 撤单异常")
 
@@ -219,33 +225,46 @@ def _sync_config(self):
         return self._config['sync']
 
     def _execute(self, order):
-        self._logger.info("[实盘易] 跟单：" + str(order))
-
-        if not self._should_execute(order):
-            return
+        common_order = self._normalize_order(order)
+        e_order = common_order.to_e_order()
+        actual_order = self._shipane_client.execute(**e_order)
+        self._order_id_map[common_order.id] = actual_order['id']
+        return actual_order
+
+    def _cancel(self, order):
+        if isinstance(order, int):
+            quant_order_id = order
+        else:
+            common_order = self._normalize_order(order)
+            quant_order_id = common_order.id
 
         try:
-            e_order = self._strategy_context.convert_order(order)
-            actual_order = self._shipane_client.execute(**e_order)
-            self._order_id_map[order.order_id] = actual_order['id']
-            return actual_order
-        except:
-            self._logger.exception("[实盘易] 下单异常")
+            order_id = self._order_id_map.pop(quant_order_id)
+            self._shipane_client.cancel(order_id=order_id)
+        except KeyError:
+            self._logger.warning('[实盘易] 未找到对应的委托编号')
+
+    def _normalize_order(self, order):
+        if isinstance(order, Order):
+            common_order = order
+        else:
+            common_order = self._strategy_context.convert_order(order)
+        return common_order
 
-    def _should_execute(self, order):
+    def _should_execute(self, common_order):
         if self._strategy_context.is_backtest():
             self._logger.info("[实盘易] 当前为回测环境，忽略下单请求")
             return False
-        if order is None:
+        if common_order is None:
             self._logger.info('[实盘易] 委托为空，忽略下单请求')
             return False
-        if self._is_expired(order):
+        if self._is_expired(common_order):
             self._logger.info('[实盘易] 委托已过期，忽略下单请求')
             return False
         return True
 
-    def _is_expired(self, order):
-        return order.add_time < self._expire_before
+    def _is_expired(self, common_order):
+        return common_order.add_time < self._expire_before
 
     def _pre_check(self):
         if not self._sync_config['enabled']:
@@ -308,8 +327,6 @@ def _execute_order(self, order):
                 return
 
             e_order = order.to_e_order()
-            e_order['type'] = 'MARKET'
-            e_order['priceType'] = 4
             self._shipane_client.execute(**e_order)
         except:
             self._logger.exception("[%s] 客户端下单失败", self.id)

shipane_sdk/jobs/online_quant_sync.py

@@ -81,8 +81,6 @@ def _execute_order(self, order, client):
                 self._logger.info(order)
                 return
             e_order = order.to_e_order()
-            e_order['type'] = 'MARKET'
-            e_order['priceType'] = 4
             self._shipane_client.execute(client=client, **e_order)
         except Exception as e:
             self._logger.error('客户端[%s]下单失败\n%s', client, e)

shipane_sdk/joinquant/manager.py

@@ -43,16 +43,15 @@ def get_portfolio(self):
         return portfolio
 
     def convert_order(self, quant_order):
-        order_type = 'LIMIT' if quant_order.limit > 0 else 'MARKET'
-        e_order = dict(
-            action=('BUY' if quant_order.is_buy else 'SELL'),
-            symbol=quant_order.security,
-            type=order_type,
-            priceType=(0 if order_type == 'LIMIT' else 4),
+        common_order = Order(
+            id=quant_order.order_id,
+            action=(OrderAction.OPEN if quant_order.is_buy else OrderAction.CLOSE),
+            security=quant_order.security,
             price=quant_order.limit,
-            amount=quant_order.amount
+            amount=quant_order.amount,
+            style=(OrderStyle.LIMIT if quant_order.limit > 0 else OrderStyle.MARKET),
         )
-        return e_order
+        return common_order
 
     def has_open_orders(self):
         return bool(get_open_orders())

shipane_sdk/models.py

@@ -254,6 +254,7 @@ def rebalance(self):
             self._available_cash = 0
             self._total_value = self._positions_value
 
+
 class Position(object):
     @staticmethod
     def to_json(instance):
@@ -334,11 +335,23 @@ def from_json(json):
         order = Order()
         order.action = OrderAction.OPEN if json['action'] == 'BUY' else OrderAction.CLOSE
         order.security = json['symbol']
+        order.style = OrderStyle(json['type'])
         order.price = json['price']
         order.amount = json['amount']
         return order
 
-    def __init__(self, action=None, security=None, amount=None, price=None, style=None):
+    @staticmethod
+    def from_e_order(**kwargs):
+        order = Order()
+        order.action = OrderAction.OPEN if kwargs['action'] == 'BUY' else OrderAction.CLOSE
+        order.security = kwargs['symbol']
+        order.style = OrderStyle(kwargs['type'])
+        order.price = kwargs['price']
+        order.amount = kwargs['amount']
+        return order
+
+    def __init__(self, id=None, action=None, security=None, amount=None, price=None, style=None):
+        self._id = id
         self._action = action
         self._security = security
         self._amount = amount
@@ -357,9 +370,11 @@ def __str__(self):
 
     def to_e_order(self):
         e_order = dict(
-            action='BUY' if self._action == OrderAction.OPEN else 'SELL',
+            action=('BUY' if self._action == OrderAction.OPEN else 'SELL'),
             symbol=self._security,
-            type=self._style,
+            type=self._style.name,
+            priceType=(0 if self._style == OrderStyle.LIMIT else 4),
+            price=self._price,
             amount=self._amount
         )
         return e_order
@@ -368,6 +383,14 @@ def to_e_order(self):
     def value(self):
         return self._amount * self._price
 
+    @property
+    def id(self):
+        return self._id
+
+    @id.setter
+    def id(self, value):
+        self._id = value
+
     @property
     def action(self):
         return self._action