fix: price round precision issue with decimal

Author: Yvictor

sjtrade/__init__.py

@@ -2,7 +2,7 @@
 trading with shioaji
 """
 
-__version__ = "0.4.4"
+__version__ = "0.4.5"
 
 def inject_env():
     import os

sjtrade/strategy.py

@@ -3,8 +3,8 @@
 from loguru import logger
 from shioaji.constant import TFTStockPriceType
 
-from .io.file import read_csv_position, read_position
-from .utils import price_move, price_round, quantity_num_split
+from .io.file import read_position
+from .utils import price_round, price_limit
 from .position import Position, PriceSet
 from .data import Snapshot
 
@@ -31,7 +31,7 @@ def cover_price_set_onclose(self, position: Position):
                 price=position.contract.limit_down
                 if position.status.open_quantity > 0
                 else position.contract.limit_up,
-                quantity=position.status.open_quantity*-1,
+                quantity=position.status.open_quantity * -1,
                 price_type=TFTStockPriceType.LMT,
             )
         ]
@@ -70,33 +70,45 @@ def entry_positions(self):
             stop_loss_price = contract.reference * (
                 1 + (-1 if pos > 0 else 1) * (self.stop_loss_pct)
             )
+            stop_loss_price = price_round(stop_loss_price, pos > 0)
+            stop_loss_price = price_limit(
+                stop_loss_price, contract.limit_up, contract.limit_down
+            )
             stop_profit_price = contract.reference * (
                 1 + (1 if pos > 0 else -1) * (self.stop_profit_pct)
             )
+            stop_profit_price = price_round(stop_profit_price, pos < 0)
+            stop_profit_price = price_limit(
+                stop_profit_price, contract.limit_up, contract.limit_down
+            )
             entry_price = contract.reference * (
                 1 + (-1 if pos > 0 else 1) * self.entry_pct
             )
+            entry_price = price_round(entry_price, pos > 0)
+            entry_price = price_limit(
+                entry_price, contract.limit_up, contract.limit_down
+            )
             entry_args.append(
                 {
                     "code": code,
                     "pos": pos,
                     "entry_price": [
                         PriceSet(
-                            price=price_round(entry_price, pos > 0),
+                            price=entry_price,
                             quantity=pos,
                             price_type=TFTStockPriceType.LMT,
                         )
                     ],
                     "stop_profit_price": [
                         PriceSet(
-                            price=price_round(stop_profit_price, pos < 0),
+                            price=stop_profit_price,
                             quantity=pos,
                             price_type=TFTStockPriceType.MKT,
                         )
                     ],
                     "stop_loss_price": [
                         PriceSet(
-                            price=price_round(stop_loss_price, pos > 0),
+                            price=stop_loss_price,
                             quantity=pos,
                             price_type=TFTStockPriceType.MKT,
                         )
@@ -112,4 +124,3 @@ def cover_positions(
         self, positions: Dict[str, Position], snapshots: Dict[str, Snapshot] = dict()
     ):
         return self.cover_positions_onclose()
-

sjtrade/utils.py

@@ -20,16 +20,27 @@ def price_floor(price: float) -> float:
     return round(math.floor(price * n - ((price * n % 5) * (1 - quinary))) / n, 2)
 
 
-def price_round(price: float, up: bool = False):
+def price_round(price: float, up: bool = False) -> float:
     roudnf = math.ceil if up else math.floor
+    price = Decimal(f"{price}")
     logp = math.floor(math.log10(price))
     quinary = ((price / 10**logp) // 5) if logp >= 1 else 1
     n = min(10 ** (3 - logp - quinary), 100)
-    return round(
-        roudnf(price * n + ((5 * int(up) - (price * n % 5)) * (1 - quinary))) / n, 2
+    return float(
+        round(
+            roudnf(price * n + ((5 * int(up) - (price * n % 5)) * (1 - quinary))) / n, 2
+        )
     )
 
 
+def price_limit(price: float, up: float, down: float):
+    if price > up:
+        return up
+    elif price < down:
+        return down
+    return price
+
+
 def price_move(price: float, tick: int) -> float:
     return rs2py.get_price_tick_move(price, tick)
 

tests/test_utils.py

@@ -66,6 +66,7 @@ def test_price_floor(input: float, expected: float):
         (50.01, True, 50.1),
         (100.01, True, 100.5),
         (500.01, True, 501),
+        (34.05, False, 34.05),
         # TODO case 10% over limit up
     ],
 )