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

bw_essentials/constants/services.py

@@ -21,6 +21,7 @@ class Services(Enum):
     PORTFOLIO_CATALOGUE = "Portfolio_Catalogue"
     PORTFOLIO_CONTENT = "Portfolio_Content"
     JOB_SCHEDULER = "Job_Scheduler"
+    COMPLIANCE = "Compliance"
 
 class PortfolioStatus(Enum):
     """

bw_essentials/email_client/email_client.py

@@ -132,7 +132,7 @@ class EmailClient:
         cc_addresses: Union[str, List[str], None],
         subject: str,
         body: str,
-        attachment_path: str,
+        attachment_path: Optional[Union[str, List[str]]],
         is_html: bool = True,
     ):
         """
@@ -143,7 +143,7 @@ class EmailClient:
             cc_addresses (Union[str, List[str], None]): One or more CC addresses (optional).
             subject (str): Email subject line.
             body (str): Email body content.
-            attachment_path (str): Full path to the file to attach.
+            attachment_path (Optional[Union[str, List[str]]]): File path(s) for attachments.
             is_html (bool): If True, body is interpreted as HTML; otherwise, plain text.
         """
         logger.info(
@@ -158,7 +158,7 @@ class EmailClient:
         cc_addresses: Union[str, List[str], None],
         subject: str,
         body: str,
-        attachment_path: Optional[str],
+        attachment_path: Optional[Union[str, List[str]]],
         is_html: bool,
     ):
         """
@@ -169,7 +169,7 @@ class EmailClient:
             cc_addresses (Union[str, List[str], None]): CC addresses.
             subject (str): Subject of the email.
             body (str): Email body content.
-            attachment_path (Optional[str]): File path for the attachment, if any.
+            attachment_path (Optional[Union[str, List[str]]]): File path(s) for attachments.
             is_html (bool): True if the body is HTML-formatted.
         """
         msg = MIMEMultipart()
@@ -180,23 +180,36 @@ class EmailClient:
 
         msg.attach(MIMEText(body, 'html' if is_html else 'plain'))
         logger.debug("Email headers and body constructed")
+        attachment_paths = []
 
         if attachment_path:
-            if not os.path.exists(attachment_path):
-                logger.warning("Attachment file not found: %s", attachment_path)
+            if isinstance(attachment_path, list):
+                attachment_paths = attachment_path
             else:
-                try:
-                    with open(attachment_path, 'rb') as attachment:
-                        part = MIMEBase('application', 'octet-stream')
-                        part.set_payload(attachment.read())
-                        encoders.encode_base64(part)
-                        part.add_header('Content-Disposition', 'attachment',
-                                        filename=os.path.basename(attachment_path))
-                        msg.attach(part)
-                        logger.info("Attachment added: %s", os.path.basename(attachment_path))
-                except Exception as e:
-                    logger.exception("Failed to read attachment file")
-                    raise e
+                attachment_paths = [attachment_path]
+
+        for path in attachment_paths:
+            if not path:
+                continue
+            if not os.path.exists(path):
+                logger.warning("Attachment file not found: %s", path)
+                continue
+
+            try:
+                with open(path, 'rb') as attachment:
+                    part = MIMEBase('application', 'octet-stream')
+                    part.set_payload(attachment.read())
+                    encoders.encode_base64(part)
+                    part.add_header(
+                        'Content-Disposition',
+                        'attachment',
+                        filename=os.path.basename(path)
+                    )
+                    msg.attach(part)
+                    logger.info("Attachment added: %s", os.path.basename(path))
+            except Exception as e:
+                logger.exception("Failed to read attachment file: %s", path)
+                raise e
 
         try:
             with smtplib.SMTP(self.smtp_host, self.smtp_port) as server:

bw_essentials/services/api_client.py

@@ -15,6 +15,7 @@ import logging
 import os
 import sys
 import time
+import httpx
 from importlib.util import spec_from_file_location, module_from_spec
 from typing import Optional, Dict, Any
 
@@ -195,6 +196,41 @@ class ApiClient:
         """
         return self._request("get", url, endpoint, params=params)
 
