bw-essentials-core 0.1.5__py3-none-any.whl → 0.1.33__py3-none-any.whl

bw_essentials/services/trade_placement.py

@@ -53,6 +53,7 @@ class TradePlacement(ApiClient):
 
     EXECUTABLE = 'executable'
     READY_ONLY = 'read_only'
+    PUBLISHER = 'publisher'
     BROKER_CONFIG_MAPPER = {
         DEALER: READY_ONLY,
         USER: EXECUTABLE
@@ -78,7 +79,8 @@ class TradePlacement(ApiClient):
         self.name = Services.TRADE_PLACEMENT.value
         self.urls = {
             "order": "orders/order",
-            "update_orders": "orders/order/update"
+            "update_orders": "orders/order/update",
+            "update_order_status": "orders/order/status/update"
         }
         if self.user_info.get("broker_name") in [self.PAPER_TRADE]:
             self._authenticate()
@@ -146,8 +148,8 @@ class TradePlacement(ApiClient):
             }
         }
 
-    def _place_order(self, trading_symbol, qty, side, order_tag, meta_data, product, order_type, proxy=None,
-                     asm_consent=None, asm_reason=None):
+    def _place_order(self, trading_symbol, qty, side, order_tag, price, meta_data, product, order_type, proxy=None,
+                     asm_consent=None, asm_reason=None, publisher=False):
         """
         Places an order with the provided metadata and order details.
 
@@ -156,6 +158,7 @@ class TradePlacement(ApiClient):
             qty (int): Quantity to trade.
             side (str): Order side ('buy' or 'sell').
             order_tag (str): Identifier tag for the order.
+            price (float): Price of the order.
             meta_data (dict): Metadata about the order context.
             product (str): Type of product ('cnc' or 'mtf').
             order_type (str): Type of order ('market', 'limit').
@@ -171,15 +174,16 @@ class TradePlacement(ApiClient):
         broker_config = self.EXECUTABLE
         if proxy == self.READY_ONLY:
             broker_config = self.READY_ONLY
-
-        payload = json.dumps({
+        if publisher:
+            broker_config = self.PUBLISHER
+        payload = {
             "user_id": self.user_info.get("user_id"),
             "entity_id": self.user_info.get("entity_id"),
             "symbol": trading_symbol,
             "quantity": abs(qty),
             "broker": self.user_info.get("broker_name"),
             "broker_config": broker_config,
-            "price": 0,
+            "price": price,
             "product_type": product,
             "order_type": order_type,
             "side": side,
@@ -187,10 +191,10 @@ class TradePlacement(ApiClient):
             "metadata": meta_data,
             "asm_consent": asm_consent,
             "asm_reason": asm_reason
-        })
+        }
         placed_orders_data = self._post(url=self.base_url,
                                         endpoint=self.urls.get("order"),
-                                        data=payload)
+                                        json=payload)
         return placed_orders_data.get("data")
 
     def _market_buy_cnc(self, trading_symbol, qty, generate_order_tag,
@@ -494,6 +498,255 @@ class TradePlacement(ApiClient):
             response = self._put(
                 url=self.base_url,
                 endpoint=f'{self.urls.get("update_orders")}/{tag}',
-                data=json.dumps(instruction)
+                json=instruction
             )
         return response
+
+    def update_order_status(self, broker_config, product_type, tag):
+        """
+        Update the status of an existing order.
+
+        This method sends a PUT request to the Trade Placement Service to update
+        the status of a specific order identified by its tag. The update includes
+        user, broker, and product configuration details.
+
+        Endpoint:
+            PUT /orders/order/status/update
+
+        Args:
+            broker_config (str): Broker configuration (e.g., 'publisher', 'executable').
+            product_type (str): Type of product (e.g., 'fno', 'cnc', 'mtf').
+            tag (str): Unique tag identifying the order.
+
+        Returns:
+            dict: API response from the Trade Placement Service.
+
+        Raises:
+            HTTPError: If the PUT request fails.
+        """
+        logger.info(f"Updating order status for {tag =}, {self.broker =}, {product_type =}")
+
+        if not self.user_id or not self.entity_id:
+            raise ValueError("user_id and entity_id must be set to update order status.")
+
+        payload = {
+            "user_id": self.user_id,
+            "entity_id": self.entity_id,
+            "broker": self.broker,
+            "broker_config": broker_config,
+            "product_type": product_type,
+            "tag": tag
+        }
+
+        response = self._put(
+            url=self.base_url,
+            endpoint=self.urls.get("update_order_status"),
+            json=payload
+        )
+
+        logger.info(f"Order status update response: {response}")
+        return response
+
+    def _get_fno_metadata(self):
+        """
+        Build metadata dictionary for FNO order.
+        Returns:
+            dict: Metadata for FNO order.
+        """
+        user_info = self.user_info or {}
+        return {
+            "user_id": user_info.get("user_id"),
+            "date": str(datetime.now().date()),
+            "user_info": {
+                "current_broker": user_info.get("current_broker"),
+                "broker_name": user_info.get("broker_name"),
+                "entity_id": user_info.get("entity_id")
+            }
+        }
+
+    def _market_buy_fno(self, trading_symbol, qty, generate_order_tag, price, publisher, proxy=None):
+        """
+        Places a market buy order for FNO.
+
+        Args:
+            trading_symbol (str): Symbol to buy.
+            qty (int): Quantity to buy.
+            generate_order_tag (str): Order tag.
+            proxy (str, optional): Proxy config.
+
+        Returns:
+            dict: Order response data.
+        """
+        logger.info(f"Placing FNO market buy order for {trading_symbol=}, {qty=}")
+        meta_data = self._get_fno_metadata()
+        return self._place_order(trading_symbol, qty, self.BUY, generate_order_tag, price,
+                                 meta_data, "fno", self.MARKET, proxy=proxy, publisher=publisher)
+
+    def _market_sell_fno(self, trading_symbol, qty, generate_order_tag, price, publisher, proxy=None):
+        """
+        Places a market sell order for FNO.
+
+        Args:
+            trading_symbol (str): Symbol to sell.
+            qty (int): Quantity to sell.
+            generate_order_tag (str): Order tag.
+            price (float): Price of the order.
+            publisher (bool): Whether to use publisher config. Defaults to False.
+            proxy (str, optional): Proxy config.
+
+        Returns:
+            dict: Order response data.
+        """
+        logger.info(f"Placing FNO market sell order for {trading_symbol=}, {qty=}")
+        meta_data = self._get_fno_metadata()
+        return self._place_order(trading_symbol, qty, self.SELL, generate_order_tag, price,
+                                 meta_data, "fno", self.MARKET, proxy=proxy, publisher=publisher)
+
+    def execute_market_buy_orders_fno(self, instructions, publisher):
+        """
+        Execute FNO Market buy orders in bulk.
+
+        Args:
+            instructions (list): List of buy order dicts (symbol, qty, tag, instruction_id).
+            publisher (bool): Whether to use publisher config. Defaults to False.
+
+        Returns:
+            None
+        """
+        logger.info(f"In execute_market_buy_orders_fno - {instructions =}")
+        for order in instructions:
+            data = self._market_buy_fno(
+                trading_symbol=order.get("symbol"),
+                qty=order.get("qty"),
+                generate_order_tag=order.get("tag"),
+                price=order.get("price"),
+                publisher=publisher
+            )
+            logger.info(f"execute_market_buy_orders_fno {data = }")
+
+    def execute_market_sell_orders_fno(self, instructions, publisher):
+        """
+        Execute FNO Market sell orders in bulk.
+
+        Args:
+            instructions (list): List of sell order dicts (symbol, qty, tag, instruction_id).
+            publisher (bool): Whether to use publisher config. Defaults to False.
+
+        Returns:
+            None
+        """
+        logger.info(f"In execute_market_sell_orders_fno - {instructions =}, {publisher =}")
+        for order in instructions:
+            data = self._market_sell_fno(
+                trading_symbol=order.get("symbol"),
+                qty=order.get("qty"),
+                generate_order_tag=order.get("tag"),
+                price=order.get("price"),
+                publisher=publisher
+            )
+            logger.info(f"execute_market_sell_orders_fno {data = }")
+
+    def _limit_buy_fno(self, trading_symbol, qty, generate_order_tag, price, publisher, proxy=None):
+        """
+        Places a limit buy order for FNO.
+
+        Args:
+            trading_symbol (str): Symbol to buy.
+            qty (int): Quantity to buy.
+            generate_order_tag (str): Order tag.
+            price (float): Limit price.
+            publisher (bool): Whether to use publisher config.
+            proxy (str, optional): Proxy config.
+
+        Returns:
+            dict: Order response data.
+        """
+        logger.info(f"Placing FNO limit buy order for {trading_symbol=}, {qty=}, {price=}")
+        meta_data = self._get_fno_metadata()
+        return self._place_order(
+            trading_symbol,
+            qty,
+            self.BUY,
+            generate_order_tag,
+            price,
+            meta_data,
+            "fno",
+            self.LIMIT,
+            proxy=proxy,
+            publisher=publisher
+        )
+
+    def _limit_sell_fno(self, trading_symbol, qty, generate_order_tag, price, publisher, proxy=None):
+        """
+        Places a limit sell order for FNO.
+
+        Args:
+            trading_symbol (str): Symbol to sell.
+            qty (int): Quantity to sell.
+            generate_order_tag (str): Order tag.
+            price (float): Limit price.
+            publisher (bool): Whether to use publisher config.
+            proxy (str, optional): Proxy config.
+
+        Returns:
+            dict: Order response data.
+        """
+        logger.info(f"Placing FNO limit sell order for {trading_symbol=}, {qty=}, {price=}")
+        meta_data = self._get_fno_metadata()
+        return self._place_order(
+            trading_symbol,
+            qty,
+            self.SELL,
+            generate_order_tag,
+            price,
+            meta_data,
+            "fno",
+            self.LIMIT,
+            proxy=proxy,
+            publisher=publisher
+        )
+
+    def execute_limit_buy_orders_fno(self, instructions, publisher):
+        """
+        Execute FNO limit buy orders in bulk.
+
+        Args:
+            instructions (list): List of buy order dicts (symbol, qty, tag, price).
+            publisher (bool): Whether to use publisher config.
+
+        Returns:
+            None
+        """
+        logger.info(f"In execute_limit_buy_orders_fno - {instructions =}")
+        for order in instructions:
+            data = self._limit_buy_fno(
+                trading_symbol=order.get("symbol"),
+                qty=order.get("qty"),
+                generate_order_tag=order.get("tag"),
+                price=order.get("price"),
+                publisher=publisher
+            )
+            logger.info(f"execute_limit_buy_orders_fno {data = }")
+
+    def execute_limit_sell_orders_fno(self, instructions, publisher):
+        """
+        Execute FNO limit sell orders in bulk.
+
+        Args:
+            instructions (list): List of sell order dicts (symbol, qty, tag, price).
+            publisher (bool): Whether to use publisher config.
+
+        Returns:
+            None
+        """
+        logger.info(f"In execute_limit_sell_orders_fno - {instructions =}, {publisher =}")
+        for order in instructions:
+            data = self._limit_sell_fno(
+                trading_symbol=order.get("symbol"),
+                qty=order.get("qty"),
+                generate_order_tag=order.get("tag"),
+                price=order.get("price"),
+                publisher=publisher
+            )
+            logger.info(f"execute_limit_sell_orders_fno {data = }")
+

bw_essentials/services/user_app.py

@@ -34,18 +34,22 @@ class PrometheusUserApp(ApiClient):
         urls (Dict[str, str]): A dictionary of endpoint path templates
     """
 
