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

tradx/interactiveEngine.py

@@ -1,18 +1,24 @@
+# Importing from xts_api_client
 from xts_api_client.xts_connect_async import XTSConnect
 from xts_api_client.interactive_socket_client import InteractiveSocketClient
 from xts_api_client.interactive_socket import OrderSocket_io
-from decimal import Decimal
-from typing import Dict, Any
-import asyncio
-import shortuuid
+
+# Importing from self module
 from tradx.logger.logger import *
 from tradx.baseClass.baseAlgo import BaseAlgo as bA
-from tradx.baseClass.orderEvent import OrderEvent
-from tradx.baseClass.positionEvent import PositionEvent
-from tradx.baseClass.tradeEvent import TradeEvent
-from tradx.baseClass.tradeConversionEvent import TradeConversionEvent
+from tradx.baseClass.interactive.orderEvent import OrderEvent
+from tradx.baseClass.interactive.positionEvent import PositionEvent
+from tradx.baseClass.interactive.tradeEvent import TradeEvent
+from tradx.baseClass.interactive.tradeConversionEvent import TradeConversionEvent
+
+# Importing other python module
 from datetime import datetime
 import os
+from decimal import Decimal
+from typing import Dict, Any
+import asyncio
+import shortuuid
+
 
 class interactiveEngine(InteractiveSocketClient):
     """
@@ -89,15 +95,17 @@ class interactiveEngine(InteractiveSocketClient):
         self.shortuuid: shortuuid = shortuuid
         self.set_interactiveToken: str = None
         self.set_iuserID: str = None
+        self.set_isInvestorClient: str = None
         self.funds: int = None
         self.strategy_to_id: Dict[str, bA] = {}
         self.position_diary_engine = {}
         self.isConnected: bool = False
+        self.isLive: bool = False
         self.user_logger = user_logger
         if user_logger:
             self.user_logger.info(
                 "Interactive Engine Object initialized.",
-                caller="interactiveEngine.__init__",
+                caller=f"{self.set_iuserID}.__init__",
             )
 
     async def market_order(
@@ -126,9 +134,9 @@ class interactiveEngine(InteractiveSocketClient):
             - The disclosed quantity, limit price, and stop price are set to 0.
             - Logs the response if user_logger is available.
         """
-        assert (
-            self.isConnected is True
-        ), f"Interactive Engine is not connected, Rejecting order with orderID: {orderUniqueIdentifier}."
+        # assert (
+        #     self.isConnected is True
+        # ), f"Interactive Engine is not connected, Rejecting order with orderID: {orderUniqueIdentifier}."
         allowed_exchange_segments = [
             XTSConnect.EXCHANGE_NSECM,
             XTSConnect.EXCHANGE_BSECM,
@@ -171,7 +179,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Place Order: {response}",
-                caller="interactiveEngine.market_order",
+                caller=f"{self.set_iuserID}.market_order",
             )
 
     async def stop_market_order(
@@ -248,7 +256,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Place Order: {response}",
-                caller="interactiveEngine.stop_market_order",
+                caller=f"{self.set_iuserID}.stop_market_order",
             )
 
     async def limit_order(
@@ -312,7 +320,7 @@ class interactiveEngine(InteractiveSocketClient):
             timeInForce=self.xt.TimeinForce_DAY,
             disclosedQuantity=0,
             orderQuantity=abs(orderQuantity),
-            limitPrice=limitPrice,
+            limitPrice=limitPrice.to_eng_string(),
             stopPrice=0,
             orderUniqueIdentifier=orderUniqueIdentifier,
             clientID=self.set_iuserID,
@@ -320,7 +328,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Place Order: {response}",
-                caller="interactiveEngine.limit_order",
+                caller=f"{self.set_iuserID}.limit_order",
             )
 
     async def stop_limit_order(
@@ -408,7 +416,35 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Place Order: {response}",
-                caller="interactiveEngine.stop_limit_order",
+                caller=f"{self.set_iuserID}.stop_limit_order",
+            )
+
+    async def modify_order(
+        self,
+        appOrderID: int,
+        modifiedProductType: str,
+        modifiedOrderType: str,
+        modifiedOrderQuantity: int,
+        modifiedLimitPrice: Decimal,
+        modifiedStopPrice: Decimal,
+        orderUniqueIdentifier: str,
+    ):
+        response = await self.xt.modify_order(
+            appOrderID=appOrderID,
+            modifiedProductType=modifiedProductType,
+            modifiedOrderType=modifiedOrderType,
+            modifiedOrderQuantity=modifiedOrderQuantity,
+            modifiedDisclosedQuantity=0,
+            modifiedLimitPrice=modifiedLimitPrice.to_eng_string(),
+            modifiedStopPrice=modifiedStopPrice.to_eng_string(),
+            modifiedTimeInForce=self.xt.TimeinForce_DAY,
+            orderUniqueIdentifier=orderUniqueIdentifier,
+            clientID=self.set_iuserID,
+        )
+        if self.user_logger:
+            self.user_logger.info(
+                f"Modified Order: {response}",
+                caller=f"{self.set_iuserID}.modify_order",
             )
 
     async def initialize(self) -> None:
