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

bw_essentials/constants/services.py

@@ -20,3 +20,15 @@ class Services(Enum):
     PROMETHEUS_USER_APP = "Prometheus_User_App"
     PORTFOLIO_CATALOGUE = "Portfolio_Catalogue"
     PORTFOLIO_CONTENT = "Portfolio_Content"
+    JOB_SCHEDULER = "Job_Scheduler"
+    COMPLIANCE = "Compliance"
+
+class PortfolioStatus(Enum):
+    """
+        Enum representing Status of Basket.
+    """
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    PAUSED = "paused"
+
+    ACTIVE_FOR_SUBSCRIBED_USER = (ACTIVE, PAUSED)

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
 
@@ -80,6 +81,19 @@ class ApiClient:
         env_key = f"{service_name.upper()}_BASE_URL"
         return self._get_env_var(env_key)
 
+    def get_api_key(self, service_name: str) -> str:
+        """
+        Resolve the service API Key for a given service name using environment variables.
+
+        Args:
+            service_name (str): The logical name of the service.
+
+        Returns:
+            str: The resolved api key from the environment.
+        """
+        env_key = f"{service_name.upper()}_API_KEY"
+        return self._get_env_var(env_key)
+
     def set_tenant_id(self, tenant_id: str) -> None:
         """
         Set the tenant ID in the request headers.
@@ -182,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
@@ -62,7 +63,8 @@ class Broker(ApiClient):
             "authorised_holdings": "brokers/{}/holdings/authorise",
             "user_instructions": "brokers/{}/user/instructions",
             "details": "brokers/{}/trade/details",
-            "surveillance_orders": "brokers/{}/surveillance/orders"
+            "surveillance_orders": "brokers/{}/surveillance/orders",
+            "profile": "brokers/{}/profile"
         }
 
     def authenticate(self, broker_name: str, user_id: str, entity_id: str,
@@ -118,22 +120,46 @@ class Broker(ApiClient):
         logger.info(f"{response =}")
         return response["data"]["balance"]
 
-    def get_holdings(self, broker_name: str, user_id: str) -> list:
+    def get_profile(self, broker_name: str, user_id: str) -> dict:
+        """
+        Fetch user profile from the broker service.
+
+        Args:
+            broker_name (str): Broker name.
+            user_id (str): User ID.
+
+        Returns:
+            Dict: User Profile.
+        """
+        logger.info(f"In - get_profile {user_id =}")
+        response = self._get(
+            url=self.base_url,
+            endpoint=self.urls["profile"].format(broker_name),
+            params={"user_id": user_id}
+        )
+        logger.info(f"{response =}")
+        return response["data"]
+
+    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/job_scheduler.py

@@ -0,0 +1,62 @@
+import logging
+from bw_essentials.constants.services import Services
+from bw_essentials.services.api_client import ApiClient
+
+logger = logging.getLogger(__name__)
+
+
+class JobScheduler(ApiClient):
+    """
+    Class for making API calls to the Job Scheduler Service.
+
+    Args:
+    user (str): The user for whom the API calls are being made.
+    """
+
+    def __init__(self, user, tenant_id: str = None):
+        """
+        Initialize the Job Scheduler object.
+
+        Args:
+        user (str): The user for whom the API calls are being made.
+        """
+        super().__init__(user)
+        self.base_url = self.get_base_url(Services.JOB_SCHEDULER.value)
+        self.api_key = self.get_api_key(Services.JOB_SCHEDULER.value)
+        self.name = Services.JOB_SCHEDULER.value
+        self.tenant_id = tenant_id
+        self.urls = {
+            "process_user_profile": "taskmanager/process/user-portfolios/"
+        }
+
+    def _headers(self):
+        """
+        Prepares headers for API calls.
+
+        Returns:
+            dict: Headers
+        """
+        self.headers.update({
+            'Content-Type': 'application/json',
+            **({'X-Tenant-ID': self.tenant_id} if self.tenant_id else {}),
+            'x-api-key': self.api_key
+        })
+
+    def process_user_profile(self, data):
+        """
+        Send a request to process a user profile.
+
+        This method prepares the required headers and sends a POST request
+        to the `process_user_profile` endpoint with the provided user data.
+
+        Args:
+            data (dict): A dictionary containing user profile information
+                to be sent in the request body.
+
+        Returns:
+            None: The method does not return a value.
+        """
+        logger.info(f"In - process_user_profile {self.user =}")
+        self._headers()
+        self._post(url=self.base_url, endpoint=self.urls.get('process_user_profile'), json=data)
+        logger.info(f"Out - process_user_profile")

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")