-    def __init__(self, service_user: str):
+    def __init__(self, service_user: str, tenant_id: str = None):
         """
-        Initialize the PrometheusUserApp client with the given service user.
+        Initialize the PrometheusUserApp client with the given service user and tenant id.
 
         Args:
             service_user (str): Username or service identifier for authentication.
+            tenant_id (str, optional): Tenant identifier for multi-tenant usage.
+                                       Defaults to None if not applicable.
         """
         super().__init__(user=service_user)
         self.base_url = self.get_base_url(Services.PROMETHEUS_USER_APP.value)
+        self.api_key = self.get_api_key(Services.PROMETHEUS_USER_APP.value)
         self.name = Services.PROMETHEUS_USER_APP.value
+        self.tenant_id = tenant_id
         self.urls = {
-            "user_details": "user/details",
+            "user_details": "user/details/",
             "profile": "user/profile",
             "get_profile": "user/profile/",
             "login": "user/login",
@@ -60,6 +64,20 @@ class PrometheusUserApp(ApiClient):
             "sso": "user/{}/sso"
         }
 
+
+    def _headers(self):
+        """
+        Prepares headers for API calls.
+
+        Returns:
+            dict: Headers
+        """
+        return {
+            'Content-Type': 'application/json',
+            **({'X-Tenant-ID': self.tenant_id} if self.tenant_id else {}),
+            'x-api-key': self.api_key
+        }
+
     def get_user_details(self, user_id: str) -> Optional[Dict[str, Any]]:
         """
         Fetch detailed user information by user ID.
@@ -71,10 +89,11 @@ class PrometheusUserApp(ApiClient):
             Optional[Dict[str, Any]]: Parsed user data if found, else None.
         """
         logger.info("Fetching user details for user_id=%s", user_id)
+        self.headers = self._headers()
         response = self._get(
             endpoint=self.urls["user_details"],
             url=self.base_url,
-            params={'user_id': user_id}
+            params={'user_id': user_id},
         )
         return response.get('data')