@@ -424,6 +460,55 @@ class interactiveEngine(InteractiveSocketClient):
         await self.login()
         await self.getBalance()
 
+    async def initializeClient(self, response: dict) -> None:
+        """
+        Initializes the trading client using an explicitly supplied login response.
+
+        This method connects the trading socket (`XTSConnect`) using the provided
+        API credentials and sets common session variables such as token, user ID,
+        and investor client status. It is intended to be called when the login
+        response has already been obtained externally (for example, from `login()`
+        or shared from another session).
+
+        Args:
+            response (dict): A dictionary containing login information with keys:
+                - "token" (str): The session token for authentication.
+                - "userID" (str): The user identifier.
+                - "isInvestorClient" (bool): Whether the client is an investor.
+
+        Returns:
+            None
+
+        Raises:
+            KeyError: If required keys are missing from the response dictionary.
+            Exception: If initialization of XTSConnect fails.
+
+        Example:
+            ```
+            # Using external login response
+            login_response = {
+                "token": "abc123token",
+                "userID": "USER001", 
+                "isInvestorClient": True
+            }
+            await interactive_engine.initializeClient(login_response)
+            ```
+
+        Note:
+            - This method sets `isConnected = True` immediately upon initialization
+            - The socket connection is not established in this method
+            - Use `initialize()` for complete setup including login and socket connection
+            - Useful for shared sessions or when login is handled by external systems
+        """
+        self.xt = XTSConnect(
+            self._api_key, self._api_password, self._source, self._root
+        )
+        self.isConnected = True
+        self.xt._set_common_variables(
+            response["token"], response["userID"], response["isInvestorClient"]
+        )
+        print("Intialized interactive client.")
+
     async def on_order(self, message: str) -> None:
         """
         Handles incoming order messages.
@@ -444,7 +529,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 __,
-                caller="interactiveEngine.on_order",
+                caller=f"{self.set_iuserID}.on_order",
             )
 
     async def on_connect(self) -> None:
@@ -459,7 +544,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 "Interactive socket connected successfully!",
-                caller="interactiveEngine.on_connect",
+                caller=f"{self.set_iuserID}.on_connect",
             )
 
     async def on_message(self, xts_message: Any) -> None:
@@ -475,7 +560,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Received a message: {xts_message}",
-                caller="interactiveEngine.on_message",
+                caller=f"{self.set_iuserID}.on_message",
             )
 
     async def on_error(self, xts_message: Any) -> None:
@@ -488,7 +573,8 @@ class interactiveEngine(InteractiveSocketClient):
         """
         if self.user_logger:
             self.user_logger.error(
-                f"Received a error: {xts_message}", caller="interactiveEngine.on_error"
+                f"Received a error: {xts_message}",
+                caller=f"{self.set_iuserID}.on_error",
             )
 
     async def on_joined(self, data: Any) -> None:
@@ -503,7 +589,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Interactive socket joined successfully! {data}",
-                caller="interactiveEngine.on_joined",
+                caller=f"{self.set_iuserID}.on_joined",
             )
 
     async def on_messagelogout(self, data: Any) -> None:
@@ -518,9 +604,49 @@ class interactiveEngine(InteractiveSocketClient):
         """
         if self.user_logger:
             self.user_logger.info(
-                f"logged out! {data}", caller="interactiveEngine.on_messagelogout"
+                f"logged out! {data}", caller=f"{self.set_iuserID}.on_messagelogout"
             )
+
     async def reconnect(self):
+        """
+        Attempts to reconnect the interactive trading socket after a disconnection.
+
+        This method recreates the OrderSocket_io connection using existing session
+        credentials (token and user ID) without performing a new login. It is typically
+        called automatically by the `on_disconnect()` event handler during market hours
+        to restore trading connectivity.
+
+        Process:
+            1. Reinitializes the OrderSocket_io object with existing session credentials
+            2. Attempts to establish the socket connection
+            3. Logs the reconnection attempt status
+            4. Handles any connection errors gracefully
+
+        Raises:
+            Exception: If socket initialization or connection fails. The exception
+                    is logged but not re-raised to allow retry attempts.
+
+        Returns:
+            None
+
+        Notes:
+            - Uses existing session token (`self.set_interactiveToken`) and user ID
+            - Does not perform a new API login, assumes existing session is valid
+            - Called automatically during market hours when `isLive = True`
+            - Logs both successful reconnection and any errors encountered
+            - Does not update `self.isConnected` flag (handled by socket events)
+
+        Example:
+            ```
+            # Automatic reconnection in on_disconnect()
+            if current_time < market_close_time and self.isLive:
+                await self.reconnect()
+            ```
+            See Also:
+            - `on_disconnect()`: Main disconnection handler that calls this method
+            - `login()`: Initial login and connection establishment
+            - `on_connect()`: Event handler for successful connections
+    """
         try:
             # Initialize and connect OrderSocket_io object
             self.socket = OrderSocket_io(
@@ -532,14 +658,15 @@ class interactiveEngine(InteractiveSocketClient):
             # Log successful login
             if self.user_logger:
                 self.user_logger.info(
-                    f"Login successful.", caller="interactiveEngine.reconnect"
+                    f"Login successful.", caller=f"{self.set_iuserID}.reconnect"
                 )
 
             await self.socket.connect()
-        
+
         except Exception as e:
             if self.user_logger:
-                self.user_logger.error(e, caller="interactiveEngine.reconnect")
+                self.user_logger.error(e, caller=f"{self.set_iuserID}.reconnect")
+
     async def on_disconnect(self) -> None:
         """
         Callback for handling disconnection events.
@@ -552,39 +679,47 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 "Interactive Socket disconnected!",
-                caller="interactiveEngine.on_disconnect",
+                caller=f"{self.set_iuserID}.on_disconnect",
             )
         current_time = datetime.now().time()
         cnt: int = 0
-        if current_time < datetime.strptime("15:20", "%H:%M").time():
-            while not self.isConnected and cnt < 8:
-                print("Attempting to reconnect as the time is before 3:20 PM and isConnected is False for interactive Socket.")
+        if current_time < datetime.strptime("15:30", "%H:%M").time():
+            while not self.isConnected and self.isLive:
+                print(
+                    "Attempting to reconnect as the time is before 3:30 PM and isConnected is False for interactive Socket."
+                )
                 if self.user_logger:
                     self.user_logger.info(
-                        "Attempting to reconnect as the time is before 3:20 PM and isConnected is False.",
-                        caller="interactiveEngine.on_disconnect",
+                        "Attempting to reconnect as the time is before 3:30 PM and isConnected is False.",
+                        caller=f"{self.set_iuserID}.on_disconnect",
                     )
                 await self.reconnect()
                 await asyncio.sleep(3)
                 cnt += 1
                 if not self.isConnected and self.user_logger:
-                    print( f"Reconnection attempt {cnt} failed for interactive socket. Retrying...")
+                    print(
+                        f"Reconnection attempt {cnt} failed for interactive socket. Retrying..."
+                    )
                     self.user_logger.warning(
                         f"Reconnection attempt {cnt} failed. Retrying...",
-                        caller="interactiveEngine.on_disconnect",
+                        caller=f"{self.set_iuserID}.on_disconnect",
                     )
+
+        """
         if cnt >= 8:
             if self.user_logger:
                 self.user_logger.error(
                     f"Reconnection attempts failed. Please check the network connection.",
-                    caller="interactiveEngine.on_disconnect",
+                    caller=f"{self.set_iuserID}.on_disconnect",
                 )
-            print("Interactive Socket reconnection failed, emergency square off triggered.")
+            print(
+                "Interactive Socket reconnection failed, emergency square off triggered."
+            )
             # Log the initiation of the liquidation process
             if self.user_logger:
                 self.user_logger.info(
                     f"Socket Disconnected, emergency square off triggered.",
-                    caller="interactiveEngine.on_disconnect",
+                    caller=f"{self.set_iuserID}.on_disconnect",
                 )
 
             # Retrieve day-wise positions
@@ -620,7 +755,7 @@ class interactiveEngine(InteractiveSocketClient):
                         lambda future: (
                             self.user_logger.info(
                                 f"Place Order: {future.result()}",
-                                caller="interactiveEngine.on_disconnect",
+                                caller=f"{self.set_iuserID}.on_disconnect",
                             )
                             if self.user_logger
                             else None
@@ -636,14 +771,14 @@ class interactiveEngine(InteractiveSocketClient):
                     lambda future: (
                         self.user_logger.info(
                             f"Cancel Order: {future.result()}",
-                            caller="interactiveEngine.Liquidate",
+                            caller=f"{self.set_iuserID}.Liquidate",
                         )
                         if self.user_logger
                         else None
                     )
                 )
             os._exit(0)
- 
+        """
 
     async def on_trade(self, xts_message: str) -> None:
         """
@@ -664,7 +799,7 @@ class interactiveEngine(InteractiveSocketClient):
         __ = TradeEvent(xts_message)
         if self.user_logger:
             self.user_logger.info(
-                f"Received a trade: {__}", caller="interactiveEngine.on_trade"
+                f"Received a trade: {__}", caller=f"{self.set_iuserID}.on_trade"
             )
         if __.OrderUniqueIdentifier != "Liquidated":
             strategy_id = __.OrderUniqueIdentifier[:4]
@@ -680,13 +815,16 @@ class interactiveEngine(InteractiveSocketClient):
         Returns:
             None
         """
