bw-essentials-core 0.1.3__tar.gz → 0.1.42__tar.gz

{bw_essentials_core-0.1.3 → bw_essentials_core-0.1.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bw-essentials-core
-Version: 0.1.3
+Version: 0.1.42
 Summary: Reusable utilities for S3, email, Data Loch, Microsoft Teams Notifications and more.
 Author: InvestorAI
 Author-email: support+tech@investorai.in

bw_essentials_core-0.1.42/bw_essentials/EventNotification/EventBridgePublisher.py

@@ -0,0 +1,106 @@
+"""
+Event notification module for publishing events to AWS EventBridge.
+
+This module provides functionality to send events to AWS EventBridge for
+asynchronous processing and integration with other AWS services.
+"""
+import json
+import logging
+import os
+import sys
+from importlib.util import spec_from_file_location, module_from_spec
+from ..notifications.teams_notifications import Notifications as ErrorNotifications
+
+import boto3
+
+logger = logging.getLogger(__name__)
+
+
+class EventBridgePublisher(object):
+    """
+    Handles publishing events to AWS EventBridge.
+
+    This class manages AWS credentials from environment configuration and provides
+    methods to publish events to an AWS EventBridge event bus for downstream processing.
+    """
+
+    def __init__(self):
+        self.region_name = self._get_env_var("AWS_REGION")
+        self.aws_access_key_id = self._get_env_var("AWS_ACCESS_KEY_ID")
+        self.aws_secret_access_key = self._get_env_var("AWS_SECRET_ACCESS_KEY")
+
+    def _get_env_var(self, key: str) -> str:
+        """
+        Fetch a required variable from bw_config.py located in the root directory.
+
+        Raises:
+            FileNotFoundError: If bw_config.py is not found.
+            AttributeError: If the requested key is not defined in the config.
+
+        Returns:
+            str: The value of the config variable.
+        """
+        config_path = os.path.join(os.getcwd(), "bw_config.py")
+
+        if not os.path.exists(config_path):
+            raise FileNotFoundError("`bw_config.py` file not found in the root directory. "
+                                    "Please ensure the config file exists.")
+
+        spec = spec_from_file_location("bw_config", config_path)
+        bw_config = module_from_spec(spec)
+        sys.modules["bw_config"] = bw_config
+        spec.loader.exec_module(bw_config)
+
+        if not hasattr(bw_config, key):
+            raise AttributeError(f"`{key}` not found in bw_config.py. Please define it in the config.")
+
+        return getattr(bw_config, key)
+
+    def send_event_notification(self, event, source='user-event'):
+        """
+        Publish an event to AWS EventBridge.
+
+        This method sends an event to the configured AWS EventBridge event bus.
+        If an error occurs during publishing, it sends an error notification
+        via Teams.
+
+        Args:
+            event (dict): The event payload to publish. Will be JSON-serialized.
+            source (str, optional): The event source identifier. Defaults to 'user-event'.
+
+        Note:
+            - Requires AWS_EVENT_BUS_ARN configuration variable
+            - Errors are logged and sent as Teams notifications
+            - AWS client connection is properly closed after use
+        """
+        try:
+            logger.info(f"In publish event")
+            # Create AWS EventBridge client with configured credentials
+            client = boto3.client("events",
+                                  region_name=self.region_name,
+                                  aws_access_key_id=self.aws_access_key_id,
+                                  aws_secret_access_key=self.aws_secret_access_key)
+            event_bus_arn = self._get_env_var("AWS_EVENT_BUS_ARN")
+
+            if not event_bus_arn:
+                raise ValueError("EventBusName is empty — invalid configuration.")
+
+            # Publish event to EventBridge
+            response = client.put_events(
+                Entries=[
+                    {
+                        'Source': source,
+                        'DetailType': 'user-preferences',
+                        'Detail': json.dumps(event),
+                        'EventBusName': event_bus_arn
+                    }
+                ]
+            )
+            client.close()
+            logger.info(f"Event published - {response = }")
+        except Exception as e:
+            # Notify error via Teams on publishing failure
+            error_notifications = ErrorNotifications('BW-essentials_error')
+            error_notifications.notify_error(
+                message="error via BW essentials while sending a event notification" + str(e),
+                summary=f"event publish error {event = }")

bw_essentials_core-0.1.42/bw_essentials/EventNotification/NotificationType.py

@@ -0,0 +1,314 @@
+"""
+Notification type definitions for different event types.
+
+This module defines structured notification types for various business events
+such as subscriptions, investments, withdrawals, and alerts.
+"""
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class NotificationType:
+    """
+    Defines all available notification event types and their structures.
+
+    This class provides methods to create standardized event payloads for
+    different types of user actions and system events. Each method returns
+    a dictionary with a consistent schema including version, broker info,
+    event name, and event-specific data.
+    """
+
+    def __init__(self):
+        self.profit_target_event_name = "profit_target"
+        self.stop_loss_alert_event_name = "stop_loss_alert"
+
+    def available_notifications(self):
+        """
+        Get a list of all available notification methods.
+
+        Returns:
+            list: Names of all public notification methods in this class.
+        """
+        return [m for m in dir(self) if
+                callable(getattr(self, m)) and m != 'available_notifications' and (not m.startswith('_'))]
+
+    def subscription_successful(self,
+                                user_id: str,
+                                phone_number: str,
+                                basket_name: str,
+                                basket_fee: float,
+                                transaction_amount: float,
+                                start_date: str,
+                                expiry_date: str,
+                                broker_name: str,
+                                product: str,
+                                platform: str):
+        """
+        Create a subscription successful event notification.
+
+        Args:
+            user_id (str): The ID of the user who subscribed.
+            phone_number (str): User's phone number.
+            basket_name (str): Name of the basket subscribed to.
+            basket_fee (float): Fee charged for the basket.
+            transaction_amount (float): Total transaction amount.
+            start_date (str): Subscription start date.
+            expiry_date (str): Subscription expiry date.
+            broker_name (str): Name of the broker handling the subscription.
+            product (str): Product identifier.
+            platform (str): Platform identifier.
+
+        Returns:
+            dict: Structured event payload with subscription details.
+        """
+        result = {"version": "2",
+                  "broker": broker_name,
+                  "event_name": "subscription_successful",
+                  "user_id": user_id,
+                  "product": product,
+                  "platform": platform,
+                  "data": {
+                      "phone_number": phone_number,
+                      "basket_name": basket_name,
+                      "basket_fee": basket_fee,
+                      "transaction_amount": transaction_amount,
+                      "start_date": start_date,
+                      "expiry_date": expiry_date,
+                  }
+                  }
+        return result
+
+    def subscription_cancelled(self,
+                               user_id: str,
+                               broker_name: str,
+                               product: str,
+                               platform: str
+                               ):
+        """
+        Create a subscription cancelled event notification.
+
+        Args:
+            user_id (str): The ID of the user whose subscription was cancelled.
+            broker_name (str): Name of the broker handling the subscription.
+            product (str): Product identifier.
+            platform (str): Platform identifier.
+
+        Returns:
+            dict: Structured event payload indicating subscription cancellation.
+        """
+        result = {
+            "version": "2",
+            "broker": broker_name,
+            "event_name": "subscription_cancelled",
+            "user_id": user_id,
+            "product": product,
+            "platform": platform,
+            "data": {}
+        }
+        return result
+
+    def investment_successful(self,
+                              user_id: str,
+                              phone_number: str,
+                              basket_name: str,
+                              basket_fee: float,
+                              transaction_amount: float,
+                              investment_amount: float,
+                              broker_name: str,
+                              product: str,
+                              platform: str
+                              ):
+        """
+        Create an investment successful event notification.
+
+        Args:
+            user_id (str): The ID of the user who made the investment.
+            phone_number (str): User's phone number.
+            basket_name (str): Name of the basket invested in.
+            basket_fee (float): Fee charged for the basket.
+            transaction_amount (float): Total transaction amount.
+            investment_amount (float): The amount invested.
+            broker_name (str): Name of the broker handling the investment.
+            product (str): Product identifier.
+            platform (str): Platform identifier.
+
+        Returns:
+            dict: Structured event payload with investment details.
+        """
+        result = {
+            "version": "2",
+            "broker": broker_name,
+            "event_name": "investment_successful",
+            "user_id": user_id,
+            "product": product,
+            "platform": platform,
+            "data": {
+                "phone_number": phone_number,
+                "basket_name": basket_name,
+                "basket_fee": basket_fee,
+                "transaction_amount": transaction_amount,
+                "investment_amount": investment_amount,
+            }
+        }
+        return result
+
+    def withdrawal_successful(self,
+                              user_id: str,
+                              phone_number: str,
+                              basket_name: str,
+                              sell_trade_value: float,
+                              broker_name: str,
+                              product: str,
+                              platform: str
+                              ):
+        """
+        Create a withdrawal successful event notification.
+
+        Args:
+            user_id (str): The ID of the user who made the withdrawal.
+            phone_number (str): User's phone number.
+            basket_name (str): Name of the basket withdrawn from.
+            sell_trade_value (float): The value of the sold trade.
+            broker_name (str): Name of the broker handling the withdrawal.
+            product (str): Product identifier.
+            platform (str): Platform identifier.
+
+        Returns:
+            dict: Structured event payload with withdrawal details.
+        """
+        result = {
+            "version": "2",
+            "broker": broker_name,
+            "event_name": "withdrawal_successful",
+            "user_id": user_id,
+            "product": product,
+            "platform": platform,
+            "data": {
+                "sell_trade_value": sell_trade_value,
+                "phone_number": phone_number,
+                "basket_name": basket_name,
+            }
+        }
+        return result
+
+    def loss_alert_updated(self,
+                           user_id: str,
+                           basket_name: str,
+                           start_date: str,
+                           stop_loss_limit: float,
+                           broker_name: str,
+                           product: str,
+                           platform: str
+                           ):
+        """
+        Create a loss alert updated event notification.
+
+        This event is triggered when a stop-loss limit is updated for a basket.
+
+        Args:
+            user_id (str): The ID of the user whose alert was updated.
+            basket_name (str): Name of the basket with the loss alert.
+            start_date (str): The start date associated with the alert.
+            stop_loss_limit (float): The stop-loss limit value.
+            broker_name (str): Name of the broker managing the alert.
+            product (str): Product identifier.
+            platform (str): Platform identifier.
+
+        Returns:
+            dict: Structured event payload with loss alert details.
+        """
+        result = {
+            "version": "2",
+            "broker": broker_name,
+            "event_name": "loss_alert_updated",
+            "user_id": user_id,
+            "product": product,
+            "platform": platform,
+            "data": {
+                "start_date": start_date,
+                "stop_loss_limit": stop_loss_limit,
+                "product": product,
+                "basket_name": basket_name
+            }
+        }
+        return result
+
+    def profit_target(
+            self,
+            user_id: str,
+            triggered_at: str,
+            target_percentage: float,
+            symbol: str,
+            broker_name: str,
+            product: str,
+            platform: str,
+    ) -> dict:
+        """
+        Build Profit Target notification payload.
+        """
+        logger.info(
+            "ProfitTarget payload build started | user=%s | symbol=%s",
+            user_id,
+            symbol,
+        )
+
+        result = {
+            "version": "2",
+            "broker": broker_name,
+            "event_name": self.profit_target_event_name,
+            "user_id": user_id,
+            "product": product,
+            "platform": platform,
+            "data": {
+                "triggered_at": triggered_at,
+                "target_percentage": target_percentage,
+                "symbol": symbol,
+                "product": product,
+            },
+        }
+
+        logger.info(
+            "ProfitTarget payload build completed | user=%s | symbol=%s | payload=%s",
+            user_id,
+            symbol,
+            result,
+        )
+
+        return result
+
+    def stop_loss_alert(
+            self,
+            user_id: str,
+            triggered_at: str,
+            target_percentage: float,
+            symbol: str,
+            broker_name: str,
+            product: str,
+            platform: str,
+    ) -> dict:
+        """
+        Build Stop Loss notification payload.
+        """
+        logger.info("StopLoss payload build started | user=%s | symbol=%s", user_id, symbol)
+        result = {
+            "version": "2",
+            "broker": broker_name,
+            "event_name": self.stop_loss_alert_event_name,
+            "user_id": user_id,
+            "product": product,
+            "platform": platform,
+            "data": {
+                "triggered_at": triggered_at,
+                "target_percentage": target_percentage,
+                "symbol": symbol,
+                "product": product,
+            },
+        }
+
+        logger.info("StopLoss payload build completed | user=%s | symbol=%s | payload=%s", user_id,
+                    symbol,
+                    result,
+                    )
+
+        return result

{bw_essentials_core-0.1.3 → bw_essentials_core-0.1.42}/bw_essentials/constants/services.py

@@ -11,6 +11,7 @@ class Services(Enum):
     MARKET_PRICER = "Market_Pricer"
     BROKER = 'Broker'
     USER_PORTFOLIO = 'User_Portfolio'
+    FINN_USER_PORTFOLIO = 'Finn_User_Portfolio'
     TRADE_PLACEMENT = 'Trade_Placement'
     CONTENT = 'Portfolio_Content'
     NOTIFICATION = 'Notification'
@@ -18,3 +19,17 @@ class Services(Enum):
     PAYMENT = 'Payment'
     MODEL_PORTFOLIO = "Model_Portfolio"
     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_core-0.1.3 → bw_essentials_core-0.1.42}/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_core-0.1.3 → bw_essentials_core-0.1.42}/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.
@@ -88,7 +102,7 @@ class ApiClient:
             tenant_id (str): The tenant identifier to include in the headers.
         """
         logger.info(f"Setting tenant ID: {tenant_id}")
-        self._update_headers({"tenant_id": tenant_id})
+        self._update_headers({"X-Tenant-ID": tenant_id})
         logger.info(f"Updated headers: {self.headers}")
 
     def set_headers(self, headers: dict) -> None:
@@ -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,