+    async def _async_get(self, url: str, endpoint: str, headers: dict | None = None, params: dict | None = None):
+        """
+        Async GET request, aligned with the sync _request() style.
+        """
+        headers = self._update_headers(headers or {})
+        params = params or {}
+        formatted_url = f"{url.rstrip('/')}/{endpoint.lstrip('/')}"
+
+        logger.info(f"GET {formatted_url} | Headers: {headers} | Params: {params}")
+
+        start = time.time()
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(formatted_url, headers=headers, params=params)
+
+            elapsed_time_ms = (time.time() - start) * 1000
+
+            # parse JSON safely
+            try:
+                json_data = response.json()
+            except ValueError:
+                logger.error(f"Non-JSON response from {formatted_url}")
+                json_data = None
+
+            self._log_response("GET", formatted_url, response.status_code, elapsed_time_ms, json_data)
+
+            response.raise_for_status()
+            return json_data
+
+        except Exception as exc:
+            elapsed_time_ms = (time.time() - start) * 1000
+            logger.error(f"GET {formatted_url} failed after {elapsed_time_ms:.2f}ms")
+            logger.exception(exc)
+            raise
+
     def _post(
         self,
         url: str,

bw_essentials/services/broker.py

@@ -30,6 +30,7 @@ APIs supported:
 - Acknowledge surveillance orders
 """
 import logging
+from typing import Optional
 
 from bw_essentials.constants.services import Services
 from bw_essentials.services.api_client import ApiClient
@@ -139,22 +140,26 @@ class Broker(ApiClient):
         logger.info(f"{response =}")
         return response["data"]
 
-    def get_holdings(self, broker_name: str, user_id: str) -> list:
+    def get_holdings(self, broker_name: str, user_id: str, product_type: Optional[str] = None) -> dict:
         """
         Fetch user holdings from the broker service.
 
         Args:
             broker_name (str): Broker name.
             user_id (str): User ID.
+            product_type (str, optional): Product type.
 
         Returns:
-            list: List of user holdings.
+            dict: Dict of user holdings.
         """
         logger.info(f"In - get_holdings {user_id =}")
+        params = {"user_id": user_id}
+        if product_type:
+            params['product_type'] = product_type
         response = self._get(
             url=self.base_url,
             endpoint=self.urls["holdings"].format(broker_name),
-            params={"user_id": user_id}
+            params=params
         )
         logger.info(f"{response =}")
         return response["data"]["holdings"]

bw_essentials/services/compliance.py

@@ -0,0 +1,78 @@
+import logging
+from bw_essentials.constants.services import Services
+from bw_essentials.services.api_client import ApiClient
+
+
+logger = logging.getLogger(__name__)
+
+
+class Compliance(ApiClient):
+    """
+    Compliance service integration class.
+
+    This class facilitates communication with the compliance service.
+    """
+
+    def __init__(self, user, tenant_id: str = None):
+        """
+        Initialize the Compliance service wrapper.
+
+        :param user: The user initiating the request.
+        """
+        super().__init__(user)
+        self.base_url = self.get_base_url(Services.COMPLIANCE.value)
+        self.name = Services.COMPLIANCE.value
+        self.tenant_id = tenant_id
+        self.urls = {
+            "kra_data": "kra/data"
+        }
+        logger.info("Compliance service initialized.")
+
+    def _headers(self):
+        """
+        Construct headers for compliance service requests.
+
+        :return: Dictionary of headers.
+        """
+        return {
+            'Content-Type': 'application/json',
+            **({'X-Tenant-ID': self.tenant_id} if self.tenant_id else {})
+        }
+
+    def get_kra_data(self, payload):
+        """
+        Fetches KRA details by calling API.
+
+        This method prepares the request headers, constructs the API endpoint,
+        sends a POST request with the provided payload, and returns the
+        parsed KRA data received from the compliance service.
+
+
+        Args:
+            payload (dict):
+                Dictionary containing the required fields for KRA lookup.
+                Example:
+                    {
+                        "pan": "ABCDE1234F",
+                        "dob": "1985-05-12"
+                    }
+
+        Returns:
+            dict:
+                Parsed KRA data dictionary returned by the Compliance Service.
+                Returns an empty dictionary if `data` is missing from the response.
+
+                Example:
+                    {
+                        "kra_status": "KYC_REGISTERED",
+                        "name": "John Doe",
+                        "dob": "1985-05-12",
+                        ...
+                    }
+        """
+        logger.info(f"In get_kra_data {payload =}")
+        url = f"{self.base_url}"
+        self.headers = self._headers()
+        kra_data = self._post(url=url, endpoint=self.urls.get('kra_data'), json=payload)
+        logger.info(f"Out get_kra_data {kra_data =}")
+        return kra_data.get('data', {})

bw_essentials/services/market_pricer.py

@@ -76,14 +76,14 @@ class MarketPricer(ApiClient):
         Retrieves live market prices for a list of securities on a specific exchange.
 
         Args:
-            securities (str): A list of security symbols for which live prices are requested.
+            securities (list): List of security symbols for which live prices are requested.
             exchange (str): The exchange on which the securities are traded.
         Returns:
-            list: A list of live market price data for the specified securities.
+            dict: A dictionary containing the live market price data for the specified securities.
 
         Example:
             market_pricer = MarketPricer(user)
-            securities = "TCS,RELIANCE"
+            securities = ["TCS", "RELIANCE"]
             exchange = "NSE"
             live_prices = market_pricer.get_live_prices(securities, exchange)
 
@@ -96,20 +96,21 @@ class MarketPricer(ApiClient):
 
         API Response:
             {
-                "data": [
-                    {
-                        "symbol": "TCS",
-                        "price": 150.25,
-                        "timestamp": "2023-10-04T10:30:00Z",
-                        "exchange": "NSE"
-                    },
-                    {
-                        "symbol": "RELIANCE",
-                        "price": 2750.75,
-                        "timestamp": "2023-10-04T10:30:00Z",
-                        "exchange": "NSE"
-                    }
-                ]
+              "data": {
+                "TCS": {
+                  "security": "TCS",
+                  "exchange": "NSE",
+                  "price": 3207.8,
+                  "timestamp": "2026-01-09 16:00:00"
+                },
+                "RELIANCE": {
+                  "security": "RELIANCE",
+                  "exchange": "NSE",
+                  "price": 1475.3,
+                  "timestamp": "2026-01-09 16:00:00"
+                }
+              },
+              "success": true
             }
         """
         logger.info(f"In - get_live_prices {securities =}, {exchange =}")
@@ -300,3 +301,56 @@ class MarketPricer(ApiClient):
         data = response.get("data")
         logger.info("Out - get_index_performance_by_dates success")
         return data
+
+    def get_bulk_option_eod_prices(
+        self,
+        symbols,
+        from_date,
+        to_date,
+        exchange=None,
+        underlying_symbol=None,
+        option_type=None,
+        expiry_date=None,
+    ):
+        """
+        Fetch bulk EOD OHLCV data for multiple option symbols over a date range.
+
+        Args:
+            symbols (list[str] | str): Option symbols as list or comma-separated string.
+            from_date (str): Start date in YYYY-MM-DD format.
+            to_date (str): End date in YYYY-MM-DD format.
+            exchange (str, optional): Exchange filter.
+            underlying_symbol (str, optional): Underlying instrument filter.
+            option_type (str, optional): CE or PE.
+            expiry_date (str, optional): Option expiry date.
+
+        Returns:
+            dict: Dictionary keyed by symbol containing EOD data.
+        """
+        logger.info(f"In - get_bulk_option_eod_prices | {symbols=}, {from_date=}, {to_date=}")
+
+        if not all([symbols, from_date, to_date]):
+            raise ValueError("symbols, from_date and to_date are required")
+
+        symbols = ",".join(symbols) if isinstance(symbols, list) else symbols
+
+        params = {"symbols": symbols, "from_date": from_date, "to_date": to_date}
+
+        for key, value in {
+            "exchange": exchange,
+            "underlying_symbol": underlying_symbol,
+            "option_type": option_type,
+            "expiry_date": expiry_date,
+        }.items():
+            if value is not None:
+                params[key] = value
+
+        response = self._get(
+            url=self.base_url,
+            endpoint="options/bulk/eod",
+            params=params,
+        )
+
+        logger.info(f"Out - get_bulk_option_eod_prices | symbols_count={len(symbols.split(','))}")
+        return response.get("data")
+

bw_essentials/services/master_data.py

@@ -299,3 +299,52 @@ class MasterData(ApiClient):
         response = self._get(url=self.base_url, endpoint=self.urls["broker_partner_mapping_details"].format(broker_partner, broker))
         logger.info(f"Broker partner mapping {response =}")
         return response.get('data', {})
+
+    async def get_broker_data_async(self, symbols, broker, username=None):
+        """
+        Asynchronously retrieve broker-specific data for specified symbols.
+
+        This function fetches broker-specific details such as margin and leverage
+        for a list of provided trading symbols from the broker master service.
+
+        Args:
+            username (str) [Optional]: The user_id for whom data is requested.
+            symbols (str): A comma-separated string of trading symbols.
+            broker (str): The broker identifier for which data is requested.
+
+        Returns:
+            list: A list of dictionaries containing broker data for each symbol
+                  or an empty list if no data is available.
+        """
+        logger.info(f"In - get_broker_data_async {broker =}")
+        broker_data_response = await self._async_get(
+            url=f"{self.base_url}",
+            endpoint = self.urls["broker_details"].format(broker),
+            params={"symbols": symbols, "user_id": username},
+            headers={}
+        )
+        return broker_data_response.get('data', [])
+
+    def get_broker_data_all(self, symbols, broker, username=None):
+        """
+        Retrieve broker-specific data for specified symbols.
+
+        This function fetches broker-specific details such as margin and leverage
+        for a list of provided trading symbols from the broker master service.
+
+        Args:
+            username (str) [Optional]: The user_id for whom data is requested.
+            symbols (str): A comma-separated string of trading symbols.
+            broker (str): The broker identifier for which data is requested.
+
+        Returns:
+            list: A dictionary containing broker data for the first symbol or
+                  an empty dictionary if no data is available.
+        """
+        logger.info(f"In - get_broker_data {broker =}")
+        broker_data_response = self._get(
+            url=f"{self.base_url}",
+            endpoint=self.urls['broker_details'].format(broker),
+            params={"symbols": symbols, "user_id": username},
+        )
+        return broker_data_response.get('data', [])

bw_essentials/services/model_portfolio_reporting.py

@@ -33,7 +33,8 @@ class ModelPortfolioReporting(ApiClient):
         self.object = None
         self.urls = {
             "portfolio": "portfolio",
-            "portfolio_performance": "portfolio/%s/performance"
+            "portfolio_performance": "portfolio/%s/performance",
+            "index_performance": "index/%s/performance/"
         }
         self.name = Services.MODEL_PORTFOLIO.value
         self.base_url = self.get_base_url(Services.MODEL_PORTFOLIO.value)
@@ -79,3 +80,31 @@ class ModelPortfolioReporting(ApiClient):
         )
         logger.info(f"Received response from get_portfolio_performance_by_dates: {performance}")
         return performance.get("data")