-
-        __ = PositionEvent(xts_message)
-        if self.user_logger:
-            self.user_logger.info(
-                f"Received a position: {__}",
-                caller="interactiveEngine.on_position",
-            )
+        print(f"Position Event received with message: {xts_message}")
+        try:
+            __ = PositionEvent(xts_message)
+            if self.user_logger:
+                self.user_logger.info(
+                    f"Received a position: {__}",
+                    caller=f"{self.set_iuserID}.on_position",
+                )
+        except Exception as e:
+            print(f"Error in position event {xts_message}: {e}")
         """Update Interactive Engine Position Diary."""
         # ExchangeInstrumentID = int(on_position["ExchangeInstrumentID"])
         # if ExchangeInstrumentID not in self.position_diary_engine:
@@ -710,7 +848,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Received a trade conversion: {__}",
-                caller="interactiveEngine.on_tradeconversion",
+                caller=f"{self.set_iuserID}.on_tradeconversion",
             )
 
     async def login(self) -> None:
@@ -738,13 +876,14 @@ class interactiveEngine(InteractiveSocketClient):
 
             # Perform interactive login
             response = await self.xt.interactive_login()
+
             self.set_interactiveToken = response["result"]["token"]
             self.set_iuserID = response["result"]["userID"]
-
+            self.set_isInvestorClient = response["result"]["isInvestorClient"]
             # Log successful login
             if self.user_logger:
                 self.user_logger.info(
-                    f"Login successful.", caller="interactiveEngine.login"
+                    f"Login successful.", caller=f"{self.set_iuserID}.login"
                 )
 
             # Initialize and connect OrderSocket_io object
@@ -760,7 +899,7 @@ class interactiveEngine(InteractiveSocketClient):
         except Exception as e:
             # Log and re-raise any exceptions
             if self.user_logger:
-                self.user_logger.error(e, caller="interactiveEngine.login")
+                self.user_logger.error(e, caller=f"{self.set_iuserID}.login")
             raise (e)
 
     async def shutdown(self) -> None:
@@ -782,7 +921,7 @@ class interactiveEngine(InteractiveSocketClient):
             # Log the start of the shutdown process
             if self.user_logger:
                 self.user_logger.info(
-                    "Entering shut down mode.", caller="interactiveEngine.shutdown"
+                    "Entering shut down mode.", caller=f"{self.set_iuserID}.shutdown"
                 )
 
             # Disconnect the socket connection
@@ -795,13 +934,13 @@ class interactiveEngine(InteractiveSocketClient):
             if self.user_logger:
                 self.user_logger.info(
                     f"Logged Out.",
-                    caller="interactiveEngine.shutdown",
+                    caller=f"{self.set_iuserID}.shutdown",
                 )
 
         except Exception as e:
             # Log and re-raise any exceptions
             if self.user_logger:
-                self.user_logger.error(e, caller="interactiveEngine.shutdown")
+                self.user_logger.error(e, caller=f"{self.set_iuserID}.shutdown")
             raise (e)
 
     async def getBalance(self) -> int:
@@ -849,7 +988,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Cancel open order and square off position for {exchangeSegment}",
-                caller="interactiveEngine.Liquidate",
+                caller=f"{self.set_iuserID}.Liquidate",
             )
 
         # Cancel all open orders for the specified exchange segment
@@ -859,7 +998,7 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 response,
-                caller="interactiveEngine.Liquidate",
+                caller=f"{self.set_iuserID}.Liquidate",
             )
 
         # Retrieve day-wise positions
@@ -900,5 +1039,5 @@ class interactiveEngine(InteractiveSocketClient):
         if self.user_logger:
             self.user_logger.info(
                 f"Cancel Order: {response}",
-                caller="interactiveEngine.cancel_order",
+                caller=f"{self.set_iuserID}.cancel_order",
             )