tradx 0.8.3__py3-none-any.whl → 0.9__py3-none-any.whl

tradx/algoContainer.py

@@ -1,7 +1,7 @@
 from typing import Dict, Set, Any
 from tradx.baseClass.baseAlgo import BaseAlgo
-from tradx.baseClass.candleData import CandleData
-from tradx.baseClass.touchLineData import TouchLineData
+from tradx.baseClass.market.candleData import CandleData
+from tradx.baseClass.market.touchLineData import TouchLineData
 import asyncio
 
 
@@ -88,3 +88,83 @@ class AlgoContainer:
             if isinstance(message, TouchLineData):
                 for algo in self.subscriptions[message.ExchangeInstrumentID]:
                     asyncio.ensure_future(algo.on_touchLineData(message))
+
+
+class SubcribeContainer:
+    """
+    AlgoContainer is a container class that maps algorithms to their subscriptions and allows broadcasting messages.
+    Attributes:
+        subscriptions (Dict[int, Set[BaseAlgo]]): A dictionary mapping subscription keys to sets of algorithm instances.
+    Methods:
+        __init__():
+            Initializes the AlgoContainer with an empty subscription map.
+        subscribe(key: int, algo: BaseAlgo):
+            Subscribes an algorithm to a specific key.
+                key (int): The subscription key.
+                algo (BaseAlgo): The algorithm instance subscribing.
+        unsubscribe(key: int, algo: BaseAlgo):
+            Unsubscribes an algorithm from a specific key.
+                key (int): The subscription key.
+                algo (BaseAlgo): The algorithm instance unsubscribing.
+        broadcast(key: int, message: str, dataType: str):
+            Broadcasts a message to all algorithms subscribed to a given key.
+                key (int): The key to broadcast the message for.
+                dataType (str): The type of data being broadcasted (e.g., "bar").
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the algoContainer instance.
+
+        Attributes:
+            subscriptions (Dict[int, Set[BaseAlgo]]):
+                A dictionary mapping an integer key (e.g., a topic or identifier)
+                to a set of algorithm instances (BaseAlgo).
+        """
+        self.subscriptions: Dict[int, Set[str]] = {}
+
+    def subscribe(self, exchangeInstrumentID, xtsMessageCode, uuid: str) -> None:
+        """
+        Subscribes an algorithm to a given key.
+        Args:
+            key: The key to subscribe the algorithm to.
+            algo (BaseAlgo): The algorithm to be subscribed.
+        Raises:
+            None
+        Returns:
+            None
+        """
+        key = (exchangeInstrumentID, xtsMessageCode)
+        if key not in self.subscriptions:
+            self.subscriptions[key] = set()
+        self.subscriptions[key].add(uuid)
+
+    def unsubscribe(self, exchangeInstrumentID, xtsMessageCode, uuid: str) -> None:
+        """
+        Unsubscribe an algorithm from a given key.
+        This method removes the specified algorithm from the list of
+        subscriptions associated with the given key. If no more algorithms
+        are subscribed to the key after removal, the key is deleted from
+        the subscriptions.
+        Args:
+            key: The key from which the algorithm should be unsubscribed.
+            algo (BaseAlgo): The algorithm instance to be unsubscribed.
+        """
+        key = (exchangeInstrumentID, xtsMessageCode)
+        if key in self.subscriptions and uuid in self.subscriptions[key]:
+            self.subscriptions[key].remove(uuid)
+
+            # Remove the key if no more algorithms are subscribed
+            if not self.subscriptions[key]:
+                del self.subscriptions[key]
+
+    def ifExists(self, exchangeInstrumentID, xtsMessageCode) -> bool:
+        """
+        Check if a subscription exists for the given exchangeInstrumentID and xtsMessageCode.
+        Args:
+            exchangeInstrumentID: The exchange instrument ID to check.
+            xtsMessageCode: The XTS message code to check.
+        Returns:
+            bool: True if the subscription exists, False otherwise.
+        """
+        return (exchangeInstrumentID, xtsMessageCode) in self.subscriptions

tradx/baseClass/baseAlgo.py

@@ -1,9 +1,9 @@
 from abc import ABC, abstractmethod
 import shortuuid
-from typing import Any, TYPE_CHECKING, List, Dict
+from typing import Any, TYPE_CHECKING, List, Dict, Set
 from decimal import Decimal
-from tradx.baseClass.order import Order
-from tradx.baseClass.position import Position
+from tradx.baseClass.interactive.order import Order
+from tradx.baseClass.interactive.position import Position
 
 import asyncio
 
