pip install slack_sdk python-dotenv tenacity pandas matplotlib seaborn numpy

import os
import logging
import time
import random
from collections import deque
from datetime import datetime, timedelta

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
from dotenv import load_dotenv
from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type

def setup_logger(logger_name: str, log_level: int = logging.INFO) -> logging.Logger:
    """
    Sets up and configures a Python logger.

    Parameters
    ----------
    logger_name : str
        The name of the logger to be set up.
    log_level : int, optional
        The logging level (e.g., logging.INFO, logging.DEBUG), defaults to logging.INFO.

    Returns
    -------
    logging.Logger
        The configured logger instance.
    """
    logger = logging.getLogger(logger_name)
    logger.setLevel(log_level)
    # Prevent adding multiple handlers if the logger already has one
    if not logger.handlers:
        handler = logging.StreamHandler()
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
    logger.info(f"Logger '{logger_name}' initialized with level {logging.getLevelName(log_level)}.")
    return logger

def create_slack_config(state: dict) -> dict:
    """
    Initializes the Slack configuration by loading environment variables and creating a Slack WebClient.

    Parameters
    ----------
    state : dict
        Current state dictionary.

    Returns
    -------
    dict
        Updated state with Slack client and channel ID.
    """
    logger = logging.getLogger('slack_config')
    load_dotenv()  # Load environment variables from .env file

    slack_bot_token = os.environ.get("SLACK_BOT_TOKEN")
    slack_bot_token = "xoxb-11337840340049-11329656469459-KBbBdP3BtKYaaN3Vrt35fwpH"
    # slack_channel_id = os.environ.get("SLACK_CHANNEL_ID", "https://testnotebookworkspace.slack.com/archives/C0B9ZJ87MPE") # Default to #general
    # slack_channel_id = "https://testnotebookworkspace.slack.com/archives/C0B9ZJ87MPE"
    slack_channel_id = "C0B9ZJ87MPE"
    if not slack_bot_token:
        logger.warning("SLACK_BOT_TOKEN environment variable not found. Slack functionality may be limited.")
        state['slack_client'] = None
    else:
        state['slack_client'] = WebClient(token=slack_bot_token)
        logger.info("Slack WebClient initialized successfully.")

    state['slack_channel_id'] = slack_channel_id
    logger.info(f"Slack channel ID set to: {slack_channel_id}")

    return state

def _add_jitter(value: float) -> float:
    """
    Adds a small random jitter to a given value.

    Parameters
    ----------
    value : float
        The original value.

    Returns
    -------
    float
        The value with added jitter.
    """
    return value * (1 + random.uniform(-0.1, 0.1)) # +/- 10% jitter

@retry(
    wait=wait_exponential(multiplier=1, min=_add_jitter(4), max=_add_jitter(60)),
    stop=stop_after_attempt(5),
    retry=retry_if_exception_type(SlackApiError),
    reraise=True
)
def send_slack_message(state: dict, message: str) -> dict:
    """
    Sends a message to the configured Slack channel with retries and exponential backoff.

    Parameters
    ----------
    state : dict
        Current state dictionary containing the Slack client and channel ID.
    message : str
        The text message to be sent to Slack.

    Returns
    -------
    dict
        Updated state dictionary.

    Examples
    --------
    >>> state = create_slack_config({})
    >>> state = send_slack_message(state, "Hello from Colab!")
    """
    logger = logging.getLogger('slack_sender')
    client = state.get('slack_client')
    channel_id = state.get('slack_channel_id')

    if not client:
        logger.error("Slack client not initialized. Cannot send message.")
        # Track failure for demonstration
        if 'message_statuses' not in state:
            state['message_statuses'] = deque()
        state['message_statuses'].append({'timestamp': datetime.now(), 'status': 'failed', 'reason': 'no_client'})
        return state

    try:
        response = client.chat_postMessage(
            channel=channel_id,
            text=message
        )
        if response['ok']:
            logger.info(f"Message sent successfully to {channel_id}: {message[:50]}...")
            if 'message_statuses' not in state:
                state['message_statuses'] = deque()
            state['message_statuses'].append({'timestamp': datetime.now(), 'status': 'sent', 'reason': None})
        else:
            error_msg = response['error']
            logger.error(f"Failed to send message to {channel_id}: {error_msg}")
            if 'message_statuses' not in state:
                state['message_statuses'] = deque()
            state['message_statuses'].append({'timestamp': datetime.now(), 'status': 'failed', 'reason': error_msg})

    except SlackApiError as e:
        logger.warning(f"Slack API error encountered, retrying: {e.response['error']}")
        # The 'retry' decorator will handle re-raising and waiting
        raise # Re-raise to trigger tenacity retry
    except Exception as e:
        logger.critical(f"An unexpected error occurred while sending Slack message: {e}")
        if 'message_statuses' not in state:
            state['message_statuses'] = deque()
        state['message_statuses'].append({'timestamp': datetime.now(), 'status': 'failed', 'reason': str(e)})

    return state

