tradx 0.1.0__py3-none-any.whl

tradx/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from tradx!"

tradx/algoContainer.py

@@ -0,0 +1,90 @@
+from typing import Dict, Set, Any
+from tradx.baseClass.baseAlgo import BaseAlgo
+from tradx.baseClass.candleData import CandleData
+from tradx.baseClass.touchLineData import TouchLineData
+import asyncio
+
+
+class AlgoContainer:
+    """
+    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[BaseAlgo]] = {}
+
+    def subscribe(self, key, algo: BaseAlgo) -> 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
+        """
+
+        if key not in self.subscriptions:
+            self.subscriptions[key] = set()
+        self.subscriptions[key].add(algo)
+
+    def unsubscribe(self, key, algo: BaseAlgo) -> 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.
+        """
+
+        if key in self.subscriptions and algo in self.subscriptions[key]:
+            self.subscriptions[key].remove(algo)
+
+            # Remove the key if no more algorithms are subscribed
+            if not self.subscriptions[key]:
+                del self.subscriptions[key]
+
+    async def broadcast(self, message: Any) -> None:
+        """
+        Broadcast a message to all algorithms subscribed to a given key.
+
+        Args:
+            key (str): The key to broadcast the message for.
+            message (str): The message to broadcast.
+        """
+        if message.ExchangeInstrumentID in self.subscriptions:
+            if isinstance(message, CandleData):
+                for algo in self.subscriptions[message.ExchangeInstrumentID]:
+                    asyncio.ensure_future(algo.on_barData(message))
+            if isinstance(message, TouchLineData):
+                for algo in self.subscriptions[message.ExchangeInstrumentID]:
+                    asyncio.ensure_future(algo.on_touchLineData(message))

tradx/baseClass/baseAlgo.py

@@ -0,0 +1,338 @@
+from abc import ABC, abstractmethod
+import shortuuid
+from typing import Any, TYPE_CHECKING, List
+from tradx.baseClass.order import Order
+from tradx.baseClass.position import Position
+import asyncio
+
+
+if TYPE_CHECKING:
+    from tradx import interactiveEngine, marketDataEngine
+    from tradx.baseClass.orderEvent import OrderEvent
+    from tradx.baseClass.tradeEvent import TradeEvent
+    from tradx.baseClass.candleData import CandleData
+    from tradx.baseClass.touchLineData import TouchLineData
+
+
+class BaseAlgo(ABC):
+    """
+    BaseAlgo is an abstract base class for algorithmic trading strategies. It provides a framework for handling market data, orders, and trades, and requires subclasses to implement specific methods for processing data and events.
+    Attributes:
+        cache (dict): A cache for storing temporary data.
+        order_nos (ShortUUID): Instance of ShortUUID for generating unique order identifiers.
+        position_diary (List[Position]): A list to store position data.
+        order_diary (List[Order]): A list to store order data.
+        name (str): A unique identifier for the algorithm.
+    Methods:
+        __init__(marketDataEngine, interactiveEngine):
+            Initializes the BaseAlgo class with marketDataEngine and interactiveEngine instances.
+        on_barData(data):
+            Abstract method to process candle data. Must be implemented by subclasses.
+        subscribe():
+            Abstract method to handle subscription logic. Must be implemented by subclasses.
+        order_no():
+            Generates a unique order identifier.
+        order_(order):
+            Handles the order event by updating the status of an existing order or inserting a new order.
+        on_orderEvent(message):
+            Abstract method to handle order events. Must be implemented by subclasses.
+        trade_(trade):
+            Handles a trade event by updating the position diary and triggering the on_tradeEvent callback.
+        on_tradeEvent(message):
+            Abstract method to handle trade events. Must be implemented by subclasses.
+        unsubscribe():
+            Abstract method to handle unsubscription logic. Must be implemented by subclasses.
+        initialize():
+            Abstract method to initialize the strategy. Must be implemented by subclasses.
+        deinitialize():
+            Abstract method to deinitialize the strategy. Must be implemented by subclasses.
+        liquidateIntraday():
+            Class method to liquidate all intraday positions and cancel pending orders.
+        isInvested():
+            Class method to check if there are any investments by summing the quantities of all positions in the position diary.
+    """
+
+    def __init__(
+        self,
+        marketDataEngine: "marketDataEngine",
+        interactiveEngine: "interactiveEngine",
+    ):
+        """
+        Initialize the BaseAlgo class.
+
+        Args:
+            marketDataEngine (marketDataEngine): Instance of marketDataEngine.
+            interactiveEngine (interactiveEngine): Instance of interactiveEngine.
+        """
+        # Initialize instance variables
+        self.cache = {}
+        self.marketDataEngine = marketDataEngine
+        self.interactiveEngine = interactiveEngine
+        self.order_nos = shortuuid
+        self.position_diary: List[Position] = []
+        self.order_diary: List[Order] = []
+
+        # Registering inside interactive engine
+        self.name = interactiveEngine.shortuuid.ShortUUID().random(length=4)
+        self.interactiveEngine.strategy_to_id[self.name] = self
+
+        # Logging the initialization
+        if self.marketDataEngine.user_logger:
+            self.marketDataEngine.user_logger.info(
+                f"Algorithm initialized with ID: {self.name}",
+                caller=f"{self.__class__.__name__}.__init__",
+            )
+
+    @abstractmethod
+    async def on_barData(self, data: "CandleData") -> None:
+        """
+        Abstract method (virtual function) to process candle data.
+        Must be implemented by subclasses.
+
+        Args:
+            data (any): The input data to process.
+        """
+        ...
+
+    @abstractmethod
+    async def on_touchLineData(self, data: "TouchLineData") -> None:
+        """
+        Asynchronous method to handle touch line data.
+        Args:
+            data (TouchLineData): The touch line data to be processed.
+        Returns:
+            None
+        """
+
+        ...
+
+    @abstractmethod
+    async def subscribe(self) -> None:
+        """
+        Abstract method (virtual function) to process subscribe.
+        Must be implemented by subclasses.
+
+        Args:
+            data (any): The input data to process.
+        """
+        ...
+
+    def order_no(self) -> str:
+        """
+        Generate a unique order identifier.
+        The identifier is an 8-digit string composed of a 4-digit algorithm ID (derived from `self.name`)
+        and a 4-digit random sequence generated using the `ShortUUID` library.
+        Returns:
+            str: An 8-digit unique order identifier.
+        """
+        return f"{self.name}{self.order_nos.ShortUUID().random(length=4)}"
+
+    async def order_(self, order: "OrderEvent") -> None:
+        """
+        Handles the order event by either updating the status of an existing order
+        or inserting a new order into the order diary.
+        Args:
+            order (OrderEvent): The order event containing order details.
+        Returns:
+            None
+        """
+
+        existing_order = next(
+            (
+                O
+                for O in self.order_diary
+                if O.OrderUniqueIdentifier == order.OrderUniqueIdentifier
+            ),
+            None,
+        )
+
+        if existing_order:
+            # Update the status of the existing order
+            existing_order.OrderStatus = order.OrderStatus
+            if self.interactiveEngine.user_logger:
+                self.interactiveEngine.user_logger.info(
+                    f"Updated order {order.OrderUniqueIdentifier} status to {order.OrderStatus}",
+                    caller=f"{self.__class__.__name__}.order_",
+                )
+        else:
+            # Insert the new order by creating an object
+            new_order = Order(
+                order.OrderUniqueIdentifier, order.AppOrderID, order.OrderStatus
+            )
+            self.order_diary.append(new_order)
+            if self.interactiveEngine.user_logger:
+                self.interactiveEngine.user_logger.info(
+                    f"Inserted new order {order.OrderUniqueIdentifier} with status {order.OrderStatus}",
+                    caller=f"{self.__class__.__name__}.order_",
+                )
+        asyncio.ensure_future(self.on_orderEvent(order))
+
+    @abstractmethod
+    async def on_orderEvent(self, message: "OrderEvent") -> None:
+        """
+        On Order Event for strategy.
+        """
+        ...
+
+    async def trade_(self, trade: "TradeEvent") -> None:
+        """
+        Handles a trade event by updating the position diary and triggering the on_tradeEvent callback.
+        Args:
+            trade (TradeEvent): The trade event to be processed.
+        Returns:
+            None
+        The method performs the following steps:
+        1. Checks if the trade exists in the position diary.
+        2. Updates the position if it exists, otherwise inserts a new position.
+        3. Logs the update or insertion of the position.
+        4. Ensures the on_tradeEvent callback is called asynchronously.
+        """
+
+        # Check if the trade exists in the position diary
+        existing_position = next(
+            (
+                _
+                for _ in self.position_diary
+                if _.ExchangeSegment == trade.ExchangeSegment
+                and _.ExchangeInstrumentID == trade.ExchangeInstrumentID
+                and _.ProductType == trade.ProductType
+            ),
+            None,
+        )
+        # Update the position
+        _quantity = (1 if trade.OrderSide == "Buy" else -1) * trade.OrderQuantity
+        if existing_position:
+            existing_position.Quantity += _quantity
+            if self.interactiveEngine.user_logger:
+                self.interactiveEngine.user_logger.info(
+                    f"Updated position for trade {trade.ExchangeInstrumentID}: {existing_position.Quantity}",
+                    caller=f"{self.__class__.__name__}.trade_",
+                )
+        else:
+            new_position = Position(
+                trade.ExchangeSegment,
+                trade.ExchangeInstrumentID,
+                trade.ProductType,
+                _quantity,
+            )
+            self.position_diary.append(new_position)
+            if self.interactiveEngine.user_logger:
+                self.interactiveEngine.user_logger.info(
+                    f"Inserted new position {trade.ExchangeInstrumentID} with quantity {new_position.Quantity}",
+                    caller=f"{self.__class__.__name__}.trade_",
+                )
+        asyncio.ensure_future(self.on_tradeEvent(trade))
+
+    @abstractmethod
+    def on_tradeEvent(self, message: "TradeEvent") -> None:
+        """
+        On trade Event for strategy.
+        """
+        ...
+
+    @abstractmethod
+    async def unsubscribe(self) -> None:
+        """
+        Abstract method (virtual function) to handle unsubscription logic.
+        Must be implemented by subclasses.
+        """
+        ...
+
+    @abstractmethod
+    async def initialize(self) -> None:
+        """
+        Initialize the strategy.
+        This function is intended to be a one-time asynchronous setup function for the strategy.
+        It can be used to perform any necessary initialization tasks, such as scheduling jobs with APScheduler.
+        """
+        # Perform initialization tasks here
+        ...
+
+    @abstractmethod
+    async def deinitialize(self) -> None:
+        """
+        Deinitialize the strategy.
+        This function is intended to be a one-time asynchronous teardown function for the strategy.
+        It can be used to perform any necessary cleanup tasks, such as unscheduling jobs with APScheduler.
+        """
+        # Perform deinitialization tasks here
+        ...
+
+    async def liquidateIntraday(self) -> None:
+        """
+        Asynchronously liquidates all intraday positions and cancels pending orders.
+        This method iterates through the order diary and cancels any orders that are
+        in the "PendingNew" or "New" status. It also iterates through the position
+        diary and places market orders to liquidate any positions with a non-zero
+        quantity.
+        Returns:
+            None
+        """
+        if self.interactiveEngine.user_logger:
+            self.interactiveEngine.user_logger.info(
+                f"Cancel open order and square off position for strategy {self.name}",
+                caller=f"{self.__class__.__name__}.liquidateIntraday",
+            )
+
+        for order in self.order_diary:
+            if order.OrderStatus in ["PendingNew", "New"]:
+                asyncio.ensure_future(
+                    self.interactiveEngine.cancel_order(
+                        order.AppOrderID, order.OrderUniqueIdentifier
+                    )
+                )
+        for position in self.position_diary:
+            if position.Quantity != 0:
+                _order_no = self.order_no()
+                asyncio.ensure_future(
+                    self.interactiveEngine.market_order(
+                        position.ExchangeSegment,
+                        position.ExchangeInstrumentID,
+                        position.ProductType,
+                        -1 * position.Quantity,
+                        _order_no,
+                    )
+                )
+
+    def isInvested(self) -> bool:
+        """
+        Asynchronously checks if there are any investments by summing the quantities
+        of all positions in the position diary.
+        Returns:
+            bool: True if the total quantity is not zero, indicating that there are
+            investments. False otherwise.
+        """
+
+        qty = 0
+        for position in self.position_diary:
+            qty += position.Quantity
+        return qty != 0
+
+    async def liquidateIntradayDummy(self) -> None:
+
+        if self.interactiveEngine.user_logger:
+            self.interactiveEngine.user_logger.info(
+                f"Cancel open order and square off position for strategy {self.name}",
+                caller=f"{self.__class__.__name__}.liquidateIntraday",
+            )
+
+        # for order in self.order_diary:
+        #     if order.OrderStatus in ["PendingNew", "New"]:
+        #         asyncio.ensure_future(
+        #             self.interactiveEngine.cancel_order(
+        #                 order.AppOrderID, order.OrderUniqueIdentifier
+        #             )
+        #         )
+        for position in self.position_diary:
+            if position.Quantity != 0:
+                _order_no = self.order_no()
+                asyncio.ensure_future(
+                    self.marketDataEngine.dummy_order(
+                        position.ExchangeSegment,
+                        position.ExchangeInstrumentID,
+                        position.ProductType,
+                        -1 * position.Quantity,
+                        _order_no,
+                        self,
+                    )
+                )

tradx/baseClass/candleData.py

@@ -0,0 +1,89 @@
+from pydantic import BaseModel
+from decimal import Decimal
+from datetime import datetime, timezone
+import json
+from typing import Dict, Any
+
+
+class CandleData(BaseModel):
+    """
+    CandleData model representing candlestick data for trading.
+
+    Attributes:
+        MessageCode (int): The message code.
+        MessageVersion (int): The version of the message.
+        ApplicationType (int): The type of application.
+        TokenID (int): The token ID.
+        ExchangeSegment (int): The exchange segment.
+        BarTime (datetime): The time of the bar.
+        BarVolume (Decimal): The volume of the bar.
+        OpenInterest (Decimal): The open interest.
+        SumOfQtyInToPrice (Decimal): The sum of quantity into price.
+        ExchangeInstrumentID (int): The exchange instrument ID.
+        Open (Decimal): The opening price.
+        High (Decimal): The highest price.
+        Low (Decimal): The lowest price.
+        Close (Decimal): The closing price.
+    Methods:
+        from_string(cls, message: str):
+            Creates an instance of CandleData from a JSON string.
+        __getitem__(self, item):
+            Allows access to specific attributes using dictionary-like indexing.
+        __str__(self):
+            Returns a JSON string representation of the instance with selected attributes.
+    """
+
+    MessageCode: int
+    MessageVersion: int
+    ApplicationType: int
+    TokenID: int
+    ExchangeSegment: int
+    BarTime: int
+    BarVolume: Decimal
+    OpenInterest: Decimal
+    SumOfQtyInToPrice: Decimal
+    ExchangeInstrumentID: int
+    BarTime: datetime
+    Open: Decimal
+    High: Decimal
+    Low: Decimal
+    Close: Decimal
+
+    def __init__(self, input_data: Any):
+        if isinstance(input_data, dict):
+            input_data["BarTime"] = datetime.fromtimestamp(
+                input_data["BarTime"], timezone.utc
+            )
+            super().__init__(**input_data)
+        elif isinstance(input_data, str):
+            data = json.loads(input_data)
+            data["BarTime"] = datetime.fromtimestamp(data["BarTime"], timezone.utc)
+            super().__init__(**data)
+        else:
+            raise ValueError("Unsupported input type for CandleData")
+
+    def __getitem__(self, item):
+        allowed_keys = {
+            "High",
+            "Low",
+            "Open",
+            "Close",
+            "ExchangeInstrumentID",
+            "BarTime",
+            "Volume",
+        }
+        if item in allowed_keys:
+            return getattr(self, item)
+
+    def __str__(self):
+        allowed_keys = {
+            "High",
+            "Low",
+            "Open",
+            "Close",
+            "ExchangeInstrumentID",
+            "BarTime",
+            "BarVolume",
+        }
+        filtered_data = {key: getattr(self, key) for key in allowed_keys}
+        return json.dumps(filtered_data, default=str, indent=4)

tradx/baseClass/cmInstrument.py

@@ -0,0 +1,84 @@
+from decimal import Decimal
+from pydantic import BaseModel
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pandas.core.series import Series
+
+
+class CMInstrument(BaseModel):
+    ExchangeSegment: str
+    ExchangeInstrumentID: int
+    InstrumentType: int
+    Name: str
+    Description: str
+    Series: str
+    NameWithSeries: str
+    InstrumentID: int
+    PriceBand_High: Decimal
+    PriceBand_Low: Decimal
+    FreezeQty: int
+    TickSize: Decimal
+    LotSize: int
+    Multiplier: Decimal
+    DisplayName: str
+    ISIN: str
+    PriceNumerator: int
+    PriceDenominator: int
+    DetailedDescription: str
+    ExtendedSurvlndicator: int
+    Cautionlndicator: int
+    GSMIndicator: int
+
+    def __init__(
+        self,
+        ExchangeSegment: str,
+        ExchangeInstrumentID: int,
+        InstrumentType: int,
+        Name: str,
+        Description: str,
+        Series: str,
+        NameWithSeries: str,
+        InstrumentID: int,
+        PriceBand_High: Decimal,
+        PriceBand_Low: Decimal,
+        FreezeQty: int,
+        TickSize: Decimal,
+        LotSize: int,
+        Multiplier: Decimal,
+        DisplayName: str,
+        ISIN: str,
+        PriceNumerator: int,
+        PriceDenominator: int,
+        DetailedDescription: str,
+        ExtendedSurvlndicator: int,
+        Cautionlndicator: int,
+        GSMIndicator: int,
+    ):
+        super().__init__(
+            ExchangeSegment=ExchangeSegment,
+            ExchangeInstrumentID=ExchangeInstrumentID,
+            InstrumentType=InstrumentType,
+            Name=Name,
+            Description=Description,
+            Series=Series,
+            NameWithSeries=NameWithSeries,
+            InstrumentID=InstrumentID,
+            PriceBand_High=PriceBand_High,
+            PriceBand_Low=PriceBand_Low,
+            FreezeQty=FreezeQty,
+            TickSize=TickSize,
+            LotSize=LotSize,
+            Multiplier=Multiplier,
+            DisplayName=DisplayName,
+            ISIN=ISIN,
+            PriceNumerator=PriceNumerator,
+            PriceDenominator=PriceDenominator,
+            DetailedDescription=DetailedDescription,
+            ExtendedSurvlndicator=ExtendedSurvlndicator,
+            Cautionlndicator=Cautionlndicator,
+            GSMIndicator=GSMIndicator,
+        )
+
+    def __init__(self, df: "Series"):
+        super().__init__(**df)

tradx/baseClass/futureInstrument.py

@@ -0,0 +1,74 @@
+from decimal import Decimal
+from pydantic import BaseModel
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pandas.core.series import Series
+
+class FutureInstrument(BaseModel):
+    ExchangeSegment: str
+    ExchangeInstrumentID: int
+    InstrumentType: int
+    Name: str
+    Description: str
+    Series: str
+    NameWithSeries: str
+    InstrumentID: int
+    PriceBand_High: Decimal
+    PriceBand_Low: Decimal
+    FreezeQty: int
+    TickSize: Decimal
+    LotSize: int
+    Multiplier: Decimal
+    ContractExpiration: datetime
+    DisplayName: str
+    PriceNumerator: int
+    PriceDenominator: int
+    DetailedDescription: str
+
+    def __init__(
+        self,
+        ExchangeSegment: str,
+        ExchangeInstrumentID: int,
+        InstrumentType: int,
+        Name: str,
+        Description: str,
+        Series: str,
+        NameWithSeries: str,
+        InstrumentID: int,
+        PriceBand_High: Decimal,
+        PriceBand_Low: Decimal,
+        FreezeQty: int,
+        TickSize: Decimal,
+        LotSize: int,
+        Multiplier: Decimal,
+        ContractExpiration: datetime,
+        DisplayName: str,
+        PriceNumerator: int,
+        PriceDenominator: int,
+        DetailedDescription: str,
+    ):
+        super().__init__(
+            ExchangeSegment=ExchangeSegment,
+            ExchangeInstrumentID=ExchangeInstrumentID,
+            InstrumentType=InstrumentType,
+            Name=Name,
+            Description=Description,
+            Series=Series,
+            NameWithSeries=NameWithSeries,
+            InstrumentID=InstrumentID,
+            PriceBand_High=PriceBand_High,
+            PriceBand_Low=PriceBand_Low,
+            FreezeQty=FreezeQty,
+            TickSize=TickSize,
+            LotSize=LotSize,
+            Multiplier=Multiplier,
+            ContractExpiration=ContractExpiration,
+            DisplayName=DisplayName,
+            PriceNumerator=PriceNumerator,
+            PriceDenominator=PriceDenominator,
+            DetailedDescription=DetailedDescription,
+        )
+    def __init__(self, df: "Series"):
+                super().__init__(**df)