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

bw_essentials/services/portfolio_catalogue.py

@@ -80,7 +80,8 @@ class PortfolioCatalogue(ApiClient):
             "rebalance": "rebalance",
             "get_rebalance": "rebalance",
             "subscriptions_by_ids": "subscription-plan/list",
-            "otp_subscriptions_by_ids": "one-time-plans/list"
+            "otp_subscriptions_by_ids": "one-time-plans/list",
+            "option_recommendations": "options/recommendations"
         }
 
     def create_rebalance(self, json: Dict[str, Any]) -> Optional[Dict[str, Any]]:
@@ -210,4 +211,62 @@ class PortfolioCatalogue(ApiClient):
         }
         response  = self._post(url=url, endpoint=self.urls.get('otp_subscriptions_by_ids'), json=payload)
         logger.info(f"Successfully fetched otp subscriptions by ids data. {response =}")
-        return response.get('data', [])
+        return response.get('data', [])
+
+    def get_options_recommendations(self,
+                                    strike_price_gt: float = None,
+                                    segment_in: str = None,
+                                    date_gte: str = None,
+                                    limit: int = None,
+                                    broker: str = None,
+                                    underlying_symbol: str = None,
+                                    status: str = None,
+                                    isin_code: str = None):
+        """
+        Fetch options trading recommendations based on filtering parameters.
+
+        This method sends a GET request to the Portfolio-Catalogue service's
+        `/options/recommendations` endpoint with optional query parameters
+        for filtering by strike price, trading segment, date, broker, and limit.
+
+        Endpoint:
+            GET /options/recommendations
+
+        Args:
+            strike_price_gt (float, optional): Fetch recommendations where strike price > given value.
+            segment_in (str, optional): Trading segment to filter by (e.g., 'fno').
+            date_gte (str, optional): Minimum date (ISO format, e.g., '2025-10-28').
+            limit (int, optional): Limit the number of records returned.
+            broker (str, optional): Broker name to filter recommendations (e.g., 'zerodha').
+            underlying_symbol (str, optional): Trading symbol to filter recommendations (e.g., 'RELIANCE').
+            status (str, optional): Status of the recommendation. (e.g., 'active', 'inactive')
+            isin_code (str, optional): ISIN code to filter recommendations).
+
+        Returns:
+            list[dict]: A list of recommendation records if available, otherwise an empty list.
+        """
+        logger.info(
+            "In - get_options_recommendations strike_price_gt=%s, segment_in=%s, date_gte=%s, limit=%s, "
+            "broker=%s, underlying_symbol=%s, status=%s, isin_code=%s",
+            strike_price_gt, segment_in, date_gte, limit, broker, underlying_symbol, status, isin_code
+        )
+
+        params = {k: v for k, v in {
+            "strike_price__gt": strike_price_gt,
+            "segment__in": segment_in,
+            "date__gte": date_gte,
+            "limit": limit,
+            "broker": broker,
+            "underlying_symbol": underlying_symbol,
+            "status": status,
+            "isin_code": isin_code
+        }.items() if v is not None}
+
+        response = self._get(
+            url=self.base_url,
+            endpoint=self.urls.get('option_recommendations'),
+            params=params
+        )
+
+        logger.info(f"Successfully fetched options recommendations. {response =}")
+        return response.get("data", [])

bw_essentials/services/portfolio_content.py

@@ -90,4 +90,4 @@ class PortfolioContent(ApiClient):
             json=payload
         )
         logger.info(f"Successfully fetched portfolio details by ids. {response=}")
-        return response.get('data', [])
+        return response.get('data', [])

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 = }")
+