[Mod] improve static typing of converter.py with mypy

Author: vnpy

vnpy/trader/converter.py

@@ -1,5 +1,5 @@
 from copy import copy
-from typing import Dict, List, Set, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from .object import (
     ContractData,
@@ -19,7 +19,7 @@ class OffsetConverter:
 
     def __init__(self, main_engine: "MainEngine") -> None:
         """"""
-        self.holdings: Dict[str, "PositionHolding"] = {}
+        self.holdings: dict[str, "PositionHolding"] = {}
 
         self.get_contract = main_engine.get_contract
 
@@ -57,7 +57,7 @@ def update_order_request(self, req: OrderRequest, vt_orderid: str) -> None:
 
     def get_position_holding(self, vt_symbol: str) -> "PositionHolding":
         """"""
-        holding: PositionHolding = self.holdings.get(vt_symbol, None)
+        holding: PositionHolding | None = self.holdings.get(vt_symbol, None)
         if not holding:
             contract: ContractData = self.get_contract(vt_symbol)
             holding = PositionHolding(contract)
@@ -69,7 +69,7 @@ def convert_order_request(
         req: OrderRequest,
         lock: bool,
         net: bool = False
-    ) -> List[OrderRequest]:
+    ) -> list[OrderRequest]:
         """"""
         if not self.is_convert_required(req.vt_symbol):
             return [req]
@@ -108,7 +108,7 @@ def __init__(self, contract: ContractData) -> None:
         self.vt_symbol: str = contract.vt_symbol
         self.exchange: Exchange = contract.exchange
 
-        self.active_orders: Dict[str, OrderData] = {}
+        self.active_orders: dict[str, OrderData] = {}
 
         self.long_pos: float = 0
         self.long_yd: float = 0
@@ -251,17 +251,17 @@ def sum_pos_frozen(self) -> None:
         self.long_pos_frozen = self.long_td_frozen + self.long_yd_frozen
         self.short_pos_frozen = self.short_td_frozen + self.short_yd_frozen
 
-    def convert_order_request_shfe(self, req: OrderRequest) -> List[OrderRequest]:
+    def convert_order_request_shfe(self, req: OrderRequest) -> list[OrderRequest]:
         """"""
         if req.offset == Offset.OPEN:
             return [req]
 
         if req.direction == Direction.LONG:
-            pos_available: int = self.short_pos - self.short_pos_frozen
-            td_available: int = self.short_td - self.short_td_frozen
+            pos_available: float = self.short_pos - self.short_pos_frozen
+            td_available: float = self.short_td - self.short_td_frozen
         else:
-            pos_available: int = self.long_pos - self.long_pos_frozen
-            td_available: int = self.long_td - self.long_td_frozen
+            pos_available = self.long_pos - self.long_pos_frozen
+            td_available = self.long_td - self.long_td_frozen
 
         if req.volume > pos_available:
             return []
@@ -270,10 +270,10 @@ def convert_order_request_shfe(self, req: OrderRequest) -> List[OrderRequest]:
             req_td.offset = Offset.CLOSETODAY
             return [req_td]
         else:
-            req_list: List[OrderRequest] = []
+            req_list: list[OrderRequest] = []
 
             if td_available > 0:
-                req_td: OrderRequest = copy(req)
+                req_td = copy(req)
                 req_td.offset = Offset.CLOSETODAY
                 req_td.volume = td_available
                 req_list.append(req_td)
@@ -285,16 +285,16 @@ def convert_order_request_shfe(self, req: OrderRequest) -> List[OrderRequest]:
 
             return req_list
 
-    def convert_order_request_lock(self, req: OrderRequest) -> List[OrderRequest]:
+    def convert_order_request_lock(self, req: OrderRequest) -> list[OrderRequest]:
         """"""
         if req.direction == Direction.LONG:
-            td_volume: int = self.short_td
-            yd_available: int = self.short_yd - self.short_yd_frozen
+            td_volume: float = self.short_td
+            yd_available: float = self.short_yd - self.short_yd_frozen
         else:
-            td_volume: int = self.long_td
-            yd_available: int = self.long_yd - self.long_yd_frozen
+            td_volume = self.long_td
+            yd_available = self.long_yd - self.long_yd_frozen
 
-        close_yd_exchanges: Set[Exchange] = {Exchange.SHFE, Exchange.INE}
+        close_yd_exchanges: set[Exchange] = {Exchange.SHFE, Exchange.INE}
 
         # If there is td_volume, we can only lock position
         if td_volume and self.exchange not in close_yd_exchanges:
@@ -304,9 +304,9 @@ def convert_order_request_lock(self, req: OrderRequest) -> List[OrderRequest]:
         # If no td_volume, we close opposite yd position first
         # then open new position
         else:
-            close_volume: int = min(req.volume, yd_available)
-            open_volume: int = max(0, req.volume - yd_available)
-            req_list: List[OrderRequest] = []
+            close_volume: float = min(req.volume, yd_available)
+            open_volume: float = max(0, req.volume - yd_available)
+            req_list: list[OrderRequest] = []
 
             if yd_available:
                 req_yd: OrderRequest = copy(req)
@@ -318,31 +318,31 @@ def convert_order_request_lock(self, req: OrderRequest) -> List[OrderRequest]:
                 req_list.append(req_yd)
 
             if open_volume:
-                req_open: OrderRequest = copy(req)
+                req_open = copy(req)
                 req_open.offset = Offset.OPEN
                 req_open.volume = open_volume
                 req_list.append(req_open)
 
             return req_list
 
-    def convert_order_request_net(self, req: OrderRequest) -> List[OrderRequest]:
+    def convert_order_request_net(self, req: OrderRequest) -> list[OrderRequest]:
         """"""
         if req.direction == Direction.LONG:
-            pos_available: int = self.short_pos - self.short_pos_frozen
-            td_available: int = self.short_td - self.short_td_frozen
-            yd_available: int = self.short_yd - self.short_yd_frozen
+            pos_available: float = self.short_pos - self.short_pos_frozen
+            td_available: float = self.short_td - self.short_td_frozen
+            yd_available: float = self.short_yd - self.short_yd_frozen
         else:
-            pos_available: int = self.long_pos - self.long_pos_frozen
-            td_available: int = self.long_td - self.long_td_frozen
-            yd_available: int = self.long_yd - self.long_yd_frozen
+            pos_available = self.long_pos - self.long_pos_frozen
+            td_available = self.long_td - self.long_td_frozen
+            yd_available = self.long_yd - self.long_yd_frozen
 
         # Split close order to close today/yesterday for SHFE/INE exchange
         if req.exchange in {Exchange.SHFE, Exchange.INE}:
-            reqs: List[OrderRequest] = []
+            reqs: list[OrderRequest] = []
             volume_left: float = req.volume
 
             if td_available:
-                td_volume: int = min(td_available, volume_left)
+                td_volume: float = min(td_available, volume_left)
                 volume_left -= td_volume
 
                 td_req: OrderRequest = copy(req)
@@ -351,7 +351,7 @@ def convert_order_request_net(self, req: OrderRequest) -> List[OrderRequest]:
                 reqs.append(td_req)
 
             if volume_left and yd_available:
-                yd_volume: int = min(yd_available, volume_left)
+                yd_volume: float = min(yd_available, volume_left)
                 volume_left -= yd_volume
 
                 yd_req: OrderRequest = copy(req)
@@ -360,7 +360,7 @@ def convert_order_request_net(self, req: OrderRequest) -> List[OrderRequest]:
                 reqs.append(yd_req)
 
             if volume_left > 0:
-                open_volume: int = volume_left
+                open_volume: float = volume_left
 
                 open_req: OrderRequest = copy(req)
                 open_req.offset = Offset.OPEN
@@ -370,11 +370,11 @@ def convert_order_request_net(self, req: OrderRequest) -> List[OrderRequest]:
             return reqs
         # Just use close for other exchanges
         else:
-            reqs: List[OrderRequest] = []
-            volume_left: float = req.volume
+            reqs = []
+            volume_left = req.volume
 
             if pos_available:
-                close_volume: int = min(pos_available, volume_left)
+                close_volume: float = min(pos_available, volume_left)
                 volume_left -= pos_available
 
                 close_req: OrderRequest = copy(req)
@@ -383,9 +383,9 @@ def convert_order_request_net(self, req: OrderRequest) -> List[OrderRequest]:
                 reqs.append(close_req)
 
             if volume_left > 0:
-                open_volume: int = volume_left
+                open_volume = volume_left
 
-                open_req: OrderRequest = copy(req)
+                open_req = copy(req)
                 open_req.offset = Offset.OPEN
                 open_req.volume = open_volume
                 reqs.append(open_req)