@@ -11,10 +11,10 @@ import asyncio
 if TYPE_CHECKING:
     from tradx.marketDataEngine import marketDataEngine
     from tradx.interactiveEngine import interactiveEngine
-    from tradx.baseClass.touchLineData import TouchLineData
-    from tradx.baseClass.orderEvent import OrderEvent
-    from tradx.baseClass.tradeEvent import TradeEvent
-    from tradx.baseClass.candleData import CandleData
+    from tradx.baseClass.market.touchLineData import TouchLineData
+    from tradx.baseClass.interactive.orderEvent import OrderEvent
+    from tradx.baseClass.interactive.tradeEvent import TradeEvent
+    from tradx.baseClass.market.candleData import CandleData
 
 
 class BaseAlgo(ABC):
@@ -74,6 +74,7 @@ class BaseAlgo(ABC):
         self.order_nos = shortuuid
         self.position_diary: List[Position] = []
         self.order_diary: List[Order] = []
+        self.uuids = set()
         # Registering inside interactive engine
         self.name = interactiveEngine.shortuuid.ShortUUID().random(length=4)
         self.interactiveEngine.strategy_to_id[self.name] = self
@@ -127,7 +128,13 @@ class BaseAlgo(ABC):
         Returns:
             str: An 8-digit unique order identifier.
         """
-        return f"{self.name}{self.order_nos.ShortUUID().random(length=4)}"
+        # Generate a unique 4-character key not present in self.uuids
+        while True:
+            ids = self.order_nos.ShortUUID().random(length=4)
+            if ids not in self.uuids:
+                self.uuids.add(ids)
+                break
+        return f"{self.name}{ids}"
 
     async def order_(self, order: "OrderEvent") -> None:
         """
@@ -152,6 +159,14 @@ class BaseAlgo(ABC):
             # Update the status of the existing order
             existing_order.OrderStatus = order.OrderStatus
             existing_order.OrderPrice = order.OrderAverageTradedPriceAPI
+            if existing_order.AppOrderID != order.AppOrderID:
+
+                if self.interactiveEngine.user_logger:
+                    self.interactiveEngine.user_logger.info(
+                        f"Updated order {order.OrderUniqueIdentifier} App order id from {existing_order.AppOrderID} to {order.AppOrderID}",
+                        caller=f"{self.__class__.__name__}.order_",
+                    )
+                    existing_order.AppOrderID = order.AppOrderID
             if self.interactiveEngine.user_logger:
                 self.interactiveEngine.user_logger.info(
                     f"Updated order {order.OrderUniqueIdentifier} status to {order.OrderStatus}",
@@ -289,7 +304,7 @@ class BaseAlgo(ABC):
             )
 
         for order in self.order_diary:
-            if order.OrderStatus in ["PendingNew", "New"]:
+            if order.OrderStatus in ["PendingNew", "New", "Replaced", "PendingReplace"]:
                 asyncio.ensure_future(
                     self.interactiveEngine.cancel_order(
                         order.AppOrderID, order.OrderUniqueIdentifier

tradx/baseClass/{order.py → interactive/order.py}

@@ -1,5 +1,6 @@
 from pydantic import BaseModel
 from decimal import Decimal
+import json
 
 
 class Order(BaseModel):
@@ -53,3 +54,8 @@ class Order(BaseModel):
             OrderSide=OrderSide,
             TimeInForce=TimeInForce,
         )
+
+    @classmethod
+    def from_str(cls, message: str):
+        data = json.loads(message)
+        return cls(**data)

tradx/baseClass/{orderEvent.py → interactive/orderEvent.py}

@@ -34,7 +34,9 @@ def parse_datetime(value) -> Any:
         return datetime(1980, 1, 1) + timedelta(seconds=value)
     return value
 class OrderEvent(BaseModel):
-    
+    """
+    Order Event class representing an order event in the system.
+    """
 
     LoginID: str
     ClientID: str = "*****"

tradx/baseClass/{position.py → interactive/position.py}

@@ -1,4 +1,5 @@
 from pydantic import BaseModel
+import json
 
 
 class Position(BaseModel):
@@ -20,8 +21,9 @@ class Position(BaseModel):
         Constructs all the necessary attributes for the Position object.
     """
 
-    ExchangeSegment: str
     ExchangeInstrumentID: int
+    ExchangeSegment: str
+
     ProductType: str
     Quantity: int
 
@@ -44,3 +46,8 @@ class Position(BaseModel):
             ProductType=ProductType,
             Quantity=Quantity,
         )
+
+    @classmethod
+    def from_str(cls, message: str):
+        data = json.loads(message)
+        return cls(**data)