+
+    def get_index_performance_by_dates(
+            self,
+            index: str,
+            start_date: str,
+            end_date: str
+            ) -> Optional[Dict[str, Any]]:
+        """
+        Fetch Index performance for a given date range.
+
+        Args:
+            index (str): The index identifier.
+            start_date (str): The start date for performance metrics (format: YYYY-MM-DD).
+            end_date (str): The end date for performance metrics (format: YYYY-MM-DD).
+
+        Returns:
+            dict | None: The performance data within the date range.
+        """
+        logger.info(f"In - get_index_performance_by_dates with index={index}, start_date={start_date}, end_date={end_date}")
+        endpoint = self.urls['index_performance'] % index
+        params = {"start_date": start_date, "end_date": end_date}
+        performance = self._get(
+            url=self.base_url,
+            endpoint=endpoint,
+            params=params
+        )
+        logger.info(f"Received response from get_index_performance_by_dates: {performance}")
+        return performance.get("data")

bw_essentials/services/notification.py

@@ -32,7 +32,7 @@ class NotificationService(ApiClient):
             "email": "email"
         }
 
-    def _whatsapp(self, title, template, platform, params, to, user_id) -> None:
+    def _whatsapp(self, title, template, platform, params, to, user_id) -> dict:
         """
         Sends a WhatsApp notification.
 
@@ -46,7 +46,7 @@ class NotificationService(ApiClient):
         - params: Parameters for the notification message.
 
         Returns:
-        None
+            returns the response data from the notification service.
         """
         logger.info(f"In - whatsapp {user_id =}, {to =}, "
                     f"{title =}, {template =}, {platform =}, {params =}")