def generate_trade_alert(state: dict, symbol: str, price: float, quantity: int, action: str) -> dict:
    """
    Generates a simulated trade alert dictionary.

    Parameters
    ----------
    state : dict
        Current state dictionary.
    symbol : str
        The stock or asset symbol (e.g., 'AAPL').
    price : float
        The price at which the trade alert is triggered.
    quantity : int
        The quantity involved in the trade.
    action : str
        The trade action (e.g., 'BUY', 'SELL').

    Returns
    -------
    dict
        A dictionary representing the generated trade alert.

    Examples
    --------
    >>> alert = generate_trade_alert({}, 'MSFT', 300.50, 100, 'BUY')
    >>> print(alert)
    """
    logger = logging.getLogger('trade_alert_generator')
    alert = {
        'timestamp': datetime.now().isoformat(),
        'symbol': symbol,
        'action': action,
        'price': price,
        'quantity': quantity,
        'message': f"TRADE ALERT: {action} {quantity} shares of {symbol} at ${price:.2f}"
    }
    logger.info(f"Generated alert for {symbol}: {action} at {price}")
    return alert

def format_slack_message(state: dict, alert: dict) -> str:
    """
    Formats a trade alert dictionary into a string suitable for a Slack message.

    Parameters
    ----------
    state : dict
        Current state dictionary.
    alert : dict
        The trade alert dictionary.

    Returns
    -------
    str
        A formatted message string for Slack.

    Examples
    --------
    >>> alert_data = {'timestamp': '...', 'symbol': 'GOOG', 'action': 'SELL', 'price': 150.0, 'quantity': 50, 'message': '...'}
    >>> msg = format_slack_message({}, alert_data)
    >>> print(msg)
    """
    logger = logging.getLogger('message_formatter')
    message = (
        f":loudspeaker: *TRADE ALERT* :loudspeaker:\n"
        f"> *Symbol:* `{alert['symbol']}`\n"
        f"> *Action:* `{alert['action']}`\n"
        f"> *Price:* `${alert['price']:.2f}`\n"
        f"> *Quantity:* `{alert['quantity']}`\n"
        f"> _Timestamp:_ `{alert['timestamp']}`\n"
        f"> :bulb: _{alert['message']}_"
    )
    logger.debug("Message formatted for Slack.")
    return message

def summarize_message_statuses(state: dict) -> pd.DataFrame:
    """
    Summarizes the message sending performance from the 'message_statuses' deque.

    Parameters
    ----------
    state : dict
        Current state dictionary containing the 'message_statuses' deque.

    Returns
    -------
    pd.DataFrame
        A DataFrame summarizing the message sending performance.
    """
    logger = logging.getLogger('summary_generator')
    statuses = state.get('message_statuses', deque())
    if not statuses:
        logger.info("No message statuses to summarize.")
        return pd.DataFrame(columns=['Metric', 'Value'])

    df_statuses = pd.DataFrame(list(statuses))
    total_messages = len(df_statuses)
    successful_messages = df_statuses[df_statuses['status'] == 'sent'].shape[0]
    failed_messages = total_messages - successful_messages
    success_rate = (successful_messages / total_messages * 100) if total_messages > 0 else 0

    summary_data = {
        'Metric': ['Total Messages', 'Successful Messages', 'Failed Messages', 'Success Rate (%)'],
        'Value': [total_messages, successful_messages, failed_messages, f"{success_rate:.2f}"]
    }
    summary_df = pd.DataFrame(summary_data)
    logger.info("Message status summary generated.")
    return summary_df