@@ -66,8 +66,9 @@ class NotificationService(ApiClient):
         self.set_headers(headers)
         resp_data = self._post(url=self.base_url, endpoint=self.urls.get('whatsapp'), data=payload)
         logger.info(f"Whatsapp response {resp_data =}")
+        return resp_data
 
-    def send_whatsapp(self, template, title, params, to, user_id) -> None:
+    def send_whatsapp(self, template, title, params, to, user_id) -> dict:
         """
 
         Args:
@@ -78,17 +79,18 @@ class NotificationService(ApiClient):
             user_id (str): The ID of the user receiving the notification.
 
         Returns:
-            None
+            Returns the response of calling function
         """
         logger.info(f"In - send_whatsapp_notification {user_id =} {title = } {params = } {to = }")
-        self._whatsapp(title=title,
+        response = self._whatsapp(title=title,
                        template=template,
                        platform=self._get_env_var(NotificationService.PLATFORM),
                        params=params,
                        to=to,
                        user_id=user_id)
+        return response
 
-    def _email(self, title: str, content: str, platform: str, to: str, user_id: str) -> None:
+    def _email(self, title: str, content: str, platform: str, to: str, user_id: str) -> dict:
         """
         Sends an email notification using the internal notification service.
 
@@ -100,7 +102,7 @@ class NotificationService(ApiClient):
             user_id (str): The ID of the user for tracking or logging purposes.
 
         Returns:
-            None
+            returns the response data from the notification service.
 
         """
         logger.info(f"In - email {user_id =}, {to =}, {title =}, {platform =}, {content =}")
@@ -119,8 +121,9 @@ class NotificationService(ApiClient):
         self.set_headers(headers)
         resp_data = self._post(url=self.base_url, endpoint=self.urls.get('email'), json=payload)
         logger.info(f"Email response {resp_data =}")
+        return resp_data
 
-    def send_email(self, title: str, content: str, to: str, user_id: str) -> None:
+    def send_email(self, title: str, content: str, to: str, user_id: str) -> dict:
         """
         Sends an email notification to the specified recipient.
 
@@ -131,13 +134,14 @@ class NotificationService(ApiClient):
             user_id (str): The ID of the user associated with the notification.
 
         Returns:
-            None
+            return the response of calling function
         """
         logger.info(f"In - send_email {user_id =}, {title =}, {to =}")
-        self._email(
-            title=title,
-            content=content,
-            platform=self._get_env_var(NotificationService.PLATFORM),
-            to=to,
-            user_id=user_id
+        response = self._email(
+                title=title,
+                content=content,
+                platform=self._get_env_var(NotificationService.PLATFORM),
+                to=to,
+                user_id=user_id
         )
+        return response

bw_essentials/services/payment.py

@@ -11,6 +11,8 @@ class Payment(ApiClient):
         super().__init__(service_user)
         self.urls = {
             "get_subscription": "user-subscription",
+            "update_otp_facilitator_code": "order",
+            "update_subscription_facilitator_code": "user-subscription-update-data"
         }
         self.name = Services.PAYMENT.value
         self.base_url = self.get_base_url(Services.PAYMENT.value)
@@ -36,4 +38,47 @@ class Payment(ApiClient):
         url = f"{self.base_url}"
         subscription = self._get(url=url, endpoint=self.urls.get('get_subscription'), params={'userId': user_id})
         logger.info(f"Successfully fetched subscription data. {subscription =}")
-        return subscription.get('data')
+        return subscription.get('data')
+
+    def update_otp_facilitator_code(self, payment_reference_id: str, analyst_id: str, payload: dict):
+        """
+        Updates the facilitator code on the Payment Service for a given payment_reference_id.
+
+        Args:
+            payment_reference_id (str): The payment reference ID (order ID)
+            analyst_id (str): Analyst UUID
+            payload (dict): Body containing facilitatorCode
+
+        Returns:
+            dict: Response data
+        """
+        logger.info(f"In - update_facilitator_code payment_reference_id={payment_reference_id}, "
+                    f""f"analyst_id={analyst_id}, payload={payload}")
+        response = self._put(
+            url=f"{self.base_url}",
+            endpoint=f"{self.urls.get('update_otp_facilitator_code')}/{payment_reference_id}",
+            json=payload,
+            params={"analyst": analyst_id},
+        )
+        logger.info(f"Out - update_facilitator_code response={response}")
+        return response
+
+    def update_subscription_facilitator_code(self, payment_reference_id: str, payload: dict):
+        """
+        Updates the facilitator code on the Payment Service for a given payment_reference_id.
+        Args:
+            payment_reference_id (str): The payment reference ID (subscription ID)
+            payload (dict): Body containing facilitatorCode and userId
+
+        Returns:
+            dict: Response data
+        """
+        logger.info(f"In - update_subscription_facilitator_code payment_reference_id={payment_reference_id}, "
+                    f"payload={payload}")
+        response = self._put(
+            url=f"{self.base_url}",
+            endpoint=f"{self.urls.get('update_subscription_facilitator_code')}/{payment_reference_id}",
+            json=payload
+        )
+        logger.info(f"Out - update_subscription_facilitator_code response={response}")
+        return response