# 1. Initialize Global State and Logger
initial_state = {}
main_logger = setup_logger('main_app', logging.DEBUG)

# 2. Configure Slack Client
initial_state = create_slack_config(initial_state)

# Ensure message_statuses deque is initialized in state
if 'message_statuses' not in initial_state:
    initial_state['message_statuses'] = deque()

# 3. Simulate Trade Alerts and Send Notifications
main_logger.info("Starting trade alert simulation...")

simulated_alerts_data = [
    {'symbol': 'BTC', 'price': 65000.00, 'quantity': 0.5, 'action': 'BUY'},
    {'symbol': 'ETH', 'price': 3200.00, 'quantity': 2.0, 'action': 'SELL'},
    {'symbol': 'ADA', 'price': 0.45, 'quantity': 1000, 'action': 'BUY'},
    {'symbol': 'SOL', 'price': 150.00, 'quantity': 10, 'action': 'BUY'},
    {'symbol': 'XRP', 'price': 0.52, 'quantity': 500, 'action': 'SELL'}
]

# Introduce some failures for demonstration (e.g., by temporarily invalidating token)
# For a real demonstration, you might want to manually make the token invalid for some calls
# For simulation, we'll just log an error without actually trying to send for certain alerts

for i, alert_data in enumerate(simulated_alerts_data):
    alert = generate_trade_alert(initial_state, **alert_data)
    slack_message = format_slack_message(initial_state, alert)

    # Simulate a failure for the 3rd alert
    if i == 2 and initial_state['slack_client'] is not None: # Only if client is actually present
        main_logger.warning("Simulating a temporary Slack API error for demonstration...")
        original_token = initial_state['slack_client'].token
        initial_state['slack_client'].token = "invalid_token_for_demo" # Temporarily invalidate
        try:
            initial_state = send_slack_message(initial_state, slack_message)
        except SlackApiError as e:
            main_logger.error(f"Simulated error caught: {e.response['error']}")
            # Manually append a failed status if tenacity reraises after exhaustion
            initial_state['message_statuses'].append({'timestamp': datetime.now(), 'status': 'failed', 'reason': e.response['error']})
        finally:
            initial_state['slack_client'].token = original_token # Restore token
    elif i == 4 and initial_state['slack_client'] is not None: # Another simulated failure
         main_logger.warning("Simulating another temporary network issue for demonstration...")
         # Simulate a network error by raising an arbitrary exception, or by a very short timeout
         if random.random() < 0.7: # High chance of failure for demo
            try:
                # Override send_slack_message's retry for this specific call to show immediate failure
                # In a real scenario, tenacity would retry. Here, we force a single attempt failure.
                temp_client = WebClient(token="invalid_token")
                temp_client.chat_postMessage(channel=initial_state['slack_channel_id'], text=slack_message)
            except Exception as e:
                main_logger.error(f"Forced error during send: {e}")
                initial_state['message_statuses'].append({'timestamp': datetime.now(), 'status': 'failed', 'reason': "Simulated network error"})
         else:
            initial_state = send_slack_message(initial_state, slack_message)
    else:
        try:
            initial_state = send_slack_message(initial_state, slack_message)
        except Exception as e:
            main_logger.error(f"Failed to send message after retries: {e}")
            # Tenacity will reraise if all retries fail. This catches the final reraise.
            initial_state['message_statuses'].append({'timestamp': datetime.now(), 'status': 'failed', 'reason': str(e)})

    time.sleep(random.uniform(0.5, 1.5)) # Simulate processing time

main_logger.info("Trade alert simulation complete.")

# 4. Summarize and Display Results
summary_df = summarize_message_statuses(initial_state)
display(summary_df)

if 'message_statuses' in initial_state and initial_state['message_statuses']:
    df_plot = pd.DataFrame(list(initial_state['message_statuses']))

    plt.figure(figsize=(8, 6))
    sns.countplot(x='status', data=df_plot, palette='viridis')
    plt.title('Distribution of Slack Message Delivery Status')
    plt.xlabel('Delivery Status')
    plt.ylabel('Number of Messages')
    plt.grid(axis='y', linestyle='--', alpha=0.7)
    plt.show()
else:
    main_logger.info("No message statuses available to plot.")