Delete visualization

visualization/.env.example

@@ -1,38 +0,0 @@
-# AI Messaging System Visualization Tool - Environment Variables
-# Copy this file to .env and fill in your actual values
-
-# ============================================================================
-# Snowflake Configuration
-# ============================================================================
-SNOWFLAKE_USER=your_snowflake_username
-SNOWFLAKE_PASSWORD=your_snowflake_password
-SNOWFLAKE_ACCOUNT=your_account_identifier
-SNOWFLAKE_ROLE=your_role_name
-SNOWFLAKE_DATABASE=your_database_name
-SNOWFLAKE_WAREHOUSE=your_warehouse_name
-SNOWFLAKE_SCHEMA=your_schema_name
-
-# ============================================================================
-# AI Provider API Keys
-# ============================================================================
-# OpenAI API Key (for GPT models)
-OPENAI_API_KEY=sk-your-openai-api-key-here
-
-# Google AI API Key (for Gemini models)
-GOOGLE_API_KEY=your-google-api-key-here
-
-# ============================================================================
-# Application Access Token
-# ============================================================================
-# This token is used for authentication in the web UI
-# Set this to a secure random string
-# Example: you can generate one using: python -c "import secrets; print(secrets.token_urlsafe(32))"
-APP_TOKEN=your-secure-access-token-here
-
-# ============================================================================
-# Notes:
-# ============================================================================
-# 1. Never commit the actual .env file to version control
-# 2. Keep your credentials secure
-# 3. Use strong, unique values for APP_TOKEN
-# 4. You can also use the parent directory's .env file if it contains all these variables

visualization/.gitignore

@@ -1,57 +0,0 @@
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-env/
-venv/
-ENV/
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# Data files (local storage)
-data/configs/*.json
-data/feedback/*.csv
-data/experiments/*.json
-data/users/*.csv
-
-# Keep directory structure but ignore contents
-!data/configs/.gitkeep
-!data/feedback/.gitkeep
-!data/experiments/.gitkeep
-!data/users/.gitkeep
-
-# Environment variables
-.env
-.env.local
-
-# IDEs
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Streamlit
-.streamlit/secrets.toml
-
-# Logs
-*.log

visualization/README.md

@@ -1,1130 +0,0 @@
-# AI Messaging System - Visualization Tool
-
-An interactive Streamlit-based visualization and experimentation tool for the AI Messaging System v2. This tool enables non-technical users to generate, visualize, analyze, and improve personalized message campaigns with integrated A/B testing capabilities and comprehensive historical tracking.
-
-## 🎯 Purpose
-
-- Generate personalized messages with various configurations
-- Run A/B tests with parallel processing and side-by-side comparison
-- Visualize and analyze messages in real-time across all campaign stages
-- Provide detailed feedback with message header/body tracking
-- Track improvements and trends across historical experiments
-- Cloud-native architecture with Snowflake integration
-- Ready for deployment on HuggingFace Spaces
-
----
-
-## 🏗️ Architecture Overview
-
-### Core Philosophy: **In-Memory + Cloud Persistence**
-
-The system operates on a hybrid architecture:
-- **In-Memory Operations**: All active experiments run in `session_state` (no local files)
-- **Cloud Persistence**: Data stored in Snowflake for long-term analytics
-- **On-Demand Loading**: Historical data loaded from Snowflake when needed
-- **One-Click Storage**: Results persisted with a single button click
-
-### Why This Architecture?
-
-1. **HuggingFace Ready**: No local file dependencies
-2. **Fast Operations**: In-memory processing for real-time feedback
-3. **Scalable**: Snowflake handles unlimited historical data
-4. **Clean Separation**: Current experiments vs. historical data
-5. **Versioned Configs**: Automatic configuration versioning in Snowflake
-
----
-
-## 📁 Directory Structure
-
-```
-visualization/
-├── app.py                         # Main entry point with authentication & brand selection
-├── pages/                         # Multi-page Streamlit application
-│   ├── 1_Campaign_Builder.py      # Campaign configuration & generation (with A/B testing)
-│   ├── 2_Message_Viewer.py        # Message browsing & feedback (A/B aware)
-│   ├── 4_Analytics.py             # Performance metrics for CURRENT experiment
-│   └── 5_Historical_Analytics.py  # Historical experiments from Snowflake
-├── utils/                         # Utility modules
-│   ├── __init__.py
-│   ├── auth.py                    # Authentication logic
-│   ├── config_manager.py          # Configuration loading from Snowflake
-│   ├── db_manager.py              # Snowflake database operations (NEW)
-│   ├── experiment_runner.py       # Parallel experiment execution (NEW)
-│   ├── session_feedback_manager.py # In-memory feedback management (NEW)
-│   └── theme.py                   # Brand-specific theming
-├── data/                          # Local data storage (configs cached here)
-│   └── UI_users/                  # Pre-loaded user lists (100 users per brand)
-│       ├── drumeo_users.csv
-│       ├── pianote_users.csv
-│       ├── guitareo_users.csv
-│       └── singeo_users.csv
-├── requirements.txt               # Python dependencies
-├── README.md                      # This file
-├── IMPLEMENTATION_COMPLETE.md     # Refactoring details & progress
-└── ARCHITECTURE_REFACTOR_GUIDE.md # Technical refactoring guide
-```
-
-### Deprecated Files (No Longer Used)
-
-These files are legacy and no longer part of the active codebase:
-- ~~`utils/data_loader.py`~~ - Replaced by session_state loading
-- ~~`utils/feedback_manager.py`~~ - Replaced by SessionFeedbackManager
-- ~~`data/configs/`~~ - Configs now cached locally but loaded from Snowflake
-- ~~`data/feedback/`~~ - Feedback now in session_state → Snowflake
-- ~~`ai_messaging_system_v2/Data/ui_output/`~~ - No more file outputs
-
----
-
-## 🗄️ Snowflake Database Schema
-
-### Tables
-
-**1. MESSAGING_SYSTEM_V2.UI.CONFIGS**
-```sql
-CONFIG_NAME      VARCHAR    -- Configuration identifier
-CONFIG_FILE      VARIANT    -- JSON configuration
-CONFIG_VERSION   INTEGER    -- Auto-incrementing version
-BRAND            VARCHAR    -- Brand name (drumeo, pianote, etc.)
-CREATED_AT       TIMESTAMP  -- Creation timestamp
-```
-
-**2. MESSAGING_SYSTEM_V2.UI.EXPERIMENT_METADATA**
-```sql
-EXPERIMENT_ID               VARCHAR    -- Unique experiment identifier
-CONFIG_NAME                 VARCHAR    -- Configuration used
-BRAND                       VARCHAR    -- Brand name
-CAMPAIGN_NAME               VARCHAR    -- Campaign identifier
-STAGE                       INTEGER    -- Stage number (1-11)
-LLM_MODEL                   VARCHAR    -- Model used (gpt-4o-mini, gemini-2.5-flash-lite, etc.)
-TOTAL_MESSAGES              INTEGER    -- Messages generated in this stage
-TOTAL_USERS                 INTEGER    -- Unique users in this stage
-PLATFORM                    VARCHAR    -- Platform (push, email, etc.)
-PERSONALIZATION             BOOLEAN    -- Personalization enabled
-INVOLVE_RECSYS              BOOLEAN    -- Recommendations enabled
-RECSYS_CONTENTS             ARRAY      -- Recommendation types
-SEGMENT_INFO                VARCHAR    -- Segment description
-CAMPAIGN_INSTRUCTIONS       VARCHAR    -- Campaign-wide instructions
-PER_MESSAGE_INSTRUCTIONS    VARCHAR    -- Stage-specific instructions
-START_TIME                  TIMESTAMP  -- Experiment start time
-END_TIME                    TIMESTAMP  -- Experiment end time (optional)
-```
-
-**3. MESSAGING_SYSTEM_V2.UI.FEEDBACKS**
-```sql
-EXPERIMENT_ID      VARCHAR    -- Links to EXPERIMENT_METADATA
-USER_ID            INTEGER    -- User who received the message
-STAGE              INTEGER    -- Stage number
-FEEDBACK_TYPE      VARCHAR    -- 'reject' (only type currently)
-REJECTION_REASON   VARCHAR    -- Reason category key
-REJECTION_TEXT     VARCHAR    -- Custom text explanation
-MESSAGE_HEADER     VARCHAR    -- Full message header
-MESSAGE_BODY       VARCHAR    -- Full message body
-CAMPAIGN_NAME      VARCHAR    -- Campaign identifier
-BRAND              VARCHAR    -- Brand name
-CONFIG_NAME        VARCHAR    -- Configuration used
-TIMESTAMP          TIMESTAMP  -- Feedback submission time
-```
-
----
-
-## 🚀 Getting Started
-
-### Prerequisites
-
-- Python 3.9+
-- Snowflake account and credentials
-- OpenAI/Google AI API keys
-- AI Messaging System v2 installed in parent directory
-- Plotly for data visualization
-
-### Installation
-
-```bash
-# Install dependencies
-pip install -r requirements.txt
-
-# Set up environment variables (.env file)
-SNOWFLAKE_USER=your_user
-SNOWFLAKE_PASSWORD=your_password
-SNOWFLAKE_ACCOUNT=your_account
-SNOWFLAKE_ROLE=your_role
-SNOWFLAKE_DATABASE=MESSAGING_SYSTEM_V2
-SNOWFLAKE_WAREHOUSE=your_warehouse
-SNOWFLAKE_SCHEMA=UI
-
-# LLM API keys
-OPENAI_API_KEY=your_key
-GOOGLE_API_KEY=your_key
-```
-
-### Running the Application
-
-```bash
-# From the visualization directory
-cd visualization
-streamlit run app.py
-```
-
-### First-Time Setup
-
-1. Ensure `.env` file exists with Snowflake credentials
-2. Verify user CSV files exist in `data/UI_users/` for each brand
-3. Create Snowflake tables using schema above (or let system auto-create)
-4. Upload initial configurations to Snowflake (optional - can create in UI)
-5. Login with authorized email and access token
-
----
-
-## 📊 Complete Data Flow
-
-### **Session State Architecture**
-
-All active data lives in Streamlit's `session_state`:
-
-```python
-# Single Experiment Mode
-st.session_state.ui_log_data              # DataFrame: Generated messages
-st.session_state.current_experiment_id    # String: Experiment identifier
-st.session_state.current_experiment_metadata  # List[Dict]: Metadata per stage
-st.session_state.current_feedbacks        # List[Dict]: Feedback records
-
-# AB Testing Mode
-st.session_state.ui_log_data_a            # DataFrame: Experiment A messages
-st.session_state.ui_log_data_b            # DataFrame: Experiment B messages
-st.session_state.experiment_a_id          # String: Experiment A identifier
-st.session_state.experiment_b_id          # String: Experiment B identifier
-st.session_state.experiment_a_metadata    # List[Dict]: A's metadata
-st.session_state.experiment_b_metadata    # List[Dict]: B's metadata
-st.session_state.feedbacks_a              # List[Dict]: A's feedback
-st.session_state.feedbacks_b              # List[Dict]: B's feedback
-
-# Configuration
-st.session_state.campaign_config          # Dict: Single mode config
-st.session_state.campaign_config_a        # Dict: AB mode config A
-st.session_state.campaign_config_b        # Dict: AB mode config B
-st.session_state.configs_cache            # Dict: Cached configs from Snowflake
-```
-
-### **End-to-End Workflow**
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                     1. CAMPAIGN BUILDER                         │
-├─────────────────────────────────────────────────────────────────┤
-│ • Load configs from Snowflake (cached in session_state)         │
-│ • User selects/modifies configuration                           │
-│ • Sample users from CSV files                                   │
-│ • Generate messages (stored in session_state.ui_log_data)       │
-│ • Track metadata (session_state.current_experiment_metadata)    │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│                      2. MESSAGE VIEWER                          │
-├─────────────────────────────────────────────────────────────────┤
-│ • Load messages from session_state.ui_log_data                  │
-│ • Display in user-centric or stage-centric views               │
-│ • User provides feedback (reject messages)                      │
-│ • Feedback stored in session_state.current_feedbacks            │
-│ • [BUTTON] Store Results to Snowflake                          │
-│   → Writes metadata to EXPERIMENT_METADATA table               │
-│   → Writes feedback to FEEDBACKS table                         │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│                        3. ANALYTICS                             │
-├─────────────────────────────────────────────────────────────────┤
-│ • Load current experiment from session_state                    │
-│ • Calculate metrics using SessionFeedbackManager                │
-│ • Show overall performance, stage analysis, rejection reasons   │
-│ • Support AB testing side-by-side comparison                    │
-└─────────────────────────────────────────────────────────────────┘
-                              ↓
-┌─────────────────────────────────────────────────────────────────┐
-│                   4. HISTORICAL ANALYTICS                       │
-├─────────────────────────────────────────────────────────────────┤
-│ • [BUTTON] Load Historical Data from Snowflake                  │
-│ • Query EXPERIMENT_METADATA + FEEDBACKS tables                  │
-│ • Calculate aggregate metrics across all experiments            │
-│ • Show trends: rejection rates over time                        │
-│ • Compare configurations: which performs best                   │
-│ • Filter by date range                                          │
-└─────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 📄 Pages Overview
-
-### Page 0: Home & Authentication (app.py)
-
-**Purpose**: Login, brand selection, config loading, and navigation hub
-
-**Features**:
-- Email and token-based authentication
-- Brand selection (Drumeo, Pianote, Guitareo, Singeo)
-- **Config loading from Snowflake on startup**
-- Brand-specific theming applied throughout app
-- Navigation guide and quick start instructions
-- Current experiment status overview
-
-**Technical Details**:
-- Session-based authentication
-- Brand selection persists via `st.session_state.selected_brand`
-- Configs cached in `st.session_state.configs_cache` on first load
-- Dynamic theming using `utils/theme.py`
-- Loads environment variables from `.env` file
-
-**Key Functions**:
-```python
-def load_configs_from_snowflake(brand):
-    """Load all configs for brand from Snowflake, cache in session_state."""
-    session = create_snowflake_session()
-    config_manager = ConfigManager(session)
-    configs = config_manager.load_configs_from_snowflake(brand)
-    st.session_state.configs_cache = configs
-    session.close()
-```
-
----
-
-### Page 1: Campaign Builder
-
-**Purpose**: Create and run message generation campaigns with integrated A/B testing
-
-**Architecture**: In-memory experiment execution with parallel AB testing
-
-#### Key Features
-
-**Configuration Management**:
-- Loads configs from cached `session_state.configs_cache`
-- Real-time config editing in UI
-- Save configs to Snowflake with auto-versioning
-- Quick save or save-as-new options
-
-**A/B Testing Toggle**:
-- Single Experiment Mode (default): One campaign
-- A/B Testing Mode: Two parallel experiments for comparison
-
-**User Sampling**:
-- Random sampling from brand-specific CSV files
-- 1-25 users selectable
-- Same users used for both AB experiments (fair comparison)
-
-**Parallel Execution**:
-- Uses `ExperimentRunner.run_ab_test_parallel()`
-- Threading for simultaneous A/B generation
-- Separate Snowflake sessions per experiment (no conflicts)
-- Console logging for thread progress
-- Results stored directly in session_state
-
-**Technical Details**:
-
-**Single Mode Generation**:
-```python
-# ExperimentRunner handles all generation logic
-runner = ExperimentRunner(brand=brand, system_config=config)
-
-success, ui_log_data, metadata = runner.run_single_experiment(
-    config=campaign_config,
-    sampled_users_df=users_df,
-    experiment_id=experiment_id,
-    create_session_func=create_snowflake_session,
-    progress_container=st.container()
-)
-
-# Store in session_state
-st.session_state.ui_log_data = ui_log_data
-st.session_state.current_experiment_metadata = metadata
-st.session_state.current_experiment_id = experiment_id
-```
-
-**AB Mode Generation**:
-```python
-# Parallel execution in threads
-results = runner.run_ab_test_parallel(
-    config_a=campaign_config_a,
-    config_b=campaign_config_b,
-    sampled_users_df=users_df,
-    experiment_a_id=experiment_a_id,
-    experiment_b_id=experiment_b_id,
-    create_session_func=create_snowflake_session
-)
-
-# Store both results
-st.session_state.ui_log_data_a = results['a']['ui_log_data']
-st.session_state.ui_log_data_b = results['b']['ui_log_data']
-st.session_state.experiment_a_metadata = results['a']['metadata']
-st.session_state.experiment_b_metadata = results['b']['metadata']
-```
-
-**Configuration Saving to Snowflake**:
-```python
-# Save with auto-versioning
-session = create_snowflake_session()
-db_manager = UIDatabaseManager(session)
-success = db_manager.save_config(
-    config_name=config_name,
-    config_data=campaign_config,
-    brand=brand
-)
-session.close()
-```
-
-**Thread-Safe Progress Handling**:
-- Main thread: Full Streamlit UI updates
-- Worker threads: Console logging only
-- Dummy progress bars prevent Streamlit errors in threads
-
----
-
-### Page 2: Message Viewer
-
-**Purpose**: Browse, search, and evaluate generated messages with A/B testing awareness
-
-**Architecture**: Loads from session_state, feedback stored in-memory
-
-#### Key Features
-
-**Automatic AB Detection**:
-```python
-def detect_ab_testing_mode():
-    """Detect AB mode from session_state."""
-    return (
-        'ui_log_data_a' in st.session_state and
-        'ui_log_data_b' in st.session_state and
-        st.session_state.ui_log_data_a is not None and
-        st.session_state.ui_log_data_b is not None
-    )
-```
-
-**Message Loading**:
-```python
-# Single mode
-def get_single_experiment_data():
-    if 'ui_log_data' in st.session_state:
-        return st.session_state.ui_log_data
-    return None
-
-# AB mode - loads both dataframes
-messages_a_df = st.session_state.ui_log_data_a
-messages_b_df = st.session_state.ui_log_data_b
-```
-
-**Feedback System**:
-- In-memory storage using `SessionFeedbackManager`
-- Rejection categories: Poor header, Poor body, Grammar, Emoji, Recommendation issues, Similar to previous, etc.
-- Stores full message header and body with feedback
-- Undo rejection capability
-
-```python
-# Add feedback
-SessionFeedbackManager.add_feedback(
-    experiment_id=experiment_id,
-    user_id=user_id,
-    stage=stage,
-    feedback_type="reject",
-    rejection_reason="poor_header",
-    rejection_text="Too generic",
-    message_header=header,
-    message_body=body,
-    campaign_name=campaign_name,
-    brand=brand,
-    config_name=config_name,
-    feedback_list_key="current_feedbacks"  # or "feedbacks_a", "feedbacks_b"
-)
-```
-
-**Store Results to Snowflake** (CRITICAL FEATURE):
-
-Located after message viewing section. Button appears prominently.
-
-```python
-if st.button("💾 Store Results to Snowflake"):
-    session = create_snowflake_session()
-    db_manager = UIDatabaseManager(session)
-
-    # Single mode
-    if not ab_mode:
-        # Store metadata
-        for meta in st.session_state.current_experiment_metadata:
-            db_manager.store_experiment_metadata(meta)
-
-        # Store feedback
-        for feedback in st.session_state.current_feedbacks:
-            db_manager.store_feedback(feedback)
-
-    # AB mode
-    else:
-        # Store both experiments
-        for meta in st.session_state.experiment_a_metadata:
-            db_manager.store_experiment_metadata(meta)
-        for meta in st.session_state.experiment_b_metadata:
-            db_manager.store_experiment_metadata(meta)
-
-        for feedback in st.session_state.feedbacks_a:
-            db_manager.store_feedback(feedback)
-        for feedback in st.session_state.feedbacks_b:
-            db_manager.store_feedback(feedback)
-
-    session.close()
-    st.success("✅ Results stored to Snowflake successfully!")
-    st.balloons()
-```
-
-**View Modes**:
-- User-Centric: All stages for each user
-- Stage-Centric: All users for each stage
-- Filters: Stage selection, keyword search, pagination
-
----
-
-### Page 3: Analytics Dashboard
-
-**Purpose**: Visualize performance metrics for CURRENT experiment only
-
-**Architecture**: Loads from session_state, uses SessionFeedbackManager
-
-#### Key Features
-
-**Data Loading**:
-```python
-# Single mode
-def get_single_experiment_data():
-    return st.session_state.ui_log_data
-
-# AB mode
-detect_ab_testing_mode()  # Returns True if AB data exists
-messages_a_df = st.session_state.ui_log_data_a
-messages_b_df = st.session_state.ui_log_data_b
-```
-
-**Feedback Stats Calculation**:
-```python
-# Single mode
-feedback_stats = SessionFeedbackManager.get_feedback_stats(
-    experiment_id=experiment_id,
-    total_messages=len(messages_df),
-    feedback_list_key="current_feedbacks"
-)
-
-# AB mode
-feedback_stats_a = SessionFeedbackManager.get_feedback_stats(
-    experiment_a_id,
-    total_messages=len(messages_a_df),
-    feedback_list_key="feedbacks_a"
-)
-feedback_stats_b = SessionFeedbackManager.get_feedback_stats(
-    experiment_b_id,
-    total_messages=len(messages_b_df),
-    feedback_list_key="feedbacks_b"
-)
-```
-
-**Metrics Displayed**:
-- Overall: Total messages, rejection rate, feedback count
-- Stage-by-Stage: Performance breakdown per stage
-- Rejection Reasons: Pie charts and bar charts
-- AB Comparison: Side-by-side metrics with winner determination
-
-**Export Options**:
-- Export current messages to CSV
-- Export current feedback to CSV
-- Export analytics summary to CSV
-
-**Important**: Analytics page shows ONLY the current in-memory experiment. For historical data, use Historical Analytics.
-
----
-
-### Page 4: Historical Analytics
-
-**Purpose**: Track all past experiments and analyze trends from Snowflake
-
-**Architecture**: Button-triggered Snowflake queries
-
-#### Key Features
-
-**Load Button**:
-```python
-if st.button("📊 Load Historical Data from Snowflake"):
-    session = create_snowflake_session()
-    db_manager = UIDatabaseManager(session)
-
-    # Load experiment summary with JOIN
-    experiments_df = db_manager.get_experiment_summary(brand=brand)
-
-    st.session_state['historical_experiments'] = experiments_df
-    st.session_state['historical_data_loaded'] = True
-
-    session.close()
-```
-
-**SQL Query Example**:
-```sql
-SELECT
-    m.EXPERIMENT_ID,
-    m.CONFIG_NAME,
-    m.CAMPAIGN_NAME,
-    m.BRAND,
-    MIN(m.START_TIME) as start_time,
-    SUM(m.TOTAL_MESSAGES) as total_messages,
-    MAX(m.TOTAL_USERS) as total_users,
-    COUNT(DISTINCT m.STAGE) as total_stages,
-    COUNT(f.FEEDBACK_TYPE) as total_rejects,
-    (COUNT(f.FEEDBACK_TYPE) * 100.0 / NULLIF(SUM(m.TOTAL_MESSAGES), 0)) as rejection_rate
-FROM MESSAGING_SYSTEM_V2.UI.EXPERIMENT_METADATA m
-LEFT JOIN MESSAGING_SYSTEM_V2.UI.FEEDBACKS f
-    ON m.EXPERIMENT_ID = f.EXPERIMENT_ID
-WHERE m.BRAND = :brand
-GROUP BY m.EXPERIMENT_ID, m.CONFIG_NAME, m.CAMPAIGN_NAME, m.BRAND
-ORDER BY start_time DESC
-```
-
-**Visualizations**:
-- Experiments summary table
-- Rejection rate trend over time (line chart)
-- Performance comparison by configuration (bar chart)
-- Best/worst performing configs
-
-**Filters**:
-- Date range filtering
-- Automatic refresh button
-
-**Export**:
-- Export summary to CSV
-- Note: Detailed feedback export coming soon (use SQL queries for now)
-
----
-
-## 🔧 Utility Modules
-
-### utils/db_manager.py - UIDatabaseManager
-
-**Purpose**: All Snowflake database operations
-
-**Key Methods**:
-```python
-class UIDatabaseManager:
-    def __init__(self, session: Session):
-        """Initialize with Snowflake session."""
-
-    def save_config(self, config_name, config_data, brand):
-        """Save config with auto-versioning."""
-
-    def load_config(self, config_name, brand, version=None):
-        """Load specific config version."""
-
-    def store_experiment_metadata(self, metadata: dict):
-        """Insert metadata record."""
-
-    def store_feedback(self, feedback: dict):
-        """Insert feedback record."""
-
-    def get_experiment_summary(self, brand=None, start_date=None, end_date=None):
-        """Get aggregated experiment metrics with JOIN."""
-
-    def close(self):
-        """Close Snowflake session."""
-```
-
-**Usage Pattern**:
-```python
-# Always use context-like pattern
-session = create_snowflake_session()
-db_manager = UIDatabaseManager(session)
-
-try:
-    # Do operations
-    db_manager.save_config(...)
-    db_manager.store_feedback(...)
-finally:
-    db_manager.close()  # or session.close()
-```
-
----
-
-### utils/config_manager.py - ConfigManager
-
-**Purpose**: Configuration loading and caching
-
-**Key Methods**:
-```python
-class ConfigManager:
-    def __init__(self, session: Session):
-        """Initialize with Snowflake session."""
-
-    def load_configs_from_snowflake(self, brand: str) -> Dict:
-        """Load all configs for brand, returns {name: config_data}."""
-
-    def get_latest_version(self, config_name: str, brand: str) -> int:
-        """Get latest version number."""
-```
-
-**Caching Strategy**:
-- Configs loaded once on app startup
-- Cached in `st.session_state.configs_cache`
-- Format: `{"config_name": {...config_data...}, ...}`
-- No re-querying Snowflake during session
-
----
-
-### utils/experiment_runner.py - ExperimentRunner
-
-**Purpose**: Execute experiments with proper session management
-
-**Key Methods**:
-```python
-class ExperimentRunner:
-    def run_single_experiment(
-        self, config, sampled_users_df, experiment_id,
-        create_session_func, progress_container
-    ):
-        """Run one experiment, all stages sequentially."""
-
-    def run_ab_test_parallel(
-        self, config_a, config_b, sampled_users_df,
-        experiment_a_id, experiment_b_id, create_session_func
-    ):
-        """Run two experiments in parallel threads."""
-```
-
-**Thread-Safe Design**:
-- Each thread gets own Snowflake session
-- Progress updates handled safely:
-  - Main thread: Full Streamlit UI
-  - Worker threads: Console logging with dummy UI objects
-- No Streamlit context errors
-
-**Implementation**:
-```python
-# Thread function
-def run_experiment(exp_key, config, exp_id):
-    try:
-        success, data, metadata = self.run_single_experiment(
-            config=config,
-            sampled_users_df=users_df,
-            experiment_id=exp_id,
-            create_session_func=create_session_func,
-            progress_container=None  # None = threaded mode
-        )
-        results[exp_key] = {'success': success, 'ui_log_data': data, 'metadata': metadata}
-    except Exception as e:
-        results[exp_key] = {'success': False, 'error': str(e)}
-
-# Start threads
-thread_a = threading.Thread(target=run_experiment, args=('a', config_a, exp_a_id))
-thread_b = threading.Thread(target=run_experiment, args=('b', config_b, exp_b_id))
-thread_a.start()
-thread_b.start()
-thread_a.join()
-thread_b.join()
-```
-
----
-
-### utils/session_feedback_manager.py - SessionFeedbackManager
-
-**Purpose**: In-memory feedback management
-
-**Static Methods** (no instance needed):
-```python
-@staticmethod
-def add_feedback(experiment_id, user_id, stage, feedback_type,
-                 rejection_reason, rejection_text, message_header,
-                 message_body, campaign_name, brand, config_name,
-                 feedback_list_key):
-    """Add feedback to session_state list."""
-
-@staticmethod
-def get_feedback_stats(experiment_id, total_messages, feedback_list_key):
-    """Calculate aggregate stats from feedback list."""
-
-@staticmethod
-def get_stage_feedback_stats(experiment_id, messages_df, feedback_list_key):
-    """Calculate per-stage stats."""
-
-@staticmethod
-def get_rejection_reason_label(reason_key):
-    """Map reason key to display label."""
-```
-
-**Feedback List Keys**:
-- `"current_feedbacks"` - Single mode
-- `"feedbacks_a"` - AB mode experiment A
-- `"feedbacks_b"` - AB mode experiment B
-
-**Usage**:
-```python
-# Add feedback
-SessionFeedbackManager.add_feedback(
-    experiment_id="drumeo_20260114_1234",
-    user_id=12345,
-    stage=1,
-    feedback_type="reject",
-    rejection_reason="poor_header",
-    rejection_text="Too generic",
-    message_header="Your next lesson 👇",
-    message_body="Check it out...",
-    campaign_name="Re-engagement",
-    brand="drumeo",
-    config_name="drumeo_re_engagement_test",
-    feedback_list_key="current_feedbacks"
-)
-
-# Get stats
-stats = SessionFeedbackManager.get_feedback_stats(
-    experiment_id="drumeo_20260114_1234",
-    total_messages=100,
-    feedback_list_key="current_feedbacks"
-)
-# Returns: {'total_feedback': 10, 'total_rejects': 10,
-#           'reject_rate': 10.0, 'rejection_reasons': {...}}
-```
-
----
-
-## 🎨 Brand Theming
-
-Theming automatically adjusts based on selected brand:
-
-| Brand    | Primary Color | Sidebar BG | Accent   | Emoji |
-|----------|---------------|------------|----------|-------|
-| Base     | Gold          | Dark Gold  | Gold     | 🎵    |
-| Drumeo   | Light Blue    | Dark Blue  | Blue     | 🥁    |
-| Pianote  | Light Red     | Dark Red   | Red      | 🎹    |
-| Guitareo | Light Green   | Dark Green | Green    | 🎸    |
-| Singeo   | Light Purple  | Dark Purple| Purple   | 🎤    |
-
-**Implementation**: `utils/theme.py`
-
-```python
-def get_brand_theme(brand):
-    """Returns theme dictionary."""
-
-def apply_theme(brand):
-    """Applies CSS via st.markdown."""
-
-def get_brand_emoji(brand):
-    """Returns brand emoji."""
-```
-
----
-
-## 🔍 Key Implementation Details
-
-### Configuration File Structure
-
-```json
-{
-  "brand": "drumeo",
-  "campaign_type": "re_engagement",
-  "campaign_name": "UI-Test-Campaign",
-  "campaign_instructions": "Keep messages encouraging and motivational.",
-  "1": {
-    "stage": 1,
-    "model": "gemini-2.5-flash-lite",
-    "personalization": true,
-    "involve_recsys_result": true,
-    "recsys_contents": ["workout", "course", "quick_tips"],
-    "specific_content_id": null,
-    "segment_info": "Students inactive for 3+ days",
-    "instructions": "",
-    "sample_examples": "Header: Your next lesson 👇\nMessage: Check it out!",
-    "identifier_column": "user_id",
-    "platform": "push"
-  },
-  "2": {
-    "stage": 2,
-    "model": "gpt-4o-mini",
-    "personalization": true,
-    "involve_recsys_result": true,
-    "recsys_contents": ["song"],
-    "specific_content_id": 12345,
-    "segment_info": "Students inactive for 7+ days",
-    "instructions": "Focus on easy songs",
-    "sample_examples": "Header: Let's jam! 🎸\nMessage: Try this song!",
-    "identifier_column": "user_id",
-    "platform": "push"
-  }
-}
-```
-
-### Rejection Reason Categories
-
-```python
-REJECTION_REASONS = {
-    "poor_header": "Poor Header",
-    "poor_body": "Poor Body/Content",
-    "grammar_issues": "Grammar Issues",
-    "emoji_problems": "Emoji Problems",
-    "recommendation_issues": "Recommendation Issues",
-    "wrong_information": "Wrong/Inaccurate Information",
-    "tone_issues": "Tone Issues",
-    "similarity": "Similar To Previous Header/Messages",
-    "other": "Other"
-}
-```
-
-### Environment Variables Required
-
-```bash
-# Snowflake
-SNOWFLAKE_USER=your_user
-SNOWFLAKE_PASSWORD=your_password
-SNOWFLAKE_ACCOUNT=your_account
-SNOWFLAKE_ROLE=your_role
-SNOWFLAKE_DATABASE=MESSAGING_SYSTEM_V2
-SNOWFLAKE_WAREHOUSE=your_warehouse
-SNOWFLAKE_SCHEMA=UI
-
-# LLM APIs
-OPENAI_API_KEY=sk-...
-GOOGLE_API_KEY=AIza...
-```
-
----
-
-## 🛠️ Development Guide
-
-### Adding a New Page
-
-1. Create `pages/{number}_{Name}.py`
-2. Follow standard structure:
-```python
-import streamlit as st
-import os
-from pathlib import Path
-from dotenv import load_dotenv
-
-# Load .env
-env_path = Path(__file__).parent.parent.parent / '.env'
-if env_path.exists():
-    load_dotenv(env_path)
-
-from utils.auth import check_authentication
-from utils.theme import apply_theme, get_brand_emoji
-
-st.set_page_config(page_title="New Page", page_icon="🆕", layout="wide")
-
-if not check_authentication():
-    st.error("🔒 Please login first")
-    st.stop()
-
-if "selected_brand" not in st.session_state:
-    st.error("⚠️ Please select a brand first")
-    st.stop()
-
-brand = st.session_state.selected_brand
-apply_theme(brand)
-
-# Your content here
-```
-3. Update `app.py` navigation
-4. Test with all brands
-
-### Adding a New Feedback Category
-
-1. Update `utils/session_feedback_manager.py`:
-```python
-REJECTION_REASONS = {
-    # ... existing
-    "new_reason": "New Reason Label"
-}
-```
-2. Automatically appears in UI
-
-### Adding a New Brand
-
-1. Create `data/UI_users/{brand}_users.csv` (100 users, must have `USER_ID` column)
-2. Add to `utils/theme.py`:
-```python
-BRAND_THEMES["newbrand"] = {
-    "primary": "#COLOR",
-    "accent": "#COLOR",
-    "sidebar_bg": "#DARK_COLOR",
-    "text": "#FFFFFF"
-}
-BRAND_EMOJIS["newbrand"] = "🆕"
-```
-3. Update `app.py`:
-```python
-brands = ["drumeo", "pianote", "guitareo", "singeo", "newbrand"]
-brand_labels["newbrand"] = "🆕 New Brand"
-```
-4. Create default config in Snowflake or via UI
-
-### Debugging Tips
-
-**Common Issues**:
-
-1. **"No messages found"** in Message Viewer:
-   - Check `st.session_state.ui_log_data` exists
-   - Verify generation completed in Campaign Builder
-   - Look for errors in terminal
-
-2. **Snowflake connection errors**:
-   - Verify `.env` file exists and is loaded
-   - Check credentials are correct
-   - Test connection: `create_snowflake_session()`
-
-3. **AB test AttributeError**:
-   - Fixed in latest version
-   - Ensure ExperimentRunner uses thread-safe progress handling
-
-4. **Config save errors with quotes**:
-   - Fixed: Now uses `write_pandas()` instead of raw SQL
-   - Handles JSON with apostrophes correctly
-
-5. **Feedback not in Analytics**:
-   - Check `st.session_state.current_feedbacks` has data
-   - Verify correct feedback_list_key used
-   - Check experiment_id matches
-
-**Debugging Code**:
-```python
-# Debug session state
-with st.expander("Debug Info"):
-    st.write("Session State Keys:", list(st.session_state.keys()))
-    if 'ui_log_data' in st.session_state:
-        st.write("Messages shape:", st.session_state.ui_log_data.shape)
-    if 'current_feedbacks' in st.session_state:
-        st.write("Feedback count:", len(st.session_state.current_feedbacks))
-```
-
----
-
-## 🎯 Key Design Decisions
-
-### 1. In-Memory + Cloud Hybrid
-**Decision**: Use session_state for active data, Snowflake for persistence
-**Rationale**:
-- Fast in-memory operations
-- No local file dependencies (HuggingFace ready)
-- Scalable historical storage
-- Clean separation: current vs. historical
-
-### 2. One-Click Storage
-**Decision**: Single "Store Results" button to persist everything
-**Rationale**:
-- Simple user workflow
-- Explicit persistence action
-- User controls when data is saved
-- No auto-save surprises
-
-### 3. Config Caching
-**Decision**: Load all configs once, cache in session_state
-**Rationale**:
-- Reduces Snowflake queries
-- Faster config switching
-- Session-scoped cache (fresh on page load)
-- No stale data issues
-
-### 4. Thread-Safe AB Testing
-**Decision**: Separate Snowflake sessions per thread, console logging
-**Rationale**:
-- Prevents session conflicts
-- Streamlit UI only in main thread
-- Clean error handling
-- Production-ready parallel execution
-
-### 5. Versioned Configurations
-**Decision**: Auto-increment version on every config save
-**Rationale**:
-- Full audit trail
-- Can rollback to previous versions
-- Supports experimentation
-- No data loss
-
-### 6. Button-Triggered Historical Loading
-**Decision**: Historical Analytics loads on button click, not auto
-**Rationale**:
-- User controls when to query Snowflake
-- Avoids unnecessary queries
-- Faster page load
-- Clear user action
-
-### 7. SessionFeedbackManager Static Methods
-**Decision**: All methods static, no instance needed
-**Rationale**:
-- Simpler API
-- Works directly with session_state
-- No state to manage
-- Cleaner code
-
----
-
-## 🚀 Deployment Guide
-
-### HuggingFace Spaces Deployment
-
-**Requirements**:
-- No local file dependencies ✅
-- Environment variables for secrets ✅
-- Snowflake connectivity ✅
-- CSV files in repo (data/UI_users/) ✅
-
-**Steps**:
-1. Push code to GitHub/HuggingFace repo
-2. Include `data/UI_users/` CSV files
-3. Set environment variables in Space settings:
-   - All SNOWFLAKE_* variables
-   - All API keys
-4. Run: `streamlit run app.py`
-5. Verify Snowflake connection works
-
-**Files to Exclude**:
-- `.env` (use Space secrets instead)
-- Local cache directories
-- Test data
-
----
-
-## 📞 Support & Resources
-
-**Contact**:
-- Technical Support: danial@musora.com
-
-**Related Documentation**:
-- Main System: `ai_messaging_system_v2/README.md`
-- UI Mode Guide: `ai_messaging_system_v2/UI_MODE_GUIDE.md`
-- Implementation Details: `visualization/IMPLEMENTATION_COMPLETE.md`
-- Refactoring Guide: `visualization/ARCHITECTURE_REFACTOR_GUIDE.md`
-
-**Useful Links**:
-- Streamlit Documentation: https://docs.streamlit.io
-- Snowflake Python Connector: https://docs.snowflake.com/en/developer-guide/python-connector/python-connector
-- Plotly Charts: https://plotly.com/python/
-
----
-
-## 📊 System Status
-
-**Completion**: 100% ✅
-
-**Completed Components**:
-1. ✅ Database Layer (db_manager.py)
-2. ✅ Config Manager (config_manager.py)
-3. ✅ Session Feedback Manager (session_feedback_manager.py)
-4. ✅ Experiment Runner (experiment_runner.py)
-5. ✅ App.py - Authentication & config loading
-6. ✅ Campaign Builder - Generation & AB testing
-7. ✅ Message Viewer - Viewing & feedback
-8. ✅ Analytics - Current experiment metrics
-9. ✅ Historical Analytics - Snowflake integration
-
-**Recent Fixes**:
-- ✅ Configuration save error (JSON escaping) - Fixed with `write_pandas()`
-- ✅ AB testing `AttributeError: enter` - Fixed with thread-safe design
-- ✅ Historical Analytics Snowflake connection - Fixed to use `.env`
-
-**Ready For**:
-- ✅ Production use
-- ✅ HuggingFace deployment
-- ✅ End-to-end testing
-- ✅ Team onboarding
-
----
-
-**Built with ❤️ for the Musora team**
-
-**Last Updated**: 2026-01-14
-**Version**: 2.0 (Refactored Architecture)

visualization/app.py

@@ -1,384 +0,0 @@
-"""
-AI Messaging System - Visualization Tool
-Main entry point with authentication and brand selection.
-"""
-
-import streamlit as st
-import sys
-from pathlib import Path
-from dotenv import load_dotenv
-
-# Load environment variables from .env file FIRST
-env_path = Path(__file__).parent / '.env'
-if env_path.exists():
-    load_dotenv(env_path)
-else:
-    # Try parent directory .env as fallback
-    parent_env_path = Path(__file__).parent.parent / '.env'
-    if parent_env_path.exists():
-        load_dotenv(parent_env_path)
-
-# Add parent directory to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from utils.auth import verify_login, check_authentication, get_current_user, logout
-from utils.theme import apply_theme, get_brand_emoji, get_brand_theme
-from utils.data_loader import DataLoader
-from utils.config_manager import ConfigManager
-from snowflake.snowpark import Session
-import os
-
-# Page configuration
-st.set_page_config(
-    page_title="AI Messaging System - Visualization",
-    page_icon="🎵",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Helper function to create Snowflake session
-def create_snowflake_session() -> Session:
-    """Create a Snowflake session using environment variables."""
-    conn_params = {
-        "user": os.getenv("SNOWFLAKE_USER"),
-        "password": os.getenv("SNOWFLAKE_PASSWORD"),
-        "account": os.getenv("SNOWFLAKE_ACCOUNT"),
-        "role": os.getenv("SNOWFLAKE_ROLE"),
-        "database": os.getenv("SNOWFLAKE_DATABASE"),
-        "warehouse": os.getenv("SNOWFLAKE_WAREHOUSE"),
-        "schema": os.getenv("SNOWFLAKE_SCHEMA"),
-    }
-    return Session.builder.configs(conn_params).create()
-
-
-# Initialize session state
-def init_session_state():
-    """Initialize session state variables."""
-    defaults = {
-        # Authentication
-        "authenticated": False,
-        "user_email": "",
-
-        # Brand and configs
-        "selected_brand": None,
-        "cached_configs": {},  # Cache configs per brand: {brand: {config_name: config_data}}
-        "configs_loaded": False,
-
-        # Current experiment data (in-memory)
-        "current_experiment_id": None,
-        "ui_log_data": None,  # Accumulated dataframe for multi-stage messages
-        "current_experiment_metadata": [],  # List of metadata dicts per stage
-        "current_feedbacks": [],  # List of feedback dicts
-
-        # AB Testing data
-        "ab_testing_mode": False,
-        "ui_log_data_a": None,
-        "ui_log_data_b": None,
-        "experiment_a_id": None,
-        "experiment_b_id": None,
-        "experiment_a_metadata": [],
-        "experiment_b_metadata": [],
-        "feedbacks_a": [],
-        "feedbacks_b": [],
-    }
-    for key, value in defaults.items():
-        if key not in st.session_state:
-            st.session_state[key] = value
-
-
-init_session_state()
-
-# Authentication check
-if not check_authentication():
-    # Show login page
-    st.title("🔐 AI Messaging System - Login")
-
-    st.markdown("""
-    Welcome to the **AI Messaging System Visualization Tool**!
-
-    This tool enables you to:
-    - 🏗️ Build and configure message campaigns
-    - 👀 Visualize generated messages across all stages
-    - 📊 Analyze performance and provide feedback
-    - 🧪 Run A/B tests to compare different approaches
-
-    ---
-
-    **Access is restricted to authorized team members only.**
-    Please enter your credentials below.
-    """)
-
-    with st.form("login_form"):
-        email = st.text_input("📧 Email Address", placeholder="your.name@musora.com")
-        token = st.text_input("🔑 Access Token", type="password", placeholder="Enter your access token")
-        submit = st.form_submit_button("🚀 Login", use_container_width=True)
-
-    if submit:
-        if verify_login(email, token):
-            st.session_state.authenticated = True
-            st.session_state.user_email = email
-            st.success("✅ Login successful! Redirecting...")
-            st.rerun()
-        else:
-            st.error("❌ Invalid email or access token. Please try again.")
-
-    st.stop()
-
-# User is authenticated - show main app
-# Apply base theme initially
-apply_theme("base")
-
-# Sidebar - Brand Selection
-with st.sidebar:
-    st.title("🎵 AI Messaging System")
-
-    st.markdown(f"**Logged in as:** {get_current_user()}")
-
-    if st.button("🚪 Logout", use_container_width=True):
-        logout()
-        st.rerun()
-
-    st.markdown("---")
-
-    # Brand Selection
-    st.subheader("🎨 Select Brand")
-
-    brands = ["drumeo", "pianote", "guitareo", "singeo"]
-    brand_labels = {
-        "drumeo": "🥁 Drumeo",
-        "pianote": "🎹 Pianote",
-        "guitareo": "🎸 Guitareo",
-        "singeo": "🎤 Singeo"
-    }
-
-    # Get current brand from session state if exists
-    current_brand = st.session_state.get("selected_brand", brands[0])
-
-    selected_brand = st.selectbox(
-        "Brand",
-        brands,
-        index=brands.index(current_brand) if current_brand in brands else 0,
-        format_func=lambda x: brand_labels[x],
-        key="brand_selector",
-        label_visibility="collapsed"
-    )
-
-    # Check if brand changed
-    brand_changed = (st.session_state.selected_brand != selected_brand)
-
-    # Update session state with selected brand
-    st.session_state.selected_brand = selected_brand
-
-    # Load configs from Snowflake if brand changed or not loaded yet
-    if brand_changed or not st.session_state.get("configs_loaded", False):
-        if selected_brand:
-            with st.spinner(f"Loading configurations for {selected_brand}..."):
-                try:
-                    # Create Snowflake session for config loading
-                    session = create_snowflake_session()
-
-                    # Initialize config manager with session
-                    config_manager = ConfigManager(session)
-
-                    # Load all configs for this brand
-                    configs = config_manager.get_all_configs(selected_brand)
-
-                    # Cache in session state
-                    if selected_brand not in st.session_state.cached_configs:
-                        st.session_state.cached_configs[selected_brand] = {}
-                    st.session_state.cached_configs[selected_brand] = configs
-                    st.session_state.configs_loaded = True
-
-                    # Close session after loading
-                    session.close()
-
-                    st.success(f"✅ Loaded {len(configs)} configurations from Snowflake")
-
-                except Exception as e:
-                    st.error(f"❌ Error loading configs from Snowflake: {e}")
-                    st.info("💡 Make sure Snowflake credentials are set in .env file")
-
-    # Apply brand theme
-    if selected_brand:
-        apply_theme(selected_brand)
-
-    st.markdown("---")
-
-    # Navigation info
-    st.subheader("📖 Navigation")
-    st.markdown("""
-    Use the pages in the sidebar to navigate:
-    - **Campaign Builder**: Create campaigns & A/B tests
-    - **Message Viewer**: Review messages
-    - **Analytics**: View current performance
-    - **Historical Analytics**: Track improvements
-    """)
-
-# Main Content Area
-if not selected_brand:
-    st.title("🎵 Welcome to AI Messaging System")
-
-    st.markdown("""
-    ### Get Started
-
-    **Please select a brand from the sidebar to begin.**
-
-    Once you've selected a brand, you can:
-
-    1. **Build Campaigns** - Configure and generate personalized messages
-    2. **View Messages** - Browse and provide feedback on generated messages
-    3. **Run A/B Tests** - Compare different configurations side-by-side
-    4. **Analyze Results** - Review performance metrics and insights
-    """)
-
-    # Show feature cards
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.markdown("""
-        #### 🏗️ Campaign Builder
-        - Configure multi-stage campaigns
-        - Built-in A/B testing mode
-        - Parallel experiment processing
-        - Automatic experiment archiving
-        - Save custom configurations
-        """)
-
-        st.markdown("""
-        #### 👀 Message Viewer
-        - View all generated messages
-        - Side-by-side A/B comparison
-        - User-centric or stage-centric views
-        - Search and filter messages
-        - Provide detailed feedback
-        """)
-
-    with col2:
-        st.markdown("""
-        #### 📊 Analytics Dashboard
-        - Real-time performance metrics
-        - A/B test winner determination
-        - Rejection reason analysis
-        - Stage-by-stage performance
-        - Export capabilities
-        """)
-
-        st.markdown("""
-        #### 📚 Historical Analytics
-        - Track all past experiments
-        - Rejection rate trends over time
-        - Compare historical A/B tests
-        - Export historical data
-        """)
-
-else:
-    # Brand is selected - show brand-specific homepage
-    emoji = get_brand_emoji(selected_brand)
-    theme = get_brand_theme(selected_brand)
-
-    st.title(f"{emoji} {selected_brand.title()} - AI Messaging System")
-
-    st.markdown(f"""
-    ### Welcome to {selected_brand.title()} Message Generation!
-
-    You're all set to create personalized messages for {selected_brand.title()} users.
-    """)
-
-    # Quick stats
-    data_loader = DataLoader()
-
-    # Check if we have brand users
-    has_users = data_loader.has_brand_users(selected_brand)
-
-    # Check if we have generated messages
-    messages_df = data_loader.load_generated_messages()
-    has_messages = messages_df is not None and len(messages_df) > 0
-
-    st.markdown("---")
-
-    # Status cards
-    col1, col2, col3 = st.columns(3)
-
-    with col1:
-        st.markdown("### 👥 Available Users")
-        if has_users:
-            user_count = data_loader.get_brand_user_count(selected_brand)
-            st.metric("Users Available", user_count)
-            st.success(f"✅ {user_count} users ready")
-        else:
-            st.metric("Users Available", 0)
-            st.info("ℹ️ No users available")
-
-    with col2:
-        st.markdown("### 📨 Generated Messages")
-        if has_messages:
-            stats = data_loader.get_message_stats()
-            st.metric("Total Messages", stats['total_messages'])
-            st.success(f"✅ {stats['total_stages']} stages")
-        else:
-            st.metric("Total Messages", 0)
-            st.info("ℹ️ No messages generated yet")
-
-    with col3:
-        st.markdown("### 🎯 Quick Actions")
-        st.markdown("")  # spacing
-        if st.button("🏗️ Build Campaign", use_container_width=True):
-            st.switch_page("pages/1_Campaign_Builder.py")
-        if has_messages:
-            if st.button("👀 View Messages", use_container_width=True):
-                st.switch_page("pages/2_Message_Viewer.py")
-
-    st.markdown("---")
-
-    # Getting started guide
-    st.markdown("### 🚀 Quick Start Guide")
-
-    st.markdown("""
-    #### Step 1: Build a Campaign
-    Navigate to **Campaign Builder** to:
-    - Toggle A/B testing mode on/off as needed
-    - Select number of users to experiment with (1-25)
-    - Configure campaign stages (or two experiments side-by-side)
-    - Set LLM models and instructions
-    - Generate personalized messages with automatic archiving
-
-    #### Step 2: Review Messages
-    Go to **Message Viewer** to:
-    - Browse all generated messages
-    - View A/B tests side-by-side automatically
-    - Switch between user-centric and stage-centric views
-    - Provide detailed feedback with rejection reasons
-    - Track message headers and content
-
-    #### Step 3: Analyze Performance
-    Check **Analytics Dashboard** for:
-    - Real-time approval and rejection rates
-    - A/B test comparisons with winner determination
-    - Common rejection reasons with visual charts
-    - Stage-by-stage performance insights
-    - Export analytics data
-
-    #### Step 4: Track Improvements
-    View **Historical Analytics** to:
-    - See all past experiments over time
-    - Identify rejection rate trends
-    - Compare historical A/B tests
-    - Export comprehensive historical data
-    """)
-
-    st.markdown("---")
-
-    # Tips
-    with st.expander("💡 Tips & Best Practices"):
-        st.markdown("""
-        - **User Selection**: Select 1-25 users for quick experimentation
-        - **Configuration Templates**: Start with default configurations and customize as needed
-        - **A/B Testing**: Enable A/B mode in Campaign Builder to compare two configurations in parallel
-        - **Feedback**: Reject poor messages with specific categories including the new 'Similar To Previous' option
-        - **Historical Tracking**: Check Historical Analytics regularly to track improvements over time
-        - **Stage Design**: Each stage should build upon previous stages with varied messaging approaches
-        - **Automatic Archiving**: Previous experiments are automatically archived when you start a new one
-        """)
-
-st.markdown("---")
-st.markdown("**Built with ❤️ for the Musora team**")

visualization/data/UI_users/drumeo_users.csv

@@ -1,101 +0,0 @@
-USER_ID
-668594
-268920
-223559
-830729
-356828
-703749
-840761
-773120
-847327
-566765
-843750
-825806
-551310
-924846
-655113
-576751
-334867
-691463
-680767
-812160
-164216
-881978
-539894
-566222
-660036
-531101
-591381
-876151
-596577
-910512
-395956
-173257
-792254
-911568
-914399
-903638
-736051
-675660
-892433
-346547
-824636
-774712
-488145
-688315
-546326
-610623
-560107
-356255
-757824
-826319
-272269
-919799
-670740
-919348
-324493
-284107
-772112
-821339
-433101
-705894
-775898
-922718
-627434
-811134
-922432
-922696
-934924
-158386
-488116
-167704
-721421
-785019
-831724
-928899
-911985
-911041
-552685
-391892
-265614
-916134
-402573
-900149
-717562
-161665
-389376
-509974
-913237
-760712
-415475
-346652
-604378
-817870
-698502
-904044
-931916
-662869
-837947
-666152
-367181
-510852

visualization/data/UI_users/guitareo_users.csv

@@ -1,101 +0,0 @@
-USER_ID
-157715
-911553
-156907
-694766
-914407
-158017
-157707
-931216
-157275
-157049
-762379
-922989
-894939
-156233
-445299
-893526
-502852
-412696
-524379
-934803
-533843
-918486
-326346
-825138
-510105
-836199
-903763
-847337
-920186
-367515
-464147
-876953
-820530
-483932
-804270
-652888
-611387
-901114
-161990
-858049
-504479
-793688
-596030
-856499
-830288
-905807
-737373
-801123
-936207
-161806
-844885
-156673
-156417
-166828
-157214
-163682
-157637
-815647
-445428
-848726
-345886
-645329
-908931
-157569
-900579
-161677
-898048
-429111
-902004
-161816
-676947
-160755
-921572
-453858
-548274
-922381
-825297
-720840
-449753
-504742
-157789
-162667
-920329
-157258
-739976
-641480
-157176
-565814
-870217
-574774
-420668
-344602
-918695
-174797
-270977
-903413
-157324
-158234
-156592
-491409

visualization/data/UI_users/pianote_users.csv

@@ -1,101 +0,0 @@
-USER_ID
-901462
-663534
-925578
-808019
-727360
-907785
-903125
-358505
-903293
-926435
-577983
-640044
-871545
-689297
-839797
-838978
-894404
-388259
-742545
-875618
-906682
-156360
-615274
-496647
-837649
-819147
-762360
-667066
-922040
-165396
-491498
-643639
-388015
-876565
-391879
-451960
-508244
-426511
-401073
-869259
-522076
-631399
-428081
-867206
-815870
-458726
-547732
-554044
-364525
-825266
-844418
-818026
-751982
-356018
-345635
-427868
-586083
-166330
-825075
-343531
-843298
-558798
-352221
-558176
-813053
-386914
-154237
-362024
-855589
-807289
-307320
-623466
-825321
-605229
-348870
-388261
-519602
-153096
-586282
-716526
-401891
-874652
-834192
-732481
-508825
-859490
-519051
-482569
-518170
-541203
-421310
-550180
-406176
-520979
-593825
-549999
-483788
-841717
-703563
-364690

visualization/data/UI_users/singeo_users.csv

@@ -1,101 +0,0 @@
-USER_ID
-397959
-807871
-532351
-344867
-491564
-687686
-912997
-757896
-475186
-559116
-476436
-430839
-929828
-546602
-660403
-809863
-930638
-308771
-156181
-832580
-642142
-484262
-672837
-723502
-735251
-440691
-676900
-891419
-912102
-605067
-727808
-449959
-295615
-934452
-932834
-631715
-933185
-247877
-550753
-841927
-795745
-555274
-679834
-675272
-911688
-689022
-414410
-502875
-649091
-540841
-616322
-761625
-534677
-830290
-870293
-510636
-932700
-533364
-540891
-584369
-739290
-914907
-934815
-760925
-411509
-420037
-566575
-667578
-483362
-787773
-164176
-876127
-344023
-634693
-365543
-160559
-474363
-675851
-934109
-563890
-875101
-768715
-405549
-509855
-615509
-800896
-901230
-444234
-152323
-610485
-628039
-854271
-503894
-339113
-441986
-721231
-486789
-807279
-749298
-923577

visualization/pages/1_Campaign_Builder.py

@@ -1,1100 +0,0 @@
-"""
-Page 1: Campaign Builder
-Configure and run message generation campaigns with A/B testing support.
-"""
-
-import streamlit as st
-import sys
-from pathlib import Path
-from datetime import datetime
-import json
-import threading
-import shutil
-
-# Add parent directories to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from utils.auth import check_authentication
-from utils.theme import apply_theme, get_brand_emoji
-from utils.data_loader import DataLoader
-from utils.config_manager import ConfigManager
-from utils.db_manager import UIDatabaseManager
-from utils.experiment_runner import ExperimentRunner
-
-from ai_messaging_system_v2.Messaging_system.Permes import Permes
-from ai_messaging_system_v2.configs.config_loader import get_system_config
-from snowflake.snowpark import Session
-from dotenv import load_dotenv
-import os
-
-# Load environment variables
-env_path = Path(__file__).parent.parent / '.env'
-if env_path.exists():
-    load_dotenv(env_path)
-else:
-    parent_env_path = Path(__file__).parent.parent.parent / '.env'
-    if parent_env_path.exists():
-        load_dotenv(parent_env_path)
-
-# Page configuration
-st.set_page_config(
-    page_title="Campaign Builder",
-    page_icon="🏗️",
-    layout="wide"
-)
-
-# Check authentication
-if not check_authentication():
-    st.error("🔒 Please login first")
-    st.stop()
-
-# Initialize utilities
-data_loader = DataLoader()
-# Initialize config_manager for utility methods (create_config_from_ui, validate_config)
-# These methods don't require a database session
-config_manager = ConfigManager(session=None)
-# Note: For saving configs, we'll create a new ConfigManager with a Snowflake session
-# For loading, we use cached configs from session_state
-
-# Helper function to create Snowflake session
-def create_snowflake_session() -> Session:
-    """Create a Snowflake session using environment variables."""
-    conn_params = {
-        "user": os.getenv("SNOWFLAKE_USER"),
-        "password": os.getenv("SNOWFLAKE_PASSWORD"),
-        "account": os.getenv("SNOWFLAKE_ACCOUNT"),
-        "role": os.getenv("SNOWFLAKE_ROLE"),
-        "database": os.getenv("SNOWFLAKE_DATABASE"),
-        "warehouse": os.getenv("SNOWFLAKE_WAREHOUSE"),
-        "schema": os.getenv("SNOWFLAKE_SCHEMA"),
-    }
-    return Session.builder.configs(conn_params).create()
-
-# Check if brand is selected
-if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
-    st.error("⚠️ Please select a brand from the home page first")
-    st.stop()
-
-brand = st.session_state.selected_brand
-apply_theme(brand)
-
-# Initialize session state
-if "ab_testing_mode" not in st.session_state:
-    st.session_state.ab_testing_mode = False
-if "campaign_config" not in st.session_state:
-    st.session_state.campaign_config = None
-if "campaign_config_a" not in st.session_state:
-    st.session_state.campaign_config_a = None
-if "campaign_config_b" not in st.session_state:
-    st.session_state.campaign_config_b = None
-if "selected_user_count" not in st.session_state:
-    st.session_state.selected_user_count = 5
-if "generation_complete" not in st.session_state:
-    st.session_state.generation_complete = False
-if "show_next_steps" not in st.session_state:
-    st.session_state.show_next_steps = False
-
-# Page Header
-emoji = get_brand_emoji(brand)
-st.title(f"🏗️ Campaign Builder - {emoji} {brand.title()}")
-st.markdown("**Configure and generate personalized message campaigns**")
-
-st.markdown("---")
-
-# ============================================================================
-# A/B TESTING TOGGLE
-# ============================================================================
-ab_col1, ab_col2 = st.columns([3, 1])
-
-with ab_col1:
-    st.subheader("🧪 Experiment Mode")
-    st.markdown("Toggle A/B testing to run two experiments in parallel with different configurations.")
-
-with ab_col2:
-    ab_testing_enabled = st.toggle(
-        "Enable A/B Testing",
-        value=st.session_state.ab_testing_mode,
-        help="Enable to run two experiments (A and B) in parallel"
-    )
-    st.session_state.ab_testing_mode = ab_testing_enabled
-
-st.markdown("---")
-
-# ============================================================================
-# HELPER FUNCTIONS FOR CONFIGURATION SECTIONS
-# ============================================================================
-
-def render_configuration_section(prefix: str, col_container, initial_config=None):
-    """
-    Render a configuration section (used for both single mode and A/B mode).
-
-    Args:
-        prefix: Prefix for session state keys (e.g., "single", "a", "b")
-        col_container: Streamlit container/column to render in
-        initial_config: Initial configuration to load
-
-    Returns:
-        Complete configuration dictionary
-    """
-    with col_container:
-        # Configuration template selection
-        st.subheader("📋 Configuration Template")
-
-        # Get available configurations from cached session_state
-        brand_configs = st.session_state.cached_configs.get(brand, {})
-        all_configs = brand_configs
-        config_names = list(all_configs.keys())
-
-        if len(config_names) == 0:
-            st.warning("No configurations available. Please check your setup.")
-            return None
-
-        selected_config_name = st.selectbox(
-            "Template",
-            config_names,
-            index=0 if "re_engagement_test" in config_names else 0,
-            help="Select a configuration template to start with",
-            key=f"{prefix}_config_select"
-        )
-
-        # Load selected configuration from cached configs
-        loaded_config = all_configs.get(selected_config_name, {})
-
-        if loaded_config:
-            st.success(f"✅ Loaded: **{selected_config_name}**")
-
-            # Show config preview
-            with st.expander("📄 View Configuration Details"):
-                st.json(loaded_config)
-
-        st.markdown("---")
-
-        # Campaign settings
-        st.subheader("⚙️ Campaign Settings")
-
-        campaign_name = st.text_input(
-            "Campaign Name",
-            value=loaded_config.get("campaign_name", f"UI-Campaign-{brand}"),
-            help="Name for this campaign",
-            key=f"{prefix}_campaign_name"
-        )
-
-        col1, col2 = st.columns(2)
-
-        with col1:
-            campaign_type = st.selectbox(
-                "Campaign Type",
-                ["re_engagement"],
-                help="Type of campaign",
-                key=f"{prefix}_campaign_type"
-            )
-
-        with col2:
-            num_stages = st.number_input(
-                "Number of Stages",
-                min_value=1,
-                max_value=11,
-                value=min(3, len([k for k in loaded_config.keys() if k.isdigit()])),
-                help="Number of message stages (1-11)",
-                key=f"{prefix}_num_stages"
-            )
-
-        campaign_instructions = st.text_area(
-            "Campaign-Wide Instructions (Optional)",
-            value=loaded_config.get("campaign_instructions", ""),
-            height=80,
-            help="Instructions applied to all stages",
-            key=f"{prefix}_campaign_instructions"
-        )
-
-        st.markdown("---")
-
-        # Stage configuration
-        st.subheader("📝 Stage Configuration")
-
-        # Load system config for model options
-        system_config = get_system_config()
-        available_models = system_config.get("openai_models", []) + system_config.get("google_models", [])
-
-        stages_config = {}
-
-        for stage_num in range(1, num_stages + 1):
-            with st.expander(f"Stage {stage_num} Configuration", expanded=(stage_num == 1)):
-                # Load existing stage config if available
-                existing_stage = loaded_config.get(str(stage_num), {})
-
-                col1, col2 = st.columns(2)
-
-                with col1:
-                    model = st.selectbox(
-                        "LLM Model",
-                        available_models,
-                        index=available_models.index(existing_stage.get("model", available_models[0])) if existing_stage.get("model") in available_models else 0,
-                        key=f"{prefix}_model_{stage_num}",
-                        help="Language model to use for generation"
-                    )
-
-                    personalization = st.checkbox(
-                        "Enable Personalization",
-                        value=existing_stage.get("personalization", True),
-                        key=f"{prefix}_personalization_{stage_num}",
-                        help="Personalize messages based on user profile"
-                    )
-
-                    involve_recsys = st.checkbox(
-                        "Include Content Recommendation",
-                        value=existing_stage.get("involve_recsys_result", True),
-                        key=f"{prefix}_involve_recsys_{stage_num}",
-                        help="Include content recommendations in messages"
-                    )
-
-                with col2:
-                    recsys_contents = st.multiselect(
-                        "Recommendation Types",
-                        ["workout", "course", "quick_tips", "song"],
-                        default=existing_stage.get("recsys_contents", ["workout", "course"]),
-                        key=f"{prefix}_recsys_contents_{stage_num}",
-                        help="Types of content to recommend",
-                        disabled=not involve_recsys
-                    )
-
-                    specific_content_id = st.number_input(
-                        "Specific Content ID (Optional)",
-                        min_value=0,
-                        value=existing_stage.get("specific_content_id", 0) or 0,
-                        key=f"{prefix}_specific_content_id_{stage_num}",
-                        help="Force specific content for all users (leave 0 for AI recommendations)"
-                    )
-                    specific_content_id = specific_content_id if specific_content_id > 0 else None
-
-                segment_info = st.text_area(
-                    "Segment Description",
-                    value=existing_stage.get("segment_info", f"Users eligible for stage {stage_num}"),
-                    key=f"{prefix}_segment_info_{stage_num}",
-                    height=68,
-                    help="Description of the user segment"
-                )
-
-                instructions = st.text_area(
-                    "Stage-Specific Instructions (Optional)",
-                    value=existing_stage.get("instructions", ""),
-                    key=f"{prefix}_instructions_{stage_num}",
-                    height=80,
-                    help="Instructions specific to this stage"
-                )
-
-                sample_example = st.text_area(
-                    "Example Messages",
-                    value=existing_stage.get("sample_examples", "Header: Hi!\nMessage: Check this out!"),
-                    key=f"{prefix}_sample_example_{stage_num}",
-                    height=80,
-                    help="Example messages for the LLM to learn from"
-                )
-
-                # Store stage configuration
-                stages_config[stage_num] = {
-                    "stage": stage_num,
-                    "model": model,
-                    "personalization": personalization,
-                    "involve_recsys_result": involve_recsys,
-                    "recsys_contents": recsys_contents if involve_recsys else [],
-                    "specific_content_id": specific_content_id,
-                    "segment_info": segment_info,
-                    "instructions": instructions,
-                    "sample_examples": sample_example,
-                    "identifier_column": "user_id",
-                    "platform": "push"
-                }
-
-        # Create complete configuration
-        complete_config = config_manager.create_config_from_ui(
-            brand=brand,
-            campaign_name=campaign_name,
-            campaign_type=campaign_type,
-            num_stages=num_stages,
-            campaign_instructions=campaign_instructions,
-            stages_config=stages_config
-        )
-
-        # Validation
-        is_valid, error_msg = config_manager.validate_config(complete_config)
-
-        if not is_valid:
-            st.error(f"❌ Configuration Error: {error_msg}")
-        else:
-            st.success("✅ Configuration is valid")
-
-        return complete_config
-
-def render_save_config_section(prefix: str, col_container, config):
-    """Render save configuration section."""
-    with col_container:
-        st.subheader("💾 Save Configuration")
-
-        with st.form(f"{prefix}_save_config_form"):
-            new_config_name = st.text_input(
-                "Configuration Name",
-                placeholder="my-custom-config",
-                help="Enter a name to save this configuration"
-            )
-
-            save_button = st.form_submit_button("💾 Save Configuration", use_container_width=True)
-
-            if save_button and new_config_name:
-                if config:
-                    try:
-                        # Create Snowflake session for saving
-                        session = create_snowflake_session()
-
-                        # Initialize config manager with session
-                        config_manager = ConfigManager(session)
-
-                        # Check if config already exists
-                        brand_configs = st.session_state.cached_configs.get(brand, {})
-                        if new_config_name in brand_configs:
-                            st.info(f"ℹ️ Configuration '{new_config_name}' exists. Creating new version...")
-
-                        # Save configuration (auto-versioning)
-                        if config_manager.save_custom_config(brand, new_config_name, config):
-                            # Reload configs and update cache
-                            updated_configs = config_manager.get_all_configs(brand)
-                            st.session_state.cached_configs[brand] = updated_configs
-                            st.success(f"✅ Configuration saved as '{new_config_name}'")
-                        else:
-                            st.error("❌ Failed to save configuration")
-
-                        # Close session
-                        session.close()
-
-                    except Exception as e:
-                        st.error(f"❌ Error saving configuration: {e}")
-                else:
-                    st.error("❌ No configuration loaded")
-
-# ============================================================================
-# RENDER CONFIGURATION SECTIONS BASED ON MODE
-# ============================================================================
-
-if st.session_state.ab_testing_mode:
-    # A/B Testing Mode - Two Columns
-    st.header("🧪 A/B Testing Configuration")
-    st.info("Configure two different experiments (A and B) to run in parallel with the same users.")
-
-    col_a, col_b = st.columns(2)
-
-    # Initialize A/B configs with defaults if None
-    if st.session_state.campaign_config_a is None:
-        brand_configs = st.session_state.cached_configs.get(brand, {})
-        default_name = f"{brand}_re_engagement_test"
-        st.session_state.campaign_config_a = brand_configs.get(default_name, {})
-    if st.session_state.campaign_config_b is None:
-        brand_configs = st.session_state.cached_configs.get(brand, {})
-        default_name = f"{brand}_re_engagement_test"
-        st.session_state.campaign_config_b = brand_configs.get(default_name, {})
-
-    # Column A
-    with col_a:
-        st.markdown("### 🅰️ Experiment A")
-        with st.expander("Configuration A", expanded=True):
-            config_a = render_configuration_section("a", st.container(), st.session_state.campaign_config_a)
-            if config_a is not None:
-                st.session_state.campaign_config_a = config_a
-
-        with st.expander("Save Configuration A"):
-            if st.session_state.campaign_config_a:
-                render_save_config_section("a", st.container(), st.session_state.campaign_config_a)
-
-    # Column B
-    with col_b:
-        st.markdown("### 🅱️ Experiment B")
-        with st.expander("Configuration B", expanded=True):
-            config_b = render_configuration_section("b", st.container(), st.session_state.campaign_config_b)
-            if config_b is not None:
-                st.session_state.campaign_config_b = config_b
-
-        with st.expander("Save Configuration B"):
-            if st.session_state.campaign_config_b:
-                render_save_config_section("b", st.container(), st.session_state.campaign_config_b)
-
-else:
-    # Single Mode
-    # Initialize config with default if None
-    if st.session_state.campaign_config is None:
-        brand_configs = st.session_state.cached_configs.get(brand, {})
-        default_name = f"{brand}_re_engagement_test"
-        st.session_state.campaign_config = brand_configs.get(default_name, {})
-
-    with st.expander("📋 Configuration", expanded=True):
-        config = render_configuration_section("single", st.container(), st.session_state.campaign_config)
-        if config is not None:
-            st.session_state.campaign_config = config
-
-    # Save section outside the main config expander
-    with st.expander("💾 Save Configuration"):
-        if st.session_state.campaign_config:
-            render_save_config_section("single", st.container(), st.session_state.campaign_config)
-
-st.markdown("---")
-
-# ============================================================================
-# USER SELECTION SECTION
-# ============================================================================
-
-with st.expander("👥 User Selection", expanded=True):
-    st.subheader("👥 Select Number of Users")
-
-    # Check if brand users file exists
-    has_brand_users = data_loader.has_brand_users(brand)
-
-    if not has_brand_users:
-        st.error(f"❌ No user file found for {brand}. Please ensure {brand}_users.csv exists in visualization/data/UI_users/")
-    else:
-        # Get total available users
-        total_users = data_loader.get_brand_user_count(brand)
-
-        st.info(f"ℹ️ {total_users} users available for {brand}")
-
-        st.markdown("""
-        Choose how many users you want to experiment with. Users will be **randomly sampled** each time you generate messages.
-
-        For quick experimentation, we recommend **5-10 users**.
-        """)
-
-        col1, col2 = st.columns([2, 3])
-
-        with col1:
-            user_count = st.number_input(
-                "Number of Users",
-                min_value=1,
-                max_value=min(25, total_users),
-                value=st.session_state.selected_user_count,
-                help="Select 1-25 users for experimentation"
-            )
-
-            # Update session state
-            st.session_state.selected_user_count = user_count
-
-        with col2:
-            st.markdown("")
-            st.markdown("")
-            st.markdown(f"**Selected:** {user_count} user{'s' if user_count != 1 else ''}")
-            st.markdown(f"**Available:** {total_users} total users")
-
-        st.markdown("---")
-
-        # Preview sample button
-        if st.button("👀 Preview Random Sample", use_container_width=False):
-            sample_df = data_loader.sample_users_randomly(brand, user_count)
-            if sample_df is not None:
-                st.success(f"✅ Sampled {len(sample_df)} random users")
-                st.dataframe(sample_df, use_container_width=True)
-
-st.markdown("---")
-
-# ============================================================================
-# GENERATION SECTION
-# ============================================================================
-
-def archive_existing_messages(campaign_name: str):
-    """Archive existing messages.csv to a timestamped file."""
-    ui_output_path = data_loader.get_ui_output_path()
-    messages_file = ui_output_path / "messages.csv"
-
-    if messages_file.exists():
-        timestamp = datetime.now().strftime('%Y%m%d_%H%M')
-        archive_name = f"messages_{campaign_name}_{timestamp}.csv"
-        archive_path = ui_output_path / archive_name
-
-        try:
-            shutil.copy2(messages_file, archive_path)
-            st.info(f"📦 Archived existing messages to: {archive_name}")
-            return True
-        except Exception as e:
-            st.warning(f"⚠️ Could not archive existing messages: {e}")
-            return False
-    return True
-
-def generate_messages_for_experiment(
-    experiment_name: str,
-    config: dict,
-    sampled_users_df,
-    output_suffix: str = None,
-    progress_container=None
-):
-    """
-    Generate messages for a single experiment.
-
-    Args:
-        experiment_name: Name of the experiment (e.g., "A" or "B")
-        config: Configuration dictionary
-        sampled_users_df: DataFrame of sampled users
-        output_suffix: Optional suffix for output filename (e.g., "_a" or "_b")
-        progress_container: Streamlit container for progress updates
-
-    Returns:
-        tuple: (success, total_messages_generated)
-    """
-    if progress_container is None:
-        progress_container = st
-
-    with progress_container:
-        st.markdown(f"### 📊 Experiment {experiment_name} Progress")
-
-        system_config = get_system_config()
-
-        # Setup Permes for message generation
-        permes = Permes()
-        original_output_file = permes.UI_OUTPUT_FILE
-        ui_experiment_id = None
-
-        if output_suffix:
-            # Generate experiment ID for timestamping and naming
-            experiment_timestamp = datetime.now().strftime('%Y%m%d_%H%M')
-            ui_experiment_id = f"messages_{output_suffix}_{brand}_{experiment_timestamp}"
-            # Keep this for backward compatibility (though it won't be used anymore)
-            permes.UI_OUTPUT_FILE = f"{ui_experiment_id}.csv"
-            st.info(f"💾 Results will be saved to: {ui_experiment_id}.csv")
-
-        # Get campaign-level configurations
-        campaign_name = config.get("campaign_name", "UI-Campaign")
-        campaign_instructions = config.get("campaign_instructions", None)
-        num_stages = len([k for k in config.keys() if k.isdigit()])
-
-        # Generate messages for each stage
-        total_messages_generated = 0
-        generation_successful = True
-
-        for stage in range(1, num_stages + 1):
-            st.markdown(f"#### Stage {stage} of {num_stages}")
-
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-
-            status_text.text(f"Generating messages for stage {stage}...")
-
-            session = None
-            try:
-                session = create_snowflake_session()
-                progress_bar.progress(10)
-
-                # Get stage configuration
-                stage_config = config.get(str(stage), {})
-
-                if not stage_config:
-                    status_text.error(f"❌ Stage {stage}: Configuration not found")
-                    generation_successful = False
-                    if session:
-                        try:
-                            session.close()
-                        except:
-                            pass
-                    continue
-
-                # Extract stage parameters
-                model = stage_config.get("model", "gemini-2.5-flash-lite")
-                segment_info = stage_config.get("segment_info", "")
-                recsys_contents = stage_config.get("recsys_contents", [])
-                involve_recsys_result = stage_config.get("involve_recsys_result", True)
-                personalization = stage_config.get("personalization", True)
-                sample_example = stage_config.get("sample_examples", "")
-                per_message_instructions = stage_config.get("instructions", None)
-                specific_content_id = stage_config.get("specific_content_id", None)
-
-                progress_bar.progress(20)
-
-                # Call Permes to generate messages
-                users_message = permes.create_personalize_messages(
-                    session=session,
-                    model=model,
-                    users=sampled_users_df.copy(),
-                    brand=brand,
-                    config_file=system_config,
-                    segment_info=segment_info,
-                    involve_recsys_result=involve_recsys_result,
-                    identifier_column="user_id",
-                    recsys_contents=recsys_contents,
-                    sample_example=sample_example,
-                    campaign_name=campaign_name,
-                    personalization=personalization,
-                    stage=stage,
-                    test_mode=False,
-                    mode="ui",
-                    campaign_instructions=campaign_instructions,
-                    per_message_instructions=per_message_instructions,
-                    specific_content_id=specific_content_id,
-                    ui_experiment_id=ui_experiment_id
-                )
-
-                progress_bar.progress(100)
-
-                if users_message is not None and len(users_message) > 0:
-                    total_messages_generated += len(users_message)
-                    status_text.success(
-                        f"✅ Stage {stage}: Generated {len(users_message)} messages"
-                    )
-                else:
-                    status_text.warning(f"⚠️ Stage {stage}: No messages generated")
-                    generation_successful = False
-
-            except Exception as e:
-                progress_bar.progress(0)
-                status_text.error(f"❌ Stage {stage}: Error - {str(e)}")
-                generation_successful = False
-
-            finally:
-                if session:
-                    try:
-                        session.close()
-                    except:
-                        pass
-
-        # Restore original output file name
-        permes.UI_OUTPUT_FILE = original_output_file
-
-        return generation_successful, total_messages_generated
-
-def generate_messages_threaded(
-    experiment_name: str,
-    config: dict,
-    sampled_users_df,
-    output_suffix: str,
-    brand: str,
-    experiment_timestamp: str = None
-):
-    """
-    Generate messages for threading (no UI updates).
-
-    Args:
-        experiment_name: Name of the experiment (e.g., "A" or "B")
-        config: Configuration dictionary
-        sampled_users_df: DataFrame of sampled users
-        output_suffix: Suffix for output filename (e.g., "a" or "b")
-        brand: Brand name
-        experiment_timestamp: Shared timestamp for A/B test pairs
-
-    Returns:
-        dict: Results with 'success', 'total_messages', 'error', 'stages_completed'
-    """
-    result = {
-        'success': False,
-        'total_messages': 0,
-        'error': None,
-        'stages_completed': 0,
-        'stage_details': []
-    }
-
-    try:
-        system_config = get_system_config()
-
-        # Setup Permes for message generation
-        permes = Permes()
-        original_output_file = permes.UI_OUTPUT_FILE
-
-        # Use provided timestamp or generate new one
-        if experiment_timestamp is None:
-            experiment_timestamp = datetime.now().strftime('%Y%m%d_%H%M')
-
-        # Create experiment ID for UI mode
-        ui_experiment_id = f"messages_{output_suffix}_{brand}_{experiment_timestamp}"
-        # Keep this for backward compatibility (though it won't be used anymore)
-        permes.UI_OUTPUT_FILE = f"{ui_experiment_id}.csv"
-
-        # Get campaign-level configurations
-        campaign_name = config.get("campaign_name", "UI-Campaign")
-        campaign_instructions = config.get("campaign_instructions", None)
-        num_stages = len([k for k in config.keys() if k.isdigit()])
-
-        # Generate messages for each stage
-        for stage in range(1, num_stages + 1):
-            session = None
-            try:
-                session = create_snowflake_session()
-
-                # Get stage configuration
-                stage_config = config.get(str(stage), {})
-
-                if not stage_config:
-                    result['stage_details'].append({
-                        'stage': stage,
-                        'status': 'error',
-                        'message': 'Configuration not found',
-                        'count': 0
-                    })
-                    continue
-
-                # Extract stage parameters
-                model = stage_config.get("model", "gemini-2.5-flash-lite")
-                segment_info = stage_config.get("segment_info", "")
-                recsys_contents = stage_config.get("recsys_contents", [])
-                involve_recsys_result = stage_config.get("involve_recsys_result", True)
-                personalization = stage_config.get("personalization", True)
-                sample_example = stage_config.get("sample_examples", "")
-                per_message_instructions = stage_config.get("instructions", None)
-                specific_content_id = stage_config.get("specific_content_id", None)
-
-                # Call Permes to generate messages
-                users_message = permes.create_personalize_messages(
-                    session=session,
-                    model=model,
-                    users=sampled_users_df.copy(),
-                    brand=brand,
-                    config_file=system_config,
-                    segment_info=segment_info,
-                    involve_recsys_result=involve_recsys_result,
-                    identifier_column="user_id",
-                    recsys_contents=recsys_contents,
-                    sample_example=sample_example,
-                    campaign_name=campaign_name,
-                    personalization=personalization,
-                    stage=stage,
-                    test_mode=False,
-                    mode="ui",
-                    campaign_instructions=campaign_instructions,
-                    per_message_instructions=per_message_instructions,
-                    specific_content_id=specific_content_id,
-                    ui_experiment_id=ui_experiment_id
-                )
-
-                if users_message is not None and len(users_message) > 0:
-                    result['total_messages'] += len(users_message)
-                    result['stages_completed'] += 1
-                    result['stage_details'].append({
-                        'stage': stage,
-                        'status': 'success',
-                        'message': f'Generated {len(users_message)} messages',
-                        'count': len(users_message)
-                    })
-                else:
-                    result['stage_details'].append({
-                        'stage': stage,
-                        'status': 'warning',
-                        'message': 'No messages generated',
-                        'count': 0
-                    })
-
-            except Exception as e:
-                result['stage_details'].append({
-                    'stage': stage,
-                    'status': 'error',
-                    'message': str(e),
-                    'count': 0
-                })
-
-            finally:
-                if session:
-                    try:
-                        session.close()
-                    except:
-                        pass
-
-        # Restore original output file name
-        permes.UI_OUTPUT_FILE = original_output_file
-
-        # Mark as successful if at least one stage completed
-        result['success'] = result['stages_completed'] > 0
-
-    except Exception as e:
-        result['error'] = str(e)
-        result['success'] = False
-
-    return result
-
-with st.expander("🚀 Generate Messages", expanded=True):
-    st.subheader("🚀 Generate Messages")
-
-    # Check prerequisites
-    if st.session_state.ab_testing_mode:
-        config_ready = (st.session_state.campaign_config_a is not None and
-                       st.session_state.campaign_config_b is not None)
-    else:
-        config_ready = st.session_state.campaign_config is not None
-
-    users_ready = data_loader.has_brand_users(brand)
-    user_count_selected = st.session_state.get("selected_user_count", 5)
-
-    # Status checks
-    col1, col2, col3 = st.columns(3)
-
-    with col1:
-        if config_ready:
-            st.success("✅ Configuration ready")
-        else:
-            st.error("❌ Configuration not ready")
-
-    with col2:
-        if users_ready:
-            st.success(f"✅ {user_count_selected} users selected")
-        else:
-            st.error("❌ No users available")
-
-    with col3:
-        if st.session_state.ab_testing_mode:
-            st.metric("Mode", "A/B Testing")
-        else:
-            st.metric("Mode", "Single")
-
-    st.markdown("---")
-
-    if not config_ready:
-        st.info("👆 Please complete the configuration first")
-    elif not users_ready:
-        st.error("❌ No users available. Please check that user files exist.")
-    else:
-        # Generation settings
-        st.subheader("Generation Settings")
-
-        if st.session_state.ab_testing_mode:
-            num_stages_a = len([k for k in st.session_state.campaign_config_a.keys() if k.isdigit()])
-            num_stages_b = len([k for k in st.session_state.campaign_config_b.keys() if k.isdigit()])
-            st.info(f"ℹ️ Will generate messages for **{num_stages_a} stages (A)** and **{num_stages_b} stages (B)** in parallel")
-        else:
-            num_stages = len([k for k in st.session_state.campaign_config.keys() if k.isdigit()])
-            st.info(f"ℹ️ Will generate messages for **all {num_stages} stages** configured in the campaign")
-
-        # Clear previous results option
-        clear_previous = st.checkbox(
-            "Start new experiment (clears previous results from memory)",
-            value=True,
-            help="Clear previous experiment data from session_state and start fresh"
-        )
-
-        st.markdown("---")
-
-        # Generate button
-        if st.button("🚀 Start Generation", use_container_width=True, type="primary"):
-            # Reset next steps flag
-            st.session_state.show_next_steps = False
-            st.session_state.generation_complete = False
-
-            # Clear previous experiment data if requested
-            if clear_previous:
-                st.session_state.ui_log_data = None
-                st.session_state.current_experiment_metadata = []
-                st.session_state.current_feedbacks = []
-                st.session_state.ui_log_data_a = None
-                st.session_state.ui_log_data_b = None
-                st.session_state.experiment_a_metadata = []
-                st.session_state.experiment_b_metadata = []
-                st.session_state.feedbacks_a = []
-                st.session_state.feedbacks_b = []
-                st.info("🗑️ Cleared previous experiment data from memory")
-
-            # Sample users randomly from the brand's user file
-            with st.spinner(f"Sampling {user_count_selected} random users from {brand}_users.csv..."):
-                sampled_users_df = data_loader.sample_users_randomly(brand, user_count_selected)
-
-                if sampled_users_df is None or len(sampled_users_df) == 0:
-                    st.error("❌ Failed to sample users. Please check your user files.")
-                    st.stop()
-
-                st.success(f"✅ Sampled {len(sampled_users_df)} users successfully")
-
-            st.markdown("---")
-
-            # Initialize ExperimentRunner
-            system_config = get_system_config()
-            runner = ExperimentRunner(brand=brand, system_config=system_config)
-
-            if st.session_state.ab_testing_mode:
-                # A/B Testing Mode - Parallel Execution
-                st.markdown("## 🧪 Running A/B Tests in Parallel")
-                st.info("⏳ Generating messages for both experiments in parallel. This may take a few minutes...")
-
-                # Generate shared timestamp for both experiments
-                shared_timestamp = datetime.now().strftime('%Y%m%d_%H%M')
-
-                # Create experiment IDs
-                experiment_a_id = f"messages_a_{brand}_{shared_timestamp}"
-                experiment_b_id = f"messages_b_{brand}_{shared_timestamp}"
-
-                # Get configs
-                config_a = st.session_state.campaign_config_a
-                config_b = st.session_state.campaign_config_b
-
-                # Run parallel AB test using ExperimentRunner
-                with st.spinner("Generating messages for both experiments..."):
-                    results = runner.run_ab_test_parallel(
-                        config_a=config_a,
-                        config_b=config_b,
-                        sampled_users_df=sampled_users_df,
-                        experiment_a_id=experiment_a_id,
-                        experiment_b_id=experiment_b_id,
-                        create_session_func=create_snowflake_session
-                    )
-
-                st.markdown("---")
-
-                # Store results in session_state
-                st.session_state.experiment_a_id = experiment_a_id
-                st.session_state.experiment_b_id = experiment_b_id
-                st.session_state.ui_log_data_a = results['a']['ui_log_data']
-                st.session_state.ui_log_data_b = results['b']['ui_log_data']
-                st.session_state.experiment_a_metadata = results['a']['metadata']
-                st.session_state.experiment_b_metadata = results['b']['metadata']
-
-                # Display results
-                st.markdown("## 📊 A/B Test Results")
-
-                col_a_result, col_b_result = st.columns(2)
-
-                # Experiment A Results
-                with col_a_result:
-                    st.markdown("### 🅰️ Experiment A")
-                    if results['a']['success']:
-                        total_messages_a = len(st.session_state.ui_log_data_a) if st.session_state.ui_log_data_a is not None else 0
-                        st.success(f"✅ Generated {total_messages_a} messages")
-                        st.metric("Stages Completed", f"{len(st.session_state.experiment_a_metadata)}")
-
-                        # Show stage summary
-                        with st.expander("View Stage Details"):
-                            for meta in st.session_state.experiment_a_metadata:
-                                st.info(f"Stage {meta['stage']}: {meta['total_messages']} messages using {meta['llm_model']}")
-                    else:
-                        st.error(f"❌ Error: {results['a'].get('error', 'Unknown error')}")
-
-                # Experiment B Results
-                with col_b_result:
-                    st.markdown("### 🅱️ Experiment B")
-                    if results['b']['success']:
-                        total_messages_b = len(st.session_state.ui_log_data_b) if st.session_state.ui_log_data_b is not None else 0
-                        st.success(f"✅ Generated {total_messages_b} messages")
-                        st.metric("Stages Completed", f"{len(st.session_state.experiment_b_metadata)}")
-
-                        # Show stage summary
-                        with st.expander("View Stage Details"):
-                            for meta in st.session_state.experiment_b_metadata:
-                                st.info(f"Stage {meta['stage']}: {meta['total_messages']} messages using {meta['llm_model']}")
-                    else:
-                        st.error(f"❌ Error: {results['b'].get('error', 'Unknown error')}")
-
-                # Mark generation as complete
-                st.session_state.generation_complete = True
-                st.session_state.show_next_steps = True
-
-            else:
-                # Single Mode
-                st.markdown("## 📊 Generating Messages")
-
-                # Generate experiment ID
-                experiment_id = f"{brand}_experiment_{datetime.now().strftime('%Y%m%d_%H%M')}"
-
-                # Run single experiment using ExperimentRunner
-                success, ui_log_data, metadata_list = runner.run_single_experiment(
-                    config=st.session_state.campaign_config,
-                    sampled_users_df=sampled_users_df,
-                    experiment_id=experiment_id,
-                    create_session_func=create_snowflake_session,
-                    progress_container=st.container()
-                )
-
-                st.markdown("---")
-
-                # Store results in session_state
-                st.session_state.current_experiment_id = experiment_id
-                st.session_state.ui_log_data = ui_log_data
-                st.session_state.current_experiment_metadata = metadata_list
-
-                if success and ui_log_data is not None:
-                    total_messages = len(ui_log_data)
-                    st.success(f"✅ Generation complete! Generated {total_messages} total messages.")
-
-                    # Show stage summary
-                    with st.expander("📋 View Stage Summary"):
-                        for meta in metadata_list:
-                            st.info(f"Stage {meta['stage']}: {meta['total_messages']} messages using {meta['llm_model']}")
-                else:
-                    st.warning("⚠️ Generation completed with some errors. Please check the output above.")
-
-                # Mark generation as complete
-                st.session_state.generation_complete = True
-                st.session_state.show_next_steps = True
-
-# Show next steps outside the generation button block (persists across reruns)
-if st.session_state.get("show_next_steps", False):
-    st.markdown("---")
-    st.subheader("📋 Next Steps")
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        if st.button("👀 View Messages", use_container_width=True, key="view_messages_after_gen"):
-            st.switch_page("pages/2_Message_Viewer.py")
-
-    with col2:
-        if st.button("📊 View Analytics", use_container_width=True, key="view_analytics_after_gen"):
-            st.switch_page("pages/4_Analytics.py")
-
-# Show existing messages from session_state if any
-if st.session_state.ab_testing_mode:
-    # AB mode - check both experiments
-    has_messages = (st.session_state.ui_log_data_a is not None and len(st.session_state.ui_log_data_a) > 0) or \
-                   (st.session_state.ui_log_data_b is not None and len(st.session_state.ui_log_data_b) > 0)
-else:
-    # Single mode
-    has_messages = st.session_state.ui_log_data is not None and len(st.session_state.ui_log_data) > 0
-
-if has_messages:
-    st.markdown("---")
-    st.subheader("📨 Current Experiment Messages")
-
-    # Calculate stats from session_state
-    if st.session_state.ab_testing_mode:
-        total_messages_a = len(st.session_state.ui_log_data_a) if st.session_state.ui_log_data_a is not None else 0
-        total_messages_b = len(st.session_state.ui_log_data_b) if st.session_state.ui_log_data_b is not None else 0
-        total_messages = total_messages_a + total_messages_b
-        stats = {
-            "total_messages": total_messages,
-            "experiment_a": total_messages_a,
-            "experiment_b": total_messages_b,
-            "mode": "AB Testing"
-        }
-    else:
-        total_messages = len(st.session_state.ui_log_data) if st.session_state.ui_log_data is not None else 0
-        total_users = st.session_state.ui_log_data['user_id'].nunique() if st.session_state.ui_log_data is not None and 'user_id' in st.session_state.ui_log_data.columns else 0
-        total_stages = st.session_state.ui_log_data['stage'].nunique() if st.session_state.ui_log_data is not None and 'stage' in st.session_state.ui_log_data.columns else 0
-        stats = {
-            "total_messages": total_messages,
-            "total_users": total_users,
-            "total_stages": total_stages,
-            "mode": "Single"
-        }
-
-    if st.session_state.ab_testing_mode:
-        col1, col2, col3 = st.columns(3)
-
-        with col1:
-            st.metric("Total Messages", stats['total_messages'])
-
-        with col2:
-            st.metric("Experiment A", stats['experiment_a'])
-
-        with col3:
-            st.metric("Experiment B", stats['experiment_b'])
-    else:
-        col1, col2, col3 = st.columns(3)
-
-        with col1:
-            st.metric("Total Messages", stats['total_messages'])
-
-        with col2:
-            st.metric("Total Users", stats['total_users'])
-
-        with col3:
-            st.metric("Total Stages", stats['total_stages'])
-
-    if st.button("🗑️ Clear Experiment Data from Memory", use_container_width=False):
-        # Clear session_state data
-        st.session_state.ui_log_data = None
-        st.session_state.current_experiment_metadata = []
-        st.session_state.current_feedbacks = []
-        st.session_state.ui_log_data_a = None
-        st.session_state.ui_log_data_b = None
-        st.session_state.experiment_a_metadata = []
-        st.session_state.experiment_b_metadata = []
-        st.session_state.feedbacks_a = []
-        st.session_state.feedbacks_b = []
-        st.success("✅ All experiment data cleared from memory")
-        st.rerun()
-
-st.markdown("---")
-st.markdown("**���� Tip:** Use A/B testing to compare different configurations with the same users!")

visualization/pages/2_Message_Viewer.py

@@ -1,939 +0,0 @@
-"""
-Page 2: Message Viewer
-Browse, search, and evaluate generated messages with feedback system.
-Supports A/B testing mode for comparing two experiments side-by-side.
-"""
-
-import streamlit as st
-import sys
-from pathlib import Path
-import json
-import pandas as pd
-import re
-from datetime import datetime
-
-# Add parent directories to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from utils.auth import check_authentication
-from utils.theme import apply_theme, get_brand_emoji, create_badge
-from utils.data_loader import DataLoader
-from utils.session_feedback_manager import SessionFeedbackManager
-from utils.db_manager import UIDatabaseManager
-from snowflake.snowpark import Session
-import os
-
-# Page configuration
-st.set_page_config(
-    page_title="Message Viewer",
-    page_icon="👀",
-    layout="wide"
-)
-
-# Check authentication
-if not check_authentication():
-    st.error("🔒 Please login first")
-    st.stop()
-
-# Initialize utilities
-data_loader = DataLoader()
-# Note: Using SessionFeedbackManager for in-memory feedback (no files)
-
-# Helper function to create Snowflake session
-def create_snowflake_session() -> Session:
-    """Create a Snowflake session using environment variables."""
-    conn_params = {
-        "user": os.getenv("SNOWFLAKE_USER"),
-        "password": os.getenv("SNOWFLAKE_PASSWORD"),
-        "account": os.getenv("SNOWFLAKE_ACCOUNT"),
-        "role": os.getenv("SNOWFLAKE_ROLE"),
-        "database": os.getenv("SNOWFLAKE_DATABASE"),
-        "warehouse": os.getenv("SNOWFLAKE_WAREHOUSE"),
-        "schema": os.getenv("SNOWFLAKE_SCHEMA"),
-    }
-    return Session.builder.configs(conn_params).create()
-
-# Check if brand is selected
-if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
-    st.error("⚠️ Please select a brand from the home page first")
-    st.stop()
-
-brand = st.session_state.selected_brand
-apply_theme(brand)
-
-# Helper functions for detecting mode from session_state
-def detect_ab_testing_mode():
-    """
-    Detect if we're in A/B testing mode from session_state.
-    Returns (is_ab_mode, messages_a_df, messages_b_df, experiment_a_id, experiment_b_id)
-    """
-    if st.session_state.get('ab_testing_mode', False):
-        # Check if we have AB test data in session_state
-        has_data_a = st.session_state.get('ui_log_data_a') is not None
-        has_data_b = st.session_state.get('ui_log_data_b') is not None
-
-        if has_data_a and has_data_b:
-            return (
-                True,
-                st.session_state.ui_log_data_a,
-                st.session_state.ui_log_data_b,
-                st.session_state.get('experiment_a_id'),
-                st.session_state.get('experiment_b_id')
-            )
-
-    return False, None, None, None, None
-
-
-def get_single_experiment_data():
-    """
-    Get single mode experiment data from session_state.
-    Returns (messages_df, experiment_id)
-    """
-    messages_df = st.session_state.get('ui_log_data')
-    experiment_id = st.session_state.get('current_experiment_id')
-
-    if messages_df is not None and len(messages_df) > 0:
-        return messages_df, experiment_id
-
-    return None, None
-
-
-# Page Header
-emoji = get_brand_emoji(brand)
-st.title(f"👀 Message Viewer - {emoji} {brand.title()}")
-st.markdown("**Browse and evaluate generated messages**")
-
-# Detect A/B testing mode from session_state
-is_ab_mode, messages_a_df, messages_b_df, experiment_a_id, experiment_b_id = detect_ab_testing_mode()
-
-if is_ab_mode:
-    st.info(f"🔬 **A/B Testing Mode Active** - Comparing two experiments side-by-side")
-
-st.markdown("---")
-
-# Load messages based on mode
-if is_ab_mode:
-    # AB mode - data already loaded from session_state
-    if messages_a_df is None or len(messages_a_df) == 0 or messages_b_df is None or len(messages_b_df) == 0:
-        st.warning("⚠️ No A/B test messages found in memory. Please generate messages first in Campaign Builder.")
-        if st.button("🏗️ Go to Campaign Builder"):
-            st.switch_page("pages/1_Campaign_Builder.py")
-        st.stop()
-
-    messages_df = None  # Not used in AB mode
-else:
-    # Single mode - load from session_state
-    messages_df, experiment_id = get_single_experiment_data()
-
-    if messages_df is None or len(messages_df) == 0:
-        st.warning("⚠️ No messages found in memory. Please generate messages first in Campaign Builder.")
-        if st.button("🏗️ Go to Campaign Builder"):
-            st.switch_page("pages/1_Campaign_Builder.py")
-        st.stop()
-
-    # Ensure experiment ID is set
-    if experiment_id is None or not experiment_id:
-        # Create experiment ID based on campaign name and timestamp
-        if 'campaign_name' in messages_df.columns and len(messages_df) > 0:
-            campaign_name = messages_df['campaign_name'].iloc[0]
-            experiment_id = campaign_name.replace(" ", "_")
-        else:
-            experiment_id = f"{brand}_experiment"
-
-        st.session_state.current_experiment_id = experiment_id
-
-    experiment_id = st.session_state.current_experiment_id
-    messages_a_df = None
-    messages_b_df = None
-    experiment_a_id = None
-    experiment_b_id = None
-
-# Sidebar - Filters and Settings
-with st.sidebar:
-    st.header("🔍 Filters & Settings")
-
-    # View mode
-    if is_ab_mode:
-        st.markdown("**View Mode (applies to both experiments)**")
-    view_mode = st.radio(
-        "View Mode",
-        ["User-Centric", "Stage-Centric"],
-        help="User-Centric: All stages for each user\nStage-Centric: All users for each stage"
-    )
-
-    st.markdown("---")
-
-    # Stage filter
-    if is_ab_mode:
-        # Get stages from both dataframes
-        stages_a = sorted(messages_a_df['stage'].unique()) if 'stage' in messages_a_df.columns else []
-        stages_b = sorted(messages_b_df['stage'].unique()) if 'stage' in messages_b_df.columns else []
-        available_stages = sorted(list(set(stages_a + stages_b)))
-    else:
-        available_stages = sorted(messages_df['stage'].unique()) if 'stage' in messages_df.columns else []
-
-    selected_stages = st.multiselect(
-        "Filter by Stage",
-        available_stages,
-        default=available_stages,
-        help="Select specific stages to view" + (" (applies to both experiments)" if is_ab_mode else "")
-    )
-
-    # Search
-    search_term = st.text_input(
-        "🔎 Search Messages",
-        placeholder="Enter keyword...",
-        help="Search for specific keywords in messages" + (" (applies to both experiments)" if is_ab_mode else "")
-    )
-
-    st.markdown("---")
-
-    # Display settings
-    st.subheader("⚙️ Display Settings")
-
-    show_feedback = st.checkbox(
-        "Show Feedback Options",
-        value=True,
-        help="Show reject button and feedback form"
-    )
-
-    messages_per_page = st.number_input(
-        "Messages per Page",
-        min_value=5,
-        max_value=100,
-        value=20,
-        help="Number of messages to display per page"
-    )
-
-# Filter messages
-if is_ab_mode:
-    # Filter both experiments
-    filtered_messages_a = messages_a_df.copy()
-    filtered_messages_b = messages_b_df.copy()
-
-    if selected_stages:
-        filtered_messages_a = filtered_messages_a[filtered_messages_a['stage'].isin(selected_stages)]
-        filtered_messages_b = filtered_messages_b[filtered_messages_b['stage'].isin(selected_stages)]
-
-    if search_term:
-        filtered_messages_a = data_loader.search_messages(filtered_messages_a, search_term)
-        filtered_messages_b = data_loader.search_messages(filtered_messages_b, search_term)
-
-    filtered_messages = None  # Not used in AB mode
-else:
-    filtered_messages = messages_df.copy()
-
-    if selected_stages:
-        filtered_messages = filtered_messages[filtered_messages['stage'].isin(selected_stages)]
-
-    if search_term:
-        filtered_messages = data_loader.search_messages(filtered_messages, search_term)
-
-    filtered_messages_a = None
-    filtered_messages_b = None
-
-# Summary stats
-st.subheader("📊 Summary")
-
-if is_ab_mode:
-    # Show stats for both experiments
-    st.markdown("##### Experiment A vs Experiment B")
-
-    col1, col2, col3, col4 = st.columns(4)
-
-    with col1:
-        st.metric("Total Messages (A)", len(filtered_messages_a))
-        st.metric("Total Messages (B)", len(filtered_messages_b))
-
-    with col2:
-        unique_users_a = filtered_messages_a['user_id'].nunique() if 'user_id' in filtered_messages_a.columns else 0
-        unique_users_b = filtered_messages_b['user_id'].nunique() if 'user_id' in filtered_messages_b.columns else 0
-        st.metric("Unique Users (A)", unique_users_a)
-        st.metric("Unique Users (B)", unique_users_b)
-
-    with col3:
-        unique_stages_a = filtered_messages_a['stage'].nunique() if 'stage' in filtered_messages_a.columns else 0
-        unique_stages_b = filtered_messages_b['stage'].nunique() if 'stage' in filtered_messages_b.columns else 0
-        st.metric("Stages (A)", unique_stages_a)
-        st.metric("Stages (B)", unique_stages_b)
-
-    with col4:
-        # Get feedback stats from session_state
-        feedback_stats_a = SessionFeedbackManager.get_feedback_stats(
-            experiment_a_id,
-            total_messages=len(filtered_messages_a),
-            feedback_list_key="feedbacks_a"
-        )
-        feedback_stats_b = SessionFeedbackManager.get_feedback_stats(
-            experiment_b_id,
-            total_messages=len(filtered_messages_b),
-            feedback_list_key="feedbacks_b"
-        )
-
-        st.metric("Rejected (A)", feedback_stats_a['total_rejects'])
-        st.metric("Rejected (B)", feedback_stats_b['total_rejects'])
-else:
-    # Single experiment stats
-    col1, col2, col3, col4 = st.columns(4)
-
-    with col1:
-        st.metric("Total Messages", len(filtered_messages))
-
-    with col2:
-        unique_users = filtered_messages['user_id'].nunique() if 'user_id' in filtered_messages.columns else 0
-        st.metric("Unique Users", unique_users)
-
-    with col3:
-        unique_stages = filtered_messages['stage'].nunique() if 'stage' in filtered_messages.columns else 0
-        st.metric("Stages", unique_stages)
-
-    with col4:
-        # Get feedback stats from session_state
-        feedback_stats = SessionFeedbackManager.get_feedback_stats(
-            experiment_id,
-            total_messages=len(filtered_messages),
-            feedback_list_key="current_feedbacks"
-        )
-        st.metric("Rejected", feedback_stats['total_rejects'])
-
-st.markdown("---")
-
-# Helper function to parse message JSON
-def parse_message_content(message_str):
-    """Parse message JSON string and extract content."""
-    try:
-        if isinstance(message_str, str):
-            message_data = json.loads(message_str)
-        elif isinstance(message_str, dict):
-            message_data = message_str
-        else:
-            return None
-
-        # Handle different message formats
-        if isinstance(message_data, dict):
-            # Check for stage-keyed format: {"1": {"header": ..., "message": ...}}
-            if any(k.isdigit() for k in message_data.keys()):
-                # Extract messages from all stages
-                messages = []
-                for key in sorted(message_data.keys(), key=lambda x: int(x) if x.isdigit() else 0):
-                    if isinstance(message_data[key], dict):
-                        messages.append(message_data[key])
-                return messages
-            else:
-                # Single message format
-                return [message_data]
-        elif isinstance(message_data, list):
-            return message_data
-
-    except (json.JSONDecodeError, TypeError):
-        return None
-
-    return None
-
-# Helper function to parse and display recommendation
-def parse_recommendation(rec_str):
-    """Parse recommendation JSON string and extract details."""
-    try:
-        if isinstance(rec_str, str):
-            rec_data = json.loads(rec_str)
-        elif isinstance(rec_str, dict):
-            rec_data = rec_str
-        else:
-            return None
-
-        if isinstance(rec_data, dict):
-            return rec_data
-
-    except (json.JSONDecodeError, TypeError):
-        return None
-
-    return None
-
-def display_recommendation(recommendation):
-    """Display recommendation with thumbnail and link."""
-    if not recommendation:
-        return
-
-    rec_data = parse_recommendation(recommendation)
-
-    if rec_data:
-        # Extract recommendation details
-        title = rec_data.get('title', 'Recommended Content')
-        web_url = rec_data.get('web_url_path', '#')
-        thumbnail_url = rec_data.get('thumbnail_url', '')
-
-        # Create a clickable card with thumbnail
-        st.markdown("**📍 Recommended Content:**")
-
-        if thumbnail_url:
-            # Use container to prevent layout shift during image loading
-            # Note: Images are displayed without columns to prevent flickering on HuggingFace
-            try:
-                # Use a fixed container to prevent layout shifts
-                st.image(thumbnail_url, width=200)  # Fixed width prevents flickering
-            except Exception:
-                # Fallback if image fails to load
-                st.markdown("🖼️ *[Image unavailable]*")
-
-            st.markdown(f"**{title}**")
-            if web_url and web_url != '#':
-                st.markdown(f"[🔗 View Content]({web_url})")
-        else:
-            # No thumbnail, just show title and link
-            st.markdown(f"**{title}**")
-            if web_url and web_url != '#':
-                st.markdown(f"[🔗 View Content]({web_url})")
-
-
-def display_user_centric_messages(filtered_df, exp_id, key_suffix, show_feedback_option, msgs_per_page):
-    """Display messages in user-centric view for a single experiment."""
-    if 'user_id' not in filtered_df.columns:
-        st.warning("No user_id column found in messages.")
-        return
-
-    unique_users = filtered_df['user_id'].unique()
-
-    # Pagination
-    total_users = len(unique_users)
-    users_per_page = msgs_per_page
-
-    if total_users > users_per_page:
-        page = st.number_input(
-            f"Page",
-            min_value=1,
-            max_value=(total_users // users_per_page) + 1,
-            value=1,
-            key=f"page_{key_suffix}"
-        )
-        start_idx = (page - 1) * users_per_page
-        end_idx = min(start_idx + users_per_page, total_users)
-        users_to_display = unique_users[start_idx:end_idx]
-
-        st.markdown(f"*Showing users {start_idx + 1}-{end_idx} of {total_users}*")
-    else:
-        users_to_display = unique_users
-
-    # Display each user
-    for user_id in users_to_display:
-        user_messages = filtered_df[filtered_df['user_id'] == user_id].sort_values('stage')
-
-        if len(user_messages) == 0:
-            continue
-
-        # Get user info from first message
-        first_msg = user_messages.iloc[0]
-        user_email = first_msg.get('email', 'N/A')
-        user_first_name = first_msg.get('first_name', 'N/A')
-
-        # User expander
-        with st.expander(f"👤 User {user_id} - {user_first_name} ({user_email})", expanded=False):
-            # User profile
-            st.markdown("##### 📋 User Profile")
-
-            profile_cols = st.columns(4)
-            profile_fields = ['first_name', 'country', 'instrument', 'subscription_status']
-
-            for idx, field in enumerate(profile_fields):
-                if field in first_msg:
-                    profile_cols[idx % 4].markdown(f"**{field.replace('_', ' ').title()}:** {first_msg[field]}")
-
-            st.markdown("---")
-
-            # Display all stages for this user
-            st.markdown("##### 📨 Messages Across All Stages")
-
-            for _, row in user_messages.iterrows():
-                stage = row['stage']
-
-                # Parse message content
-                message_content = parse_message_content(row.get('message', ''))
-
-                if message_content:
-                    # Find the message for this stage
-                    stage_message = None
-                    for msg in message_content:
-                        if isinstance(msg, dict):
-                            stage_message = msg
-                            break
-
-                    if stage_message:
-                        # Create message card
-                        st.markdown(f"**Stage {stage}**")
-
-                        msg_col1, msg_col2 = st.columns([4, 1])
-
-                        with msg_col1:
-                            header = stage_message.get('header', 'No header')
-                            message_text = stage_message.get('message', 'No message')
-
-                            st.markdown(f"**📧 Header:** {header}")
-                            st.markdown(f"**💬 Message:** {message_text}")
-
-                            # Show recommendation if available
-                            if 'thumbnail_url' in stage_message or 'web_url_path' in stage_message:
-                                rec_data = {
-                                    'title': stage_message.get('title', 'Recommended Content'),
-                                    'web_url_path': stage_message.get('web_url_path', '#'),
-                                    'thumbnail_url': stage_message.get('thumbnail_url', '')
-                                }
-                                display_recommendation(rec_data)
-                            elif 'recommendation' in row and pd.notna(row['recommendation']):
-                                display_recommendation(row['recommendation'])
-
-                        with msg_col2:
-                            # Feedback section
-                            if show_feedback_option:
-                                # Determine feedback list key based on mode
-                                if is_ab_mode:
-                                    feedback_key = "feedbacks_a" if "exp_a" in key_suffix else "feedbacks_b"
-                                else:
-                                    feedback_key = "current_feedbacks"
-
-                                existing_feedback = SessionFeedbackManager.get_feedback(
-                                    exp_id, user_id, stage, feedback_list_key=feedback_key
-                                )
-
-                                if existing_feedback:
-                                    st.error("❌ Rejected")
-                                    if st.button(f"Undo", key=f"undo_{user_id}_{stage}_{key_suffix}"):
-                                        SessionFeedbackManager.delete_feedback(exp_id, user_id, stage, feedback_list_key=feedback_key)
-                                        st.rerun()
-                                else:
-                                    if st.button("🚫 Reject", key=f"reject_{user_id}_{stage}_{key_suffix}"):
-                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}"] = True
-                                        st.rerun()
-
-                        # Feedback form
-                        if st.session_state.get(f"show_feedback_form_{user_id}_{stage}_{key_suffix}", False):
-                            with st.form(f"feedback_form_{user_id}_{stage}_{key_suffix}"):
-                                st.markdown("**Why is this message rejected?**")
-
-                                rejection_reasons = SessionFeedbackManager.get_all_rejection_reasons()
-                                selected_reason = st.selectbox(
-                                    "Rejection Reason",
-                                    list(rejection_reasons.keys()),
-                                    format_func=lambda x: rejection_reasons[x],
-                                    key=f"reason_{user_id}_{stage}_{key_suffix}"
-                                )
-
-                                rejection_text = st.text_area(
-                                    "Additional Comments (Optional)",
-                                    key=f"text_{user_id}_{stage}_{key_suffix}"
-                                )
-
-                                col1, col2 = st.columns(2)
-
-                                with col1:
-                                    if st.form_submit_button("💾 Save", use_container_width=True):
-                                        # Determine feedback list key based on mode
-                                        if is_ab_mode:
-                                            feedback_key = "feedbacks_a" if "exp_a" in key_suffix else "feedbacks_b"
-                                        else:
-                                            feedback_key = "current_feedbacks"
-
-                                        # Get config name from session_state
-                                        config_name = row.get('campaign_name', 'Unknown')
-
-                                        SessionFeedbackManager.add_feedback(
-                                            experiment_id=exp_id,
-                                            user_id=user_id,
-                                            stage=stage,
-                                            feedback_type="reject",
-                                            rejection_reason=selected_reason,
-                                            rejection_text=rejection_text,
-                                            campaign_name=row.get('campaign_name'),
-                                            config_name=config_name,
-                                            brand=brand,
-                                            message_header=stage_message.get('header', 'N/A'),
-                                            message_body=stage_message.get('message', 'N/A'),
-                                            feedback_list_key=feedback_key
-                                        )
-                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}"] = False
-                                        st.success("✅ Feedback saved to memory")
-                                        st.rerun()
-
-                                with col2:
-                                    if st.form_submit_button("❌ Cancel", use_container_width=True):
-                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}"] = False
-                                        st.rerun()
-
-                        st.markdown("---")
-
-
-def display_stage_centric_messages(filtered_df, exp_id, key_suffix, show_feedback_option, msgs_per_page, stages_to_display):
-    """Display messages in stage-centric view for a single experiment."""
-    # Group by stage
-    for stage in sorted(stages_to_display if stages_to_display else filtered_df['stage'].unique()):
-        stage_messages = filtered_df[filtered_df['stage'] == stage]
-
-        if len(stage_messages) == 0:
-            continue
-
-        with st.expander(f"📨 Stage {stage} - {len(stage_messages)} messages", expanded=(stage == 1)):
-            st.markdown(f"##### Stage {stage} Messages")
-
-            # Pagination for this stage
-            total_stage_messages = len(stage_messages)
-            stage_messages_per_page = msgs_per_page
-
-            if total_stage_messages > stage_messages_per_page:
-                page = st.number_input(
-                    f"Page for Stage {stage}",
-                    min_value=1,
-                    max_value=(total_stage_messages // stage_messages_per_page) + 1,
-                    value=1,
-                    key=f"page_stage_{stage}_{key_suffix}"
-                )
-                start_idx = (page - 1) * stage_messages_per_page
-                end_idx = min(start_idx + stage_messages_per_page, total_stage_messages)
-                messages_to_display = stage_messages.iloc[start_idx:end_idx]
-
-                st.markdown(f"*Showing messages {start_idx + 1}-{end_idx} of {total_stage_messages}*")
-            else:
-                messages_to_display = stage_messages
-
-            # Display messages
-            for idx, row in messages_to_display.iterrows():
-                user_id = row.get('user_id', 'N/A')
-                user_email = row.get('email', 'N/A')
-                user_name = row.get('first_name', 'N/A')
-
-                # Parse message content
-                message_content = parse_message_content(row.get('message', ''))
-
-                if message_content:
-                    stage_message = None
-                    for msg in message_content:
-                        if isinstance(msg, dict):
-                            stage_message = msg
-                            break
-
-                    if stage_message:
-                        # Message card
-                        msg_col1, msg_col2 = st.columns([4, 1])
-
-                        with msg_col1:
-                            st.markdown(f"**User:** {user_name} ({user_email}) - ID: {user_id}")
-
-                            header = stage_message.get('header', 'No header')
-                            message_text = stage_message.get('message', 'No message')
-
-                            st.markdown(f"**�� Header:** {header}")
-                            st.markdown(f"**💬 Message:** {message_text}")
-
-                            # Show recommendation if available
-                            if 'thumbnail_url' in stage_message or 'web_url_path' in stage_message:
-                                rec_data = {
-                                    'title': stage_message.get('title', 'Recommended Content'),
-                                    'web_url_path': stage_message.get('web_url_path', '#'),
-                                    'thumbnail_url': stage_message.get('thumbnail_url', '')
-                                }
-                                display_recommendation(rec_data)
-                            elif 'recommendation' in row and pd.notna(row['recommendation']):
-                                display_recommendation(row['recommendation'])
-
-                        with msg_col2:
-                            # Feedback section
-                            if show_feedback_option:
-                                # Determine feedback list key based on mode
-                                if is_ab_mode:
-                                    feedback_key = "feedbacks_a" if "exp_a" in key_suffix else "feedbacks_b"
-                                else:
-                                    feedback_key = "current_feedbacks"
-
-                                existing_feedback = SessionFeedbackManager.get_feedback(
-                                    exp_id, user_id, stage, feedback_list_key=feedback_key
-                                )
-
-                                if existing_feedback:
-                                    st.error("❌ Rejected")
-                                    if st.button(f"Undo", key=f"undo_{user_id}_{stage}_{key_suffix}_sc"):
-                                        SessionFeedbackManager.delete_feedback(exp_id, user_id, stage, feedback_list_key=feedback_key)
-                                        st.rerun()
-                                else:
-                                    if st.button("🚫 Reject", key=f"reject_{user_id}_{stage}_{key_suffix}_sc"):
-                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc"] = True
-                                        st.rerun()
-
-                        # Feedback form
-                        if st.session_state.get(f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc", False):
-                            with st.form(f"feedback_form_{user_id}_{stage}_{key_suffix}_sc"):
-                                st.markdown("**Why is this message rejected?**")
-
-                                rejection_reasons = SessionFeedbackManager.get_all_rejection_reasons()
-                                selected_reason = st.selectbox(
-                                    "Rejection Reason",
-                                    list(rejection_reasons.keys()),
-                                    format_func=lambda x: rejection_reasons[x],
-                                    key=f"reason_{user_id}_{stage}_{key_suffix}_sc"
-                                )
-
-                                rejection_text = st.text_area(
-                                    "Additional Comments (Optional)",
-                                    key=f"text_{user_id}_{stage}_{key_suffix}_sc"
-                                )
-
-                                col1, col2 = st.columns(2)
-
-                                with col1:
-                                    if st.form_submit_button("💾 Save", use_container_width=True):
-                                        # Determine feedback list key based on mode
-                                        if is_ab_mode:
-                                            feedback_key = "feedbacks_a" if "exp_a" in key_suffix else "feedbacks_b"
-                                        else:
-                                            feedback_key = "current_feedbacks"
-
-                                        # Get config name from session_state
-                                        config_name = row.get('campaign_name', 'Unknown')
-
-                                        SessionFeedbackManager.add_feedback(
-                                            experiment_id=exp_id,
-                                            user_id=user_id,
-                                            stage=stage,
-                                            feedback_type="reject",
-                                            rejection_reason=selected_reason,
-                                            rejection_text=rejection_text,
-                                            campaign_name=row.get('campaign_name'),
-                                            config_name=config_name,
-                                            brand=brand,
-                                            message_header=stage_message.get('header', 'N/A'),
-                                            message_body=stage_message.get('message', 'N/A'),
-                                            feedback_list_key=feedback_key
-                                        )
-                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc"] = False
-                                        st.success("✅ Feedback saved to memory")
-                                        st.rerun()
-
-                                with col2:
-                                    if st.form_submit_button("❌ Cancel", use_container_width=True):
-                                        st.session_state[f"show_feedback_form_{user_id}_{stage}_{key_suffix}_sc"] = False
-                                        st.rerun()
-
-                        st.markdown("---")
-
-# Display messages based on mode and view
-if is_ab_mode:
-    # A/B Testing Mode - Show both experiments side by side
-    if view_mode == "User-Centric":
-        st.subheader("👤 User-Centric View")
-        st.markdown("*All stages for each user - comparing both experiments*")
-    else:
-        st.subheader("📊 Stage-Centric View")
-        st.markdown("*All users for each stage - comparing both experiments*")
-
-    # Create two columns for A/B comparison
-    col_a, col_b = st.columns(2)
-
-    with col_a:
-        st.markdown("### 🅰️ Experiment A")
-        if view_mode == "User-Centric":
-            display_user_centric_messages(
-                filtered_messages_a,
-                experiment_a_id,
-                "exp_a",
-                show_feedback,
-                messages_per_page
-            )
-        else:
-            display_stage_centric_messages(
-                filtered_messages_a,
-                experiment_a_id,
-                "exp_a",
-                show_feedback,
-                messages_per_page,
-                selected_stages
-            )
-
-    with col_b:
-        st.markdown("### 🅱️ Experiment B")
-        if view_mode == "User-Centric":
-            display_user_centric_messages(
-                filtered_messages_b,
-                experiment_b_id,
-                "exp_b",
-                show_feedback,
-                messages_per_page
-            )
-        else:
-            display_stage_centric_messages(
-                filtered_messages_b,
-                experiment_b_id,
-                "exp_b",
-                show_feedback,
-                messages_per_page,
-                selected_stages
-            )
-
-else:
-    # Single Experiment Mode - Original behavior
-    if view_mode == "User-Centric":
-        st.subheader("👤 User-Centric View")
-        st.markdown("*All stages for each user*")
-        display_user_centric_messages(
-            filtered_messages,
-            experiment_id,
-            "single",
-            show_feedback,
-            messages_per_page
-        )
-    else:
-        st.subheader("📊 Stage-Centric View")
-        st.markdown("*All users for each stage*")
-        display_stage_centric_messages(
-            filtered_messages,
-            experiment_id,
-            "single",
-            show_feedback,
-            messages_per_page,
-            selected_stages
-        )
-
-st.markdown("---")
-
-# ============================================================================
-# STORE RESULTS TO SNOWFLAKE SECTION (CRITICAL NEW FEATURE)
-# ============================================================================
-
-st.subheader("💾 Store Experiment Results to Snowflake")
-
-st.markdown("""
-**Important:** Experiment results are currently stored in memory only. Click the button below to persist your experiment metadata and feedback to Snowflake for long-term storage and historical analysis.
-""")
-
-if is_ab_mode:
-    # AB Testing Mode
-    st.info(f"🔬 Ready to store A/B test results for:\n- **Experiment A**: {experiment_a_id}\n- **Experiment B**: {experiment_b_id}")
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.metric("Experiment A Feedback", len(st.session_state.get('feedbacks_a', [])))
-        st.metric("Experiment A Metadata", len(st.session_state.get('experiment_a_metadata', [])))
-
-    with col2:
-        st.metric("Experiment B Feedback", len(st.session_state.get('feedbacks_b', [])))
-        st.metric("Experiment B Metadata", len(st.session_state.get('experiment_b_metadata', [])))
-
-else:
-    # Single Mode
-    st.info(f"📊 Ready to store experiment results for: **{experiment_id}**")
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.metric("Total Feedback", len(st.session_state.get('current_feedbacks', [])))
-
-    with col2:
-        st.metric("Metadata Records", len(st.session_state.get('current_experiment_metadata', [])))
-
-st.markdown("---")
-
-if st.button("💾 Store Results to Snowflake", type="primary", use_container_width=True):
-    with st.spinner("Storing results to Snowflake..."):
-        try:
-            # Create Snowflake session
-            session = create_snowflake_session()
-            db_manager = UIDatabaseManager(session)
-
-            if is_ab_mode:
-                # Store A/B Test Results
-                st.write("Storing Experiment A metadata...")
-                for meta in st.session_state.get('experiment_a_metadata', []):
-                    db_manager.store_experiment_metadata(meta)
-
-                st.write("Storing Experiment B metadata...")
-                for meta in st.session_state.get('experiment_b_metadata', []):
-                    db_manager.store_experiment_metadata(meta)
-
-                st.write("Storing Experiment A feedback...")
-                feedbacks_a = st.session_state.get('feedbacks_a', [])
-                if feedbacks_a:
-                    db_manager.store_feedback_batch(feedbacks_a)
-
-                st.write("Storing Experiment B feedback...")
-                feedbacks_b = st.session_state.get('feedbacks_b', [])
-                if feedbacks_b:
-                    db_manager.store_feedback_batch(feedbacks_b)
-
-                session.close()
-
-                st.success(f"""
-                ✅ **Successfully stored A/B test results!**
-
-                - **Experiment A** ({experiment_a_id}): {len(st.session_state.get('experiment_a_metadata', []))} metadata records, {len(feedbacks_a)} feedback records
-                - **Experiment B** ({experiment_b_id}): {len(st.session_state.get('experiment_b_metadata', []))} metadata records, {len(feedbacks_b)} feedback records
-
-                Results are now available in Historical Analytics.
-                """)
-
-            else:
-                # Store Single Experiment Results
-                st.write("Storing experiment metadata...")
-                for meta in st.session_state.get('current_experiment_metadata', []):
-                    db_manager.store_experiment_metadata(meta)
-
-                st.write("Storing feedback...")
-                feedbacks = st.session_state.get('current_feedbacks', [])
-                if feedbacks:
-                    db_manager.store_feedback_batch(feedbacks)
-
-                session.close()
-
-                st.success(f"""
-                ✅ **Successfully stored experiment results!**
-
-                - **Experiment** ({experiment_id}): {len(st.session_state.get('current_experiment_metadata', []))} metadata records, {len(feedbacks)} feedback records
-
-                Results are now available in Historical Analytics.
-                """)
-
-        except Exception as e:
-            st.error(f"❌ Error storing results to Snowflake: {e}")
-            st.error("Please check your Snowflake credentials and connection.")
-
-st.markdown("---")
-
-# Quick actions
-col1, col2, col3 = st.columns(3)
-
-with col1:
-    if st.button("🏗️ Back to Campaign Builder", use_container_width=True):
-        st.switch_page("pages/1_Campaign_Builder.py")
-
-with col2:
-    if st.button("📊 View Analytics", use_container_width=True):
-        st.switch_page("pages/4_Analytics.py")
-
-with col3:
-    # Export messages
-    if st.button("💾 Export Messages", use_container_width=True):
-        if is_ab_mode:
-            # In AB mode, offer to export both experiments
-            st.markdown("**Export Options:**")
-            csv_a = filtered_messages_a.to_csv(index=False, encoding='utf-8')
-            csv_b = filtered_messages_b.to_csv(index=False, encoding='utf-8')
-
-            st.download_button(
-                label="⬇️ Download Experiment A CSV",
-                data=csv_a,
-                file_name=f"{brand}_messages_experiment_a_{ab_timestamp}.csv",
-                mime="text/csv",
-                use_container_width=True
-            )
-
-            st.download_button(
-                label="⬇️ Download Experiment B CSV",
-                data=csv_b,
-                file_name=f"{brand}_messages_experiment_b_{ab_timestamp}.csv",
-                mime="text/csv",
-                use_container_width=True
-            )
-        else:
-            csv = filtered_messages.to_csv(index=False, encoding='utf-8')
-            st.download_button(
-                label="⬇️ Download CSV",
-                data=csv,
-                file_name=f"{brand}_messages_{experiment_id}.csv",
-                mime="text/csv",
-                use_container_width=True
-            )

visualization/pages/4_Analytics.py

@@ -1,886 +0,0 @@
-"""
-Page 4: Analytics Dashboard
-Visualize performance metrics and insights from generated messages and feedback.
-Supports A/B testing mode for comparing two experiments side-by-side.
-Works with in-memory session_state data.
-"""
-
-import streamlit as st
-import sys
-from pathlib import Path
-import pandas as pd
-
-# Try to import plotly with helpful error message
-try:
-    import plotly.express as px
-    import plotly.graph_objects as go
-except ModuleNotFoundError:
-    st.error("""
-    ⚠️ **Missing Dependency: plotly**
-
-    Plotly is not installed in the current Python environment.
-
-    **To fix this:**
-    1. Make sure you're running Streamlit from the correct Python environment
-    2. Install plotly: `pip install plotly>=5.17.0`
-    3. Or install all requirements: `pip install -r visualization/requirements.txt`
-
-    **Current Python:** {}
-    """.format(sys.executable))
-    st.stop()
-
-# Add parent directories to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from utils.auth import check_authentication
-from utils.theme import apply_theme, get_brand_emoji, get_brand_theme
-from utils.session_feedback_manager import SessionFeedbackManager
-
-# Page configuration
-st.set_page_config(
-    page_title="Analytics Dashboard",
-    page_icon="📊",
-    layout="wide"
-)
-
-# Check authentication
-if not check_authentication():
-    st.error("🔒 Please login first")
-    st.stop()
-
-# Check if brand is selected
-if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
-    st.error("⚠️ Please select a brand from the home page first")
-    st.stop()
-
-brand = st.session_state.selected_brand
-apply_theme(brand)
-theme = get_brand_theme(brand)
-
-# Helper functions to detect AB mode and get data from session_state
-def detect_ab_testing_mode():
-    """
-    Detect if we're in AB testing mode based on session_state.
-    Returns True if AB mode data exists in session_state.
-    """
-    return (
-        'ui_log_data_a' in st.session_state and
-        'ui_log_data_b' in st.session_state and
-        st.session_state.ui_log_data_a is not None and
-        st.session_state.ui_log_data_b is not None and
-        len(st.session_state.ui_log_data_a) > 0 and
-        len(st.session_state.ui_log_data_b) > 0
-    )
-
-
-def get_single_experiment_data():
-    """Get single experiment data from session_state."""
-    if 'ui_log_data' in st.session_state and st.session_state.ui_log_data is not None:
-        if isinstance(st.session_state.ui_log_data, pd.DataFrame):
-            return st.session_state.ui_log_data
-        elif isinstance(st.session_state.ui_log_data, list):
-            return pd.DataFrame(st.session_state.ui_log_data)
-    return None
-
-
-# Page Header
-emoji = get_brand_emoji(brand)
-st.title(f"📊 Analytics Dashboard - {emoji} {brand.title()}")
-st.markdown("**Performance metrics and insights for current experiment**")
-
-# Detect A/B testing mode
-is_ab_mode = detect_ab_testing_mode()
-
-if is_ab_mode:
-    st.success("🔬 **A/B Testing Mode - Comparing Experiments Side-by-Side**")
-
-st.markdown("---")
-
-# Load messages based on mode
-if is_ab_mode:
-    # Load A/B test messages from session_state
-    messages_a_df = st.session_state.ui_log_data_a
-    messages_b_df = st.session_state.ui_log_data_b
-
-    # Convert to DataFrame if needed
-    if isinstance(messages_a_df, list):
-        messages_a_df = pd.DataFrame(messages_a_df)
-    if isinstance(messages_b_df, list):
-        messages_b_df = pd.DataFrame(messages_b_df)
-
-    if messages_a_df is None or len(messages_a_df) == 0 or messages_b_df is None or len(messages_b_df) == 0:
-        st.warning("⚠️ No A/B test messages found in current session. Please generate messages first in Campaign Builder.")
-        if st.button("🏗️ Go to Campaign Builder"):
-            st.switch_page("pages/1_Campaign_Builder.py")
-        st.stop()
-
-    # Get experiment IDs from session_state metadata
-    experiment_a_id = st.session_state.get('experiment_a_id', 'experiment_a')
-    experiment_b_id = st.session_state.get('experiment_b_id', 'experiment_b')
-
-    messages_df = None  # Not used in AB mode
-else:
-    # Load single experiment messages from session_state
-    messages_df = get_single_experiment_data()
-
-    if messages_df is None or len(messages_df) == 0:
-        st.warning("⚠️ No messages found in current session. Please generate messages first in Campaign Builder.")
-        if st.button("🏗️ Go to Campaign Builder"):
-            st.switch_page("pages/1_Campaign_Builder.py")
-        st.stop()
-
-    # Get experiment ID from session_state
-    experiment_id = st.session_state.get('current_experiment_id', f"{brand}_experiment")
-
-# Sidebar - Filters
-with st.sidebar:
-    st.header("⚙️ Settings")
-
-    # Show current experiment info
-    if is_ab_mode:
-        st.info(f"**Experiment A:** {experiment_a_id}")
-        st.info(f"**Experiment B:** {experiment_b_id}")
-    else:
-        st.info(f"**Experiment:** {experiment_id}")
-
-    st.markdown("---")
-
-    # Filters
-    st.subheader("🔍 Filters")
-
-    # Stage filter
-    if is_ab_mode:
-        # Get stages from both dataframes
-        stages_a = sorted(messages_a_df['stage'].unique()) if 'stage' in messages_a_df.columns else []
-        stages_b = sorted(messages_b_df['stage'].unique()) if 'stage' in messages_b_df.columns else []
-        available_stages = sorted(list(set(stages_a + stages_b)))
-    else:
-        available_stages = sorted(messages_df['stage'].unique()) if 'stage' in messages_df.columns else []
-
-    if available_stages:
-        selected_stages = st.multiselect(
-            "Filter by Stage",
-            available_stages,
-            default=available_stages,
-            help="Select stages to include in analysis" + (" (applies to both experiments)" if is_ab_mode else "")
-        )
-    else:
-        selected_stages = []
-
-# Filter messages by selected stages
-if is_ab_mode:
-    # Filter both experiments
-    filtered_messages_a = messages_a_df.copy()
-    filtered_messages_b = messages_b_df.copy()
-
-    if selected_stages:
-        filtered_messages_a = filtered_messages_a[filtered_messages_a['stage'].isin(selected_stages)]
-        filtered_messages_b = filtered_messages_b[filtered_messages_b['stage'].isin(selected_stages)]
-
-    filtered_messages = None  # Not used in AB mode
-
-    # Get feedback stats for both experiments using SessionFeedbackManager
-    feedback_stats_a = SessionFeedbackManager.get_feedback_stats(
-        experiment_a_id,
-        total_messages=len(filtered_messages_a),
-        feedback_list_key="feedbacks_a"
-    )
-    feedback_stats_b = SessionFeedbackManager.get_feedback_stats(
-        experiment_b_id,
-        total_messages=len(filtered_messages_b),
-        feedback_list_key="feedbacks_b"
-    )
-    stage_feedback_stats_a = SessionFeedbackManager.get_stage_feedback_stats(
-        experiment_a_id,
-        messages_df=filtered_messages_a,
-        feedback_list_key="feedbacks_a"
-    )
-    stage_feedback_stats_b = SessionFeedbackManager.get_stage_feedback_stats(
-        experiment_b_id,
-        messages_df=filtered_messages_b,
-        feedback_list_key="feedbacks_b"
-    )
-else:
-    if selected_stages and 'stage' in messages_df.columns:
-        filtered_messages = messages_df[messages_df['stage'].isin(selected_stages)]
-    else:
-        filtered_messages = messages_df
-
-    # Get feedback stats using SessionFeedbackManager
-    feedback_stats = SessionFeedbackManager.get_feedback_stats(
-        experiment_id,
-        total_messages=len(filtered_messages),
-        feedback_list_key="current_feedbacks"
-    )
-    stage_feedback_stats = SessionFeedbackManager.get_stage_feedback_stats(
-        experiment_id,
-        messages_df=filtered_messages,
-        feedback_list_key="current_feedbacks"
-    )
-
-# ============================================================================
-# OVERALL METRICS
-# ============================================================================
-st.header("📈 Overall Performance")
-
-if is_ab_mode:
-    # A/B Testing Mode - Show comparison side-by-side
-    st.markdown("##### Experiment A vs Experiment B")
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.markdown("### 🅰️ Experiment A")
-        sub_col1, sub_col2 = st.columns(2)
-
-        with sub_col1:
-            st.metric(
-                "Total Messages",
-                len(filtered_messages_a),
-                help="Total number of generated messages"
-            )
-            st.metric(
-                "Rejected Messages",
-                feedback_stats_a['total_rejects'],
-                f"{feedback_stats_a['reject_rate']:.1f}%"
-            )
-
-        with sub_col2:
-            st.metric(
-                "Total Feedback",
-                feedback_stats_a['total_feedback'],
-                help="Number of messages with feedback"
-            )
-            approved_a = len(filtered_messages_a) - feedback_stats_a['total_rejects']
-            approval_rate_a = (approved_a / len(filtered_messages_a) * 100) if len(filtered_messages_a) > 0 else 0
-            st.metric(
-                "Approved/OK",
-                approved_a,
-                f"{approval_rate_a:.1f}%"
-            )
-
-    with col2:
-        st.markdown("### 🅱️ Experiment B")
-        sub_col1, sub_col2 = st.columns(2)
-
-        with sub_col1:
-            st.metric(
-                "Total Messages",
-                len(filtered_messages_b),
-                help="Total number of generated messages"
-            )
-            st.metric(
-                "Rejected Messages",
-                feedback_stats_b['total_rejects'],
-                f"{feedback_stats_b['reject_rate']:.1f}%"
-            )
-
-        with sub_col2:
-            st.metric(
-                "Total Feedback",
-                feedback_stats_b['total_feedback'],
-                help="Number of messages with feedback"
-            )
-            approved_b = len(filtered_messages_b) - feedback_stats_b['total_rejects']
-            approval_rate_b = (approved_b / len(filtered_messages_b) * 100) if len(filtered_messages_b) > 0 else 0
-            st.metric(
-                "Approved/OK",
-                approved_b,
-                f"{approval_rate_b:.1f}%"
-            )
-
-    # Winner determination
-    st.markdown("---")
-    st.markdown("#### 🏆 Winner Determination")
-
-    reject_rate_diff = feedback_stats_a['reject_rate'] - feedback_stats_b['reject_rate']
-
-    col1, col2, col3 = st.columns([1, 2, 1])
-
-    with col2:
-        if reject_rate_diff < -1:
-            st.success(f"**🏆 Experiment A is performing better** by {abs(reject_rate_diff):.1f}% (lower rejection rate)")
-        elif reject_rate_diff > 1:
-            st.success(f"**🏆 Experiment B is performing better** by {abs(reject_rate_diff):.1f}% (lower rejection rate)")
-        else:
-            st.info("**➡️ Both experiments have similar performance** (difference < 1%)")
-
-else:
-    # Single Experiment Mode - Original behavior
-    col1, col2, col3, col4 = st.columns(4)
-
-    with col1:
-        st.metric(
-            "Total Messages",
-            len(filtered_messages),
-            help="Total number of generated messages"
-        )
-
-    with col2:
-        st.metric(
-            "Total Feedback",
-            feedback_stats['total_feedback'],
-            help="Number of messages with feedback"
-        )
-
-    with col3:
-        st.metric(
-            "Rejected Messages",
-            feedback_stats['total_rejects'],
-            f"{feedback_stats['reject_rate']:.1f}%"
-        )
-
-    with col4:
-        approved = len(filtered_messages) - feedback_stats['total_rejects']
-        approval_rate = (approved / len(filtered_messages) * 100) if len(filtered_messages) > 0 else 0
-        st.metric(
-            "Approved/OK Messages",
-            approved,
-            f"{approval_rate:.1f}%"
-        )
-
-st.markdown("---")
-
-# ============================================================================
-# STAGE-BY-STAGE PERFORMANCE
-# ============================================================================
-st.header("📊 Stage-by-Stage Performance")
-
-if is_ab_mode:
-    # A/B Testing Mode - Show both experiments on same chart for easy comparison
-    if len(stage_feedback_stats_a) > 0 or len(stage_feedback_stats_b) > 0:
-        # Create comparison chart
-        fig = go.Figure()
-
-        if len(stage_feedback_stats_a) > 0:
-            fig.add_trace(go.Bar(
-                x=stage_feedback_stats_a['stage'],
-                y=stage_feedback_stats_a['reject_rate'],
-                name='Experiment A',
-                marker_color='#4A90E2',
-                text=stage_feedback_stats_a['reject_rate'].round(1),
-                textposition='auto',
-            ))
-
-        if len(stage_feedback_stats_b) > 0:
-            fig.add_trace(go.Bar(
-                x=stage_feedback_stats_b['stage'],
-                y=stage_feedback_stats_b['reject_rate'],
-                name='Experiment B',
-                marker_color='#E94B3C',
-                text=stage_feedback_stats_b['reject_rate'].round(1),
-                textposition='auto',
-            ))
-
-        max_reject_rate = 10
-        if len(stage_feedback_stats_a) > 0:
-            max_reject_rate = max(max_reject_rate, stage_feedback_stats_a['reject_rate'].max())
-        if len(stage_feedback_stats_b) > 0:
-            max_reject_rate = max(max_reject_rate, stage_feedback_stats_b['reject_rate'].max())
-
-        fig.update_layout(
-            title="Rejection Rate by Stage - A vs B Comparison",
-            xaxis_title="Stage",
-            yaxis_title="Rejection Rate (%)",
-            yaxis=dict(range=[0, max_reject_rate * 1.2]),
-            template="plotly_dark",
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            barmode='group'
-        )
-
-        st.plotly_chart(fig, use_container_width=True)
-
-        # Stage details tables side-by-side
-        with st.expander("📋 View Stage Details Comparison"):
-            col1, col2 = st.columns(2)
-
-            with col1:
-                st.markdown("**🅰️ Experiment A**")
-                if len(stage_feedback_stats_a) > 0:
-                    st.dataframe(
-                        stage_feedback_stats_a,
-                        use_container_width=True,
-                        column_config={
-                            "stage": "Stage",
-                            "total_messages": "Messages",
-                            "total_feedback": "Feedback",
-                            "rejects": "Rejected",
-                            "reject_rate": st.column_config.NumberColumn(
-                                "Reject Rate (%)",
-                                format="%.1f%%"
-                            )
-                        }
-                    )
-                else:
-                    st.info("No feedback data for Experiment A")
-
-            with col2:
-                st.markdown("**🅱️ Experiment B**")
-                if len(stage_feedback_stats_b) > 0:
-                    st.dataframe(
-                        stage_feedback_stats_b,
-                        use_container_width=True,
-                        column_config={
-                            "stage": "Stage",
-                            "total_messages": "Messages",
-                            "total_feedback": "Feedback",
-                            "rejects": "Rejected",
-                            "reject_rate": st.column_config.NumberColumn(
-                                "Reject Rate (%)",
-                                format="%.1f%%"
-                            )
-                        }
-                    )
-                else:
-                    st.info("No feedback data for Experiment B")
-    else:
-        st.info("ℹ️ No feedback data available yet. Provide feedback in the Message Viewer to see stage-by-stage analysis.")
-
-else:
-    # Single Experiment Mode - Original behavior
-    if len(stage_feedback_stats) > 0:
-        # Create bar chart for stage performance
-        fig = go.Figure()
-
-        fig.add_trace(go.Bar(
-            x=stage_feedback_stats['stage'],
-            y=stage_feedback_stats['reject_rate'],
-            name='Rejection Rate (%)',
-            marker_color=theme['accent'],
-            text=stage_feedback_stats['reject_rate'].round(1),
-            textposition='auto',
-        ))
-
-        fig.update_layout(
-            title="Rejection Rate by Stage",
-            xaxis_title="Stage",
-            yaxis_title="Rejection Rate (%)",
-            yaxis=dict(range=[0, max(stage_feedback_stats['reject_rate'].max() * 1.2, 10)]),
-            template="plotly_dark",
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-        )
-
-        st.plotly_chart(fig, use_container_width=True)
-
-        # Stage details table
-        with st.expander("📋 View Stage Details"):
-            st.dataframe(
-                stage_feedback_stats,
-                use_container_width=True,
-                column_config={
-                    "stage": "Stage",
-                    "total_messages": "Total Messages",
-                    "total_feedback": "Total Feedback",
-                    "rejects": "Rejected",
-                    "reject_rate": st.column_config.NumberColumn(
-                        "Rejection Rate (%)",
-                        format="%.1f%%"
-                    )
-                }
-            )
-    else:
-        st.info("ℹ️ No feedback data available yet. Provide feedback in the Message Viewer to see stage-by-stage analysis.")
-
-st.markdown("---")
-
-# ============================================================================
-# REJECTION REASONS ANALYSIS
-# ============================================================================
-st.header("🔍 Rejection Reasons Analysis")
-
-if is_ab_mode:
-    # A/B Testing Mode - Show side-by-side pie charts for both experiments
-    has_rejection_a = len(feedback_stats_a['rejection_reasons']) > 0
-    has_rejection_b = len(feedback_stats_b['rejection_reasons']) > 0
-
-    if has_rejection_a or has_rejection_b:
-        col1, col2 = st.columns(2)
-
-        with col1:
-            st.markdown("### 🅰️ Experiment A")
-            if has_rejection_a:
-                rejection_reasons_a_df = pd.DataFrame([
-                    {"Reason": reason, "Count": count}
-                    for reason, count in feedback_stats_a['rejection_reasons'].items()
-                ]).sort_values('Count', ascending=False)
-
-                # Pie chart for rejection reasons
-                fig_a = px.pie(
-                    rejection_reasons_a_df,
-                    names='Reason',
-                    values='Count',
-                    title="Distribution of Rejection Reasons",
-                    color_discrete_sequence=px.colors.qualitative.Set3
-                )
-
-                fig_a.update_layout(
-                    template="plotly_dark",
-                    paper_bgcolor='rgba(0,0,0,0)',
-                    plot_bgcolor='rgba(0,0,0,0)',
-                )
-
-                st.plotly_chart(fig_a, use_container_width=True)
-
-                # Most common issue
-                most_common_reason_a = rejection_reasons_a_df.iloc[0]
-                st.info(f"💡 **Most Common:** {most_common_reason_a['Reason']} ({most_common_reason_a['Count']})")
-            else:
-                st.info("No rejection feedback for Experiment A")
-
-        with col2:
-            st.markdown("### 🅱️ Experiment B")
-            if has_rejection_b:
-                rejection_reasons_b_df = pd.DataFrame([
-                    {"Reason": reason, "Count": count}
-                    for reason, count in feedback_stats_b['rejection_reasons'].items()
-                ]).sort_values('Count', ascending=False)
-
-                # Pie chart for rejection reasons
-                fig_b = px.pie(
-                    rejection_reasons_b_df,
-                    names='Reason',
-                    values='Count',
-                    title="Distribution of Rejection Reasons",
-                    color_discrete_sequence=px.colors.qualitative.Pastel
-                )
-
-                fig_b.update_layout(
-                    template="plotly_dark",
-                    paper_bgcolor='rgba(0,0,0,0)',
-                    plot_bgcolor='rgba(0,0,0,0)',
-                )
-
-                st.plotly_chart(fig_b, use_container_width=True)
-
-                # Most common issue
-                most_common_reason_b = rejection_reasons_b_df.iloc[0]
-                st.info(f"💡 **Most Common:** {most_common_reason_b['Reason']} ({most_common_reason_b['Count']})")
-            else:
-                st.info("No rejection feedback for Experiment B")
-
-        # Detailed rejection reasons tables side-by-side
-        with st.expander("📋 View Detailed Rejection Feedback"):
-            col1, col2 = st.columns(2)
-
-            with col1:
-                st.markdown("**🅰️ Experiment A**")
-                # Load feedback from session_state
-                feedbacks_a = st.session_state.get('feedbacks_a', [])
-                feedback_a_list = [fb for fb in feedbacks_a if fb['experiment_id'] == experiment_a_id]
-
-                if len(feedback_a_list) > 0:
-                    feedback_a_df = pd.DataFrame(feedback_a_list)
-                    reject_a_df = feedback_a_df[feedback_a_df['feedback_type'] == 'reject']
-
-                    if len(reject_a_df) > 0:
-                        display_a_df = reject_a_df[[
-                            'user_id', 'stage', 'rejection_reason', 'rejection_text', 'timestamp'
-                        ]].copy()
-
-                        display_a_df['rejection_reason'] = display_a_df['rejection_reason'].apply(
-                            lambda x: SessionFeedbackManager.get_rejection_reason_label(x) if pd.notna(x) else 'N/A'
-                        )
-
-                        st.dataframe(display_a_df, use_container_width=True)
-                    else:
-                        st.info("No rejection feedback")
-                else:
-                    st.info("No feedback data")
-
-            with col2:
-                st.markdown("**🅱️ Experiment B**")
-                # Load feedback from session_state
-                feedbacks_b = st.session_state.get('feedbacks_b', [])
-                feedback_b_list = [fb for fb in feedbacks_b if fb['experiment_id'] == experiment_b_id]
-
-                if len(feedback_b_list) > 0:
-                    feedback_b_df = pd.DataFrame(feedback_b_list)
-                    reject_b_df = feedback_b_df[feedback_b_df['feedback_type'] == 'reject']
-
-                    if len(reject_b_df) > 0:
-                        display_b_df = reject_b_df[[
-                            'user_id', 'stage', 'rejection_reason', 'rejection_text', 'timestamp'
-                        ]].copy()
-
-                        display_b_df['rejection_reason'] = display_b_df['rejection_reason'].apply(
-                            lambda x: SessionFeedbackManager.get_rejection_reason_label(x) if pd.notna(x) else 'N/A'
-                        )
-
-                        st.dataframe(display_b_df, use_container_width=True)
-                    else:
-                        st.info("No rejection feedback")
-                else:
-                    st.info("No feedback data")
-    else:
-        st.info("ℹ️ No rejection feedback available yet. Reject messages in the Message Viewer to see detailed analysis.")
-
-else:
-    # Single Experiment Mode - Original behavior
-    if len(feedback_stats['rejection_reasons']) > 0:
-        # Create DataFrame for rejection reasons
-        rejection_reasons_df = pd.DataFrame([
-            {"Reason": reason, "Count": count}
-            for reason, count in feedback_stats['rejection_reasons'].items()
-        ]).sort_values('Count', ascending=False)
-
-        col1, col2 = st.columns([1, 1])
-
-        with col1:
-            # Pie chart for rejection reasons
-            fig = px.pie(
-                rejection_reasons_df,
-                names='Reason',
-                values='Count',
-                title="Distribution of Rejection Reasons",
-                color_discrete_sequence=px.colors.qualitative.Set3
-            )
-
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-            )
-
-            st.plotly_chart(fig, use_container_width=True)
-
-        with col2:
-            # Bar chart for rejection reasons
-            fig = px.bar(
-                rejection_reasons_df,
-                x='Reason',
-                y='Count',
-                title="Rejection Reasons Count",
-                color='Count',
-                color_continuous_scale='Reds'
-            )
-
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                xaxis_tickangle=-45
-            )
-
-            st.plotly_chart(fig, use_container_width=True)
-
-        # Most common issue
-        most_common_reason = rejection_reasons_df.iloc[0]
-        st.info(f"💡 **Most Common Issue:** {most_common_reason['Reason']} ({most_common_reason['Count']} occurrences)")
-
-        # Detailed rejection reasons table
-        with st.expander("📋 View Detailed Rejection Feedback"):
-            # Load feedback from session_state
-            current_feedbacks = st.session_state.get('current_feedbacks', [])
-            feedback_list = [fb for fb in current_feedbacks if fb['experiment_id'] == experiment_id]
-
-            if len(feedback_list) > 0:
-                feedback_df = pd.DataFrame(feedback_list)
-                reject_df = feedback_df[feedback_df['feedback_type'] == 'reject']
-
-                if len(reject_df) > 0:
-                    # Prepare display dataframe
-                    display_df = reject_df[[
-                        'user_id', 'stage', 'rejection_reason', 'rejection_text', 'timestamp'
-                    ]].copy()
-
-                    # Map rejection reason keys to labels
-                    display_df['rejection_reason'] = display_df['rejection_reason'].apply(
-                        lambda x: SessionFeedbackManager.get_rejection_reason_label(x) if pd.notna(x) else 'N/A'
-                    )
-
-                    st.dataframe(display_df, use_container_width=True)
-    else:
-        st.info("ℹ️ No rejection feedback available yet. Reject messages in the Message Viewer to see detailed analysis.")
-
-st.markdown("---")
-
-# ============================================================================
-# STATISTICAL COMPARISON (AB Testing Mode Only)
-# ============================================================================
-if is_ab_mode:
-    st.header("📊 Statistical Comparison")
-
-    # Create comparison using feedback stats we already have
-    col1, col2, col3 = st.columns(3)
-
-    with col1:
-        st.markdown("### 🅰️ Experiment A")
-        st.metric(
-            "Rejection Rate",
-            f"{feedback_stats_a['reject_rate']:.1f}%"
-        )
-        st.metric(
-            "Total Feedback",
-            feedback_stats_a['total_feedback']
-        )
-        st.metric(
-            "Total Messages",
-            len(filtered_messages_a)
-        )
-
-    with col2:
-        st.markdown("### 🅱️ Experiment B")
-        st.metric(
-            "Rejection Rate",
-            f"{feedback_stats_b['reject_rate']:.1f}%"
-        )
-        st.metric(
-            "Total Feedback",
-            feedback_stats_b['total_feedback']
-        )
-        st.metric(
-            "Total Messages",
-            len(filtered_messages_b)
-        )
-
-    with col3:
-        st.markdown("### 📊 Difference")
-        diff = feedback_stats_a['reject_rate'] - feedback_stats_b['reject_rate']
-
-        st.metric(
-            "Rejection Rate Δ",
-            f"{diff:.1f}%",
-            delta=f"{-diff:.1f}%" if diff != 0 else "0%",
-            delta_color="inverse"
-        )
-
-        feedback_diff = feedback_stats_b['total_feedback'] - feedback_stats_a['total_feedback']
-        st.metric(
-            "Feedback Δ",
-            feedback_diff,
-            delta=f"{feedback_diff}" if feedback_diff != 0 else "0"
-        )
-
-    st.markdown("---")
-
-
-# Export options
-st.header("💾 Export Data")
-
-if is_ab_mode:
-    # A/B Testing Mode - Export both experiments
-    st.markdown("##### Export Experiment Data")
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.markdown("**🅰️ Experiment A**")
-
-        if st.button("📥 Export Messages A", use_container_width=True):
-            csv = filtered_messages_a.to_csv(index=False, encoding='utf-8')
-            st.download_button(
-                label="⬇️ Download Messages A CSV",
-                data=csv,
-                file_name=f"{brand}_{experiment_a_id}_messages.csv",
-                mime="text/csv",
-                use_container_width=True
-            )
-
-        feedbacks_a = st.session_state.get('feedbacks_a', [])
-        feedback_a_list = [fb for fb in feedbacks_a if fb['experiment_id'] == experiment_a_id]
-        if len(feedback_a_list) > 0:
-            if st.button("📥 Export Feedback A", use_container_width=True):
-                feedback_a_df = pd.DataFrame(feedback_a_list)
-                csv = feedback_a_df.to_csv(index=False, encoding='utf-8')
-                st.download_button(
-                    label="⬇️ Download Feedback A CSV",
-                    data=csv,
-                    file_name=f"{brand}_{experiment_a_id}_feedback.csv",
-                    mime="text/csv",
-                    use_container_width=True
-                )
-
-        if len(stage_feedback_stats_a) > 0:
-            if st.button("📥 Export Analytics A", use_container_width=True):
-                csv = stage_feedback_stats_a.to_csv(index=False, encoding='utf-8')
-                st.download_button(
-                    label="⬇️ Download Analytics A CSV",
-                    data=csv,
-                    file_name=f"{brand}_{experiment_a_id}_analytics.csv",
-                    mime="text/csv",
-                    use_container_width=True
-                )
-
-    with col2:
-        st.markdown("**🅱️ Experiment B**")
-
-        if st.button("📥 Export Messages B", use_container_width=True):
-            csv = filtered_messages_b.to_csv(index=False, encoding='utf-8')
-            st.download_button(
-                label="⬇️ Download Messages B CSV",
-                data=csv,
-                file_name=f"{brand}_{experiment_b_id}_messages.csv",
-                mime="text/csv",
-                use_container_width=True
-            )
-
-        feedbacks_b = st.session_state.get('feedbacks_b', [])
-        feedback_b_list = [fb for fb in feedbacks_b if fb['experiment_id'] == experiment_b_id]
-        if len(feedback_b_list) > 0:
-            if st.button("📥 Export Feedback B", use_container_width=True):
-                feedback_b_df = pd.DataFrame(feedback_b_list)
-                csv = feedback_b_df.to_csv(index=False, encoding='utf-8')
-                st.download_button(
-                    label="⬇️ Download Feedback B CSV",
-                    data=csv,
-                    file_name=f"{brand}_{experiment_b_id}_feedback.csv",
-                    mime="text/csv",
-                    use_container_width=True
-                )
-
-        if len(stage_feedback_stats_b) > 0:
-            if st.button("📥 Export Analytics B", use_container_width=True):
-                csv = stage_feedback_stats_b.to_csv(index=False, encoding='utf-8')
-                st.download_button(
-                    label="⬇️ Download Analytics B CSV",
-                    data=csv,
-                    file_name=f"{brand}_{experiment_b_id}_analytics.csv",
-                    mime="text/csv",
-                    use_container_width=True
-                )
-
-else:
-    # Single Experiment Mode - Original behavior
-    col1, col2, col3 = st.columns(3)
-
-    with col1:
-        if st.button("📥 Export Messages", use_container_width=True):
-            csv = filtered_messages.to_csv(index=False, encoding='utf-8')
-            st.download_button(
-                label="⬇️ Download Messages CSV",
-                data=csv,
-                file_name=f"{brand}_{experiment_id}_messages.csv",
-                mime="text/csv",
-                use_container_width=True
-            )
-
-    with col2:
-        current_feedbacks = st.session_state.get('current_feedbacks', [])
-        feedback_list = [fb for fb in current_feedbacks if fb['experiment_id'] == experiment_id]
-        if len(feedback_list) > 0:
-            if st.button("📥 Export Feedback", use_container_width=True):
-                feedback_df = pd.DataFrame(feedback_list)
-                csv = feedback_df.to_csv(index=False, encoding='utf-8')
-                st.download_button(
-                    label="⬇️ Download Feedback CSV",
-                    data=csv,
-                    file_name=f"{brand}_{experiment_id}_feedback.csv",
-                    mime="text/csv",
-                    use_container_width=True
-                )
-
-    with col3:
-        if len(stage_feedback_stats) > 0:
-            if st.button("📥 Export Analytics", use_container_width=True):
-                csv = stage_feedback_stats.to_csv(index=False, encoding='utf-8')
-                st.download_button(
-                    label="⬇️ Download Analytics CSV",
-                    data=csv,
-                    file_name=f"{brand}_{experiment_id}_analytics.csv",
-                    mime="text/csv",
-                    use_container_width=True
-                )
-
-st.markdown("---")

visualization/pages/5_Historical_Analytics.py

@@ -1,1043 +0,0 @@
-"""
-Page 5: Historical Analytics (Enhanced)
-View comprehensive performance metrics and insights from all previous experiments stored in Snowflake.
-Includes campaign-level analysis, model performance, and detailed rejection analytics.
-"""
-
-import streamlit as st
-import sys
-import os
-from pathlib import Path
-import pandas as pd
-from datetime import datetime, timedelta
-from dotenv import load_dotenv
-
-# Load environment variables
-env_path = Path(__file__).parent.parent.parent / '.env'
-if env_path.exists():
-    load_dotenv(env_path)
-else:
-    # Try parent directory
-    parent_env_path = Path(__file__).parent.parent.parent.parent / '.env'
-    if parent_env_path.exists():
-        load_dotenv(parent_env_path)
-
-# Try to import plotly with helpful error message
-try:
-    import plotly.express as px
-    import plotly.graph_objects as go
-    from plotly.subplots import make_subplots
-except ModuleNotFoundError:
-    st.error("""
-    ⚠️ **Missing Dependency: plotly**
-
-    Plotly is not installed in the current Python environment.
-
-    **To fix this:**
-    1. Make sure you're running Streamlit from the correct Python environment
-    2. Install plotly: `pip install plotly>=5.17.0`
-    3. Or install all requirements: `pip install -r visualization/requirements.txt`
-
-    **Current Python:** {}
-    """.format(sys.executable))
-    st.stop()
-
-# Add parent directories to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from utils.auth import check_authentication
-from utils.theme import apply_theme, get_brand_emoji, get_brand_theme
-from utils.db_manager import UIDatabaseManager
-
-# Helper function to create Snowflake session
-def create_snowflake_session():
-    """Create a Snowflake session using environment variables."""
-    try:
-        from snowflake.snowpark import Session
-        connection_parameters = {
-            "user": os.getenv("SNOWFLAKE_USER"),
-            "password": os.getenv("SNOWFLAKE_PASSWORD"),
-            "account": os.getenv("SNOWFLAKE_ACCOUNT"),
-            "role": os.getenv("SNOWFLAKE_ROLE"),
-            "database": os.getenv("SNOWFLAKE_DATABASE"),
-            "warehouse": os.getenv("SNOWFLAKE_WAREHOUSE"),
-            "schema": os.getenv("SNOWFLAKE_SCHEMA"),
-        }
-        return Session.builder.configs(connection_parameters).create()
-    except Exception as e:
-        st.error(f"Failed to create Snowflake session: {e}")
-        import traceback
-        st.error(f"Traceback: {traceback.format_exc()}")
-        return None
-
-# Rejection reason mapping
-REJECTION_REASON_LABELS = {
-    "poor_header": "Poor Header",
-    "poor_body": "Poor Body/Content",
-    "grammar_issues": "Grammar Issues",
-    "emoji_problems": "Emoji Problems",
-    "recommendation_issues": "Recommendation Issues",
-    "wrong_information": "Wrong/Inaccurate Information",
-    "tone_issues": "Tone Issues",
-    "similarity": "Similar To Previous",
-    "other": "Other"
-}
-
-def get_rejection_label(reason_key):
-    """Get human-readable label for rejection reason."""
-    if reason_key is None:
-        return "Unknown"
-    return REJECTION_REASON_LABELS.get(reason_key, reason_key)
-
-# Page configuration
-st.set_page_config(
-    page_title="Historical Analytics",
-    page_icon="📚",
-    layout="wide"
-)
-
-# Check authentication
-if not check_authentication():
-    st.error("🔒 Please login first")
-    st.stop()
-
-# Check if brand is selected
-if "selected_brand" not in st.session_state or not st.session_state.selected_brand:
-    st.error("⚠️ Please select a brand from the home page first")
-    st.stop()
-
-brand = st.session_state.selected_brand
-apply_theme(brand)
-theme = get_brand_theme(brand)
-
-# Page Header
-emoji = get_brand_emoji(brand)
-st.title(f"📚 Enhanced Historical Analytics - {emoji} {brand.title()}")
-st.markdown("**Comprehensive insights across campaigns, models, stages, and rejection patterns**")
-
-st.markdown("---")
-
-# ============================================================================
-# LOAD DATA SECTION
-# ============================================================================
-col1, col2, col3 = st.columns([1, 2, 1])
-with col2:
-    if st.button("📊 Load Historical Data from Snowflake", use_container_width=True, type="primary"):
-        with st.spinner("Loading historical data from Snowflake..."):
-            # Create Snowflake session
-            session = create_snowflake_session()
-
-            if session:
-                try:
-                    db_manager = UIDatabaseManager(session)
-
-                    # Load campaigns summary (new enhanced view)
-                    campaigns_df = db_manager.get_all_campaigns_summary(brand=brand)
-
-                    # Load experiment summary (original view for backward compatibility)
-                    experiments_df = db_manager.get_experiment_summary(brand=brand)
-
-                    # Store in session_state
-                    st.session_state['historical_campaigns'] = campaigns_df
-                    st.session_state['historical_experiments'] = experiments_df
-                    st.session_state['historical_data_loaded'] = True
-                    st.session_state['selected_campaign'] = None  # Reset selection
-
-                    # Close session
-                    db_manager.close()
-
-                    st.success(f"✅ Loaded {len(campaigns_df)} campaigns and {len(experiments_df)} experiments from Snowflake!")
-                    st.rerun()
-
-                except Exception as e:
-                    st.error(f"Error loading historical data: {e}")
-                    import traceback
-                    st.error(f"Traceback: {traceback.format_exc()}")
-                    if session:
-                        session.close()
-            else:
-                st.error("Failed to connect to Snowflake. Please check your credentials.")
-
-st.markdown("---")
-
-# Check if data is loaded
-if not st.session_state.get('historical_data_loaded', False):
-    st.info("👆 Click the button above to load historical data from Snowflake")
-    st.markdown("""
-    ### What's in Historical Analytics:
-    - **Campaign-Level Analysis**: View aggregated metrics for all experiments in a campaign
-    - **Model Performance**: Compare LLM models with detailed rejection metrics
-    - **Stage Analysis**: Identify which stages have the highest rejection rates
-    - **Rejection Reasons**: Interactive breakdown of why messages get rejected
-    - **Filtering**: Drill down by campaign, stage, and model
-    """)
-    st.stop()
-
-# Get loaded data
-campaigns_df = st.session_state.get('historical_campaigns', pd.DataFrame())
-experiments_df = st.session_state.get('historical_experiments', pd.DataFrame())
-
-if campaigns_df is None or len(campaigns_df) == 0:
-    st.warning("⚠️ No historical campaigns found in Snowflake. Generate and store experiments first using Campaign Builder.")
-    st.stop()
-
-# ============================================================================
-# SIDEBAR - CAMPAIGN SELECTOR
-# ============================================================================
-with st.sidebar:
-    st.header("🎯 Campaign Selector")
-
-    # Campaign selection
-    campaign_options = ["-- All Campaigns Overview --"] + list(campaigns_df['campaign_name'].unique())
-    selected_campaign = st.selectbox(
-        "Select Campaign",
-        campaign_options,
-        index=0,
-        key='campaign_selector'
-    )
-
-    # Store selected campaign
-    if selected_campaign != "-- All Campaigns Overview --":
-        st.session_state['selected_campaign'] = selected_campaign
-    else:
-        st.session_state['selected_campaign'] = None
-
-    st.markdown("---")
-
-    # Refresh button
-    if st.button("🔄 Reload Data", use_container_width=True):
-        st.session_state['historical_data_loaded'] = False
-        st.session_state['selected_campaign'] = None
-        st.rerun()
-
-    st.markdown("---")
-    st.markdown("**💡 Tip:** Select a campaign to see detailed analytics including model performance and rejection patterns.")
-
-# ============================================================================
-# MAIN CONTENT - CONDITIONAL BASED ON SELECTION
-# ============================================================================
-
-if st.session_state.get('selected_campaign') is None:
-    # ========================================================================
-    # ALL CAMPAIGNS OVERVIEW
-    # ========================================================================
-    st.header("🌐 All Campaigns Overview")
-
-    # Overview metrics
-    col1, col2, col3, col4 = st.columns(4)
-
-    with col1:
-        st.metric("Total Campaigns", len(campaigns_df))
-
-    with col2:
-        total_experiments = campaigns_df['total_experiments'].sum() if 'total_experiments' in campaigns_df.columns else 0
-        st.metric("Total Experiments", f"{int(total_experiments):,}")
-
-    with col3:
-        total_messages = campaigns_df['total_messages'].sum() if 'total_messages' in campaigns_df.columns else 0
-        st.metric("Total Messages", f"{int(total_messages):,}")
-
-    with col4:
-        total_rejections = campaigns_df['total_rejections'].sum() if 'total_rejections' in campaigns_df.columns else 0
-        st.metric("Total Rejections", f"{int(total_rejections):,}")
-
-    st.markdown("---")
-
-    # Campaigns summary table
-    st.subheader("📊 Campaigns Summary")
-
-    display_df = campaigns_df.copy()
-
-    # Format dates
-    if 'first_experiment' in display_df.columns:
-        display_df['first_experiment'] = pd.to_datetime(display_df['first_experiment']).dt.strftime('%Y-%m-%d')
-    if 'last_experiment' in display_df.columns:
-        display_df['last_experiment'] = pd.to_datetime(display_df['last_experiment']).dt.strftime('%Y-%m-%d')
-
-    # Select and order columns for display
-    display_columns = ['campaign_name', 'total_experiments', 'total_messages', 'total_rejections',
-                      'rejection_rate', 'models_used', 'first_experiment', 'last_experiment']
-    display_columns = [col for col in display_columns if col in display_df.columns]
-
-    st.dataframe(
-        display_df[display_columns],
-        use_container_width=True,
-        hide_index=True,
-        column_config={
-            "campaign_name": "Campaign Name",
-            "total_experiments": st.column_config.NumberColumn("Experiments", format="%d"),
-            "total_messages": st.column_config.NumberColumn("Messages", format="%d"),
-            "total_rejections": st.column_config.NumberColumn("Rejections", format="%d"),
-            "rejection_rate": st.column_config.NumberColumn("Rejection Rate", format="%.1f%%"),
-            "models_used": "Models Used",
-            "first_experiment": "First Run",
-            "last_experiment": "Last Run"
-        }
-    )
-
-    st.markdown("---")
-
-    # Campaign comparison charts
-    col1, col2 = st.columns(2)
-
-    with col1:
-        st.subheader("📉 Rejection Rate by Campaign")
-        if 'rejection_rate' in campaigns_df.columns and len(campaigns_df) > 0:
-            fig = px.bar(
-                campaigns_df.sort_values('rejection_rate', ascending=False),
-                x='campaign_name',
-                y='rejection_rate',
-                color='rejection_rate',
-                color_continuous_scale='RdYlGn_r',
-                text='rejection_rate'
-            )
-            fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                xaxis_title="Campaign",
-                yaxis_title="Rejection Rate (%)",
-                showlegend=False
-            )
-            st.plotly_chart(fig, use_container_width=True)
-        else:
-            st.info("No rejection data available")
-
-    with col2:
-        st.subheader("📊 Messages vs Rejections")
-        if 'total_messages' in campaigns_df.columns and 'total_rejections' in campaigns_df.columns:
-            fig = go.Figure()
-            fig.add_trace(go.Bar(
-                x=campaigns_df['campaign_name'],
-                y=campaigns_df['total_messages'],
-                name='Total Messages',
-                marker_color=theme['primary']
-            ))
-            fig.add_trace(go.Bar(
-                x=campaigns_df['campaign_name'],
-                y=campaigns_df['total_rejections'],
-                name='Rejections',
-                marker_color='#ff4444'
-            ))
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                xaxis_title="Campaign",
-                yaxis_title="Count",
-                barmode='group'
-            )
-            st.plotly_chart(fig, use_container_width=True)
-        else:
-            st.info("No message data available")
-
-else:
-    # ========================================================================
-    # SELECTED CAMPAIGN DETAILED ANALYSIS
-    # ========================================================================
-    selected_campaign = st.session_state['selected_campaign']
-
-    st.header(f"🎯 Campaign Analysis: {selected_campaign}")
-
-    # Load detailed campaign analysis
-    with st.spinner(f"Loading detailed analytics for '{selected_campaign}'..."):
-        session = create_snowflake_session()
-        if session:
-            try:
-                db_manager = UIDatabaseManager(session)
-
-                # Get detailed feedback analysis
-                analysis = db_manager.get_campaign_feedback_analysis(selected_campaign, brand=brand)
-
-                # Store in session state
-                st.session_state['campaign_analysis'] = analysis
-
-                db_manager.close()
-            except Exception as e:
-                st.error(f"Error loading campaign analysis: {e}")
-                import traceback
-                st.error(f"Traceback: {traceback.format_exc()}")
-                if session:
-                    session.close()
-                st.stop()
-        else:
-            st.error("Failed to connect to Snowflake")
-            st.stop()
-
-    analysis = st.session_state.get('campaign_analysis', {})
-
-    # Get campaign summary
-    campaign_summary = campaigns_df[campaigns_df['campaign_name'] == selected_campaign].iloc[0]
-
-    # Campaign overview metrics
-    col1, col2, col3, col4, col5 = st.columns(5)
-
-    with col1:
-        st.metric("Experiments", int(campaign_summary.get('total_experiments', 0)))
-
-    with col2:
-        st.metric("Total Messages", f"{int(campaign_summary.get('total_messages', 0)):,}")
-
-    with col3:
-        st.metric("Total Rejections", f"{int(campaign_summary.get('total_rejections', 0)):,}")
-
-    with col4:
-        st.metric("Rejection Rate", f"{campaign_summary.get('rejection_rate', 0):.1f}%")
-
-    with col5:
-        st.metric("Models Used", int(len(str(campaign_summary.get('models_used', '')).split(', '))))
-
-    st.markdown("---")
-
-    # ========================================================================
-    # OVERALL FEEDBACK ANALYSIS
-    # ========================================================================
-    st.header("📊 Overall Feedback Analysis")
-
-    # Get data for overall analysis
-    reasons_df = analysis.get('rejection_reasons', pd.DataFrame())
-    stage_df = analysis.get('by_stage', pd.DataFrame())
-    model_df = analysis.get('by_model', pd.DataFrame())
-
-    col1, col2, col3 = st.columns(3)
-
-    with col1:
-        st.subheader("📋 Top Rejection Reasons")
-        if not reasons_df.empty:
-            top_reasons = reasons_df.nlargest(5, 'count')
-            for idx, row in top_reasons.iterrows():
-                reason_label = get_rejection_label(row['rejection_reason'])
-                st.metric(reason_label, f"{int(row['count']):,}",
-                         help=f"Affected {int(row.get('experiments_affected', 0))} experiments")
-        else:
-            st.info("No rejection data available")
-
-    with col2:
-        st.subheader("⚠️ Highest Rejection Rate Stages")
-        if not stage_df.empty and 'rejection_rate' in stage_df.columns:
-            top_stages = stage_df.nlargest(5, 'rejection_rate')
-            for idx, row in top_stages.iterrows():
-                st.metric(
-                    f"Stage {int(row['stage'])}",
-                    f"{row['rejection_rate']:.1f}%",
-                    help=f"{int(row.get('total_rejections', 0))} rejections out of {int(row.get('total_messages', 0))} messages"
-                )
-        else:
-            st.info("No stage rejection data available")
-
-    with col3:
-        st.subheader("🤖 Highest Rejection Rate Models")
-        if not model_df.empty and 'rejection_rate' in model_df.columns:
-            top_models = model_df.nlargest(5, 'rejection_rate')
-            for idx, row in top_models.iterrows():
-                model_name = row['llm_model']
-                # Truncate long model names
-                display_name = model_name if len(model_name) <= 20 else model_name[:17] + "..."
-                st.metric(
-                    display_name,
-                    f"{row['rejection_rate']:.1f}%",
-                    help=f"{model_name}: {int(row.get('total_rejections', 0))} rejections"
-                )
-        else:
-            st.info("No model rejection data available")
-
-    # Overall rejection reasons chart
-    if not reasons_df.empty:
-        st.subheader("🔍 Rejection Reasons Distribution")
-        reasons_display = reasons_df.copy()
-        reasons_display['reason_label'] = reasons_display['rejection_reason'].apply(get_rejection_label)
-
-        fig = px.bar(
-            reasons_display.sort_values('count', ascending=False),
-            x='reason_label',
-            y='count',
-            color='count',
-            color_continuous_scale='Reds',
-            text='count'
-        )
-        fig.update_traces(textposition='outside')
-        fig.update_layout(
-            template="plotly_dark",
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            xaxis_title="Rejection Reason",
-            yaxis_title="Count",
-            showlegend=False,
-            height=350
-        )
-        fig.update_xaxes(tickangle=-45)
-        st.plotly_chart(fig, use_container_width=True)
-
-    st.markdown("---")
-
-    # ========================================================================
-    # MODEL PERFORMANCE ANALYSIS
-    # ========================================================================
-    st.header("🤖 Model Performance Analysis")
-
-    model_df = analysis.get('by_model', pd.DataFrame())
-
-    if not model_df.empty:
-        col1, col2 = st.columns(2)
-
-        with col1:
-            st.subheader("📊 Rejection Rate by Model")
-            fig = px.bar(
-                model_df.sort_values('rejection_rate', ascending=True),
-                y='llm_model',
-                x='rejection_rate',
-                orientation='h',
-                color='rejection_rate',
-                color_continuous_scale='RdYlGn_r',
-                text='rejection_rate'
-            )
-            fig.update_traces(texttemplate='%{text:.1f}%', textposition='outside')
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                xaxis_title="Rejection Rate (%)",
-                yaxis_title="Model",
-                showlegend=False
-            )
-            st.plotly_chart(fig, use_container_width=True)
-
-        with col2:
-            st.subheader("📈 Messages vs Rejections by Model")
-            fig = go.Figure()
-            fig.add_trace(go.Bar(
-                x=model_df['llm_model'],
-                y=model_df['total_messages_generated'],
-                name='Total Messages',
-                marker_color=theme['primary']
-            ))
-            fig.add_trace(go.Bar(
-                x=model_df['llm_model'],
-                y=model_df['total_rejections'],
-                name='Rejections',
-                marker_color='#ff4444'
-            ))
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                xaxis_title="Model",
-                yaxis_title="Count",
-                barmode='group'
-            )
-            st.plotly_chart(fig, use_container_width=True)
-
-        # Model performance table
-        st.subheader("📋 Detailed Model Statistics")
-        st.dataframe(
-            model_df,
-            use_container_width=True,
-            hide_index=True,
-            column_config={
-                "llm_model": "Model",
-                "total_rejections": st.column_config.NumberColumn("Rejections", format="%d"),
-                "unique_users_rejected": st.column_config.NumberColumn("Unique Users", format="%d"),
-                "total_messages_generated": st.column_config.NumberColumn("Total Messages", format="%d"),
-                "rejection_rate": st.column_config.NumberColumn("Rejection Rate", format="%.2f%%")
-            }
-        )
-    else:
-        st.info("No model performance data available for this campaign")
-
-    st.markdown("---")
-
-    # ========================================================================
-    # COMPREHENSIVE STAGE ANALYSIS
-    # ========================================================================
-    st.header("📍 Comprehensive Stage Analysis")
-
-    stage_df = analysis.get('by_stage', pd.DataFrame())
-    reasons_by_stage_df = analysis.get('reasons_by_stage', pd.DataFrame())
-
-    if not stage_df.empty:
-        # Messages vs Rejections Chart
-        st.subheader("📊 Messages vs Rejections by Stage")
-        fig = go.Figure()
-        fig.add_trace(go.Bar(
-            x=stage_df['stage'],
-            y=stage_df['total_messages'],
-            name='Total Messages',
-            marker_color=theme['primary'],
-            text=stage_df['total_messages'],
-            textposition='outside'
-        ))
-        fig.add_trace(go.Bar(
-            x=stage_df['stage'],
-            y=stage_df['total_rejections'],
-            name='Rejections',
-            marker_color='#ff4444',
-            text=stage_df['total_rejections'],
-            textposition='outside'
-        ))
-        fig.update_layout(
-            template="plotly_dark",
-            paper_bgcolor='rgba(0,0,0,0)',
-            plot_bgcolor='rgba(0,0,0,0)',
-            xaxis_title="Stage",
-            yaxis_title="Count",
-            barmode='group',
-            height=400
-        )
-        st.plotly_chart(fig, use_container_width=True)
-
-        # Comprehensive Stage Statistics Table
-        st.subheader("📋 Detailed Stage Metrics")
-
-        # Prepare display dataframe
-        stage_display = stage_df.copy()
-
-        # Column configuration for display
-        column_config = {
-            "stage": "Stage",
-            "total_messages": st.column_config.NumberColumn("Messages", format="%d"),
-            "total_rejections": st.column_config.NumberColumn("Rejections", format="%d"),
-            "rejection_rate": st.column_config.NumberColumn("Rejection Rate", format="%.2f%%"),
-            "unique_users_rejected": st.column_config.NumberColumn("Unique Users", format="%d"),
-            "experiments_count": st.column_config.NumberColumn("Experiments", format="%d"),
-            "models_used": "Models Used"
-        }
-
-        # Only show columns that exist
-        available_columns = [col for col in ['stage', 'total_messages', 'total_rejections', 'rejection_rate',
-                                             'unique_users_rejected', 'experiments_count', 'models_used']
-                           if col in stage_display.columns]
-
-        st.dataframe(
-            stage_display[available_columns],
-            use_container_width=True,
-            hide_index=True,
-            column_config=column_config
-        )
-
-        st.markdown("---")
-
-        # ========================================================================
-        # INTERACTIVE STAGE SELECTOR
-        # ========================================================================
-        st.subheader("🎯 Detailed Stage-by-Stage Analysis")
-        st.markdown("Select a stage to see detailed breakdown of models, rejection reasons, and performance metrics.")
-
-        # Stage selector
-        available_stages = sorted(stage_df['stage'].unique())
-
-        if len(available_stages) > 0:
-            selected_stage_detail = st.selectbox(
-                "Select Stage for Detailed View",
-                available_stages,
-                key='detailed_stage_selector'
-            )
-
-            # Get selected stage data
-            stage_info = stage_df[stage_df['stage'] == selected_stage_detail].iloc[0]
-
-            # Display stage metrics
-            col1, col2, col3, col4 = st.columns(4)
-
-            with col1:
-                st.metric("Total Messages", f"{int(stage_info.get('total_messages', 0)):,}")
-
-            with col2:
-                st.metric("Total Rejections", f"{int(stage_info.get('total_rejections', 0)):,}")
-
-            with col3:
-                st.metric("Rejection Rate", f"{stage_info.get('rejection_rate', 0):.2f}%")
-
-            with col4:
-                st.metric("Experiments", int(stage_info.get('experiments_count', 0)))
-
-            # Models used at this stage
-            st.markdown(f"**🤖 Models Used at Stage {selected_stage_detail}:**")
-            models_used = stage_info.get('models_used', 'N/A')
-            st.info(models_used)
-
-            # Rejection reasons for this stage
-            if not reasons_by_stage_df.empty:
-                stage_reasons = reasons_by_stage_df[reasons_by_stage_df['stage'] == selected_stage_detail].copy()
-
-                if not stage_reasons.empty:
-                    st.markdown(f"**🔍 Rejection Reasons for Stage {selected_stage_detail}:**")
-
-                    # Apply labels
-                    stage_reasons['reason_label'] = stage_reasons['rejection_reason'].apply(get_rejection_label)
-
-                    col1, col2 = st.columns(2)
-
-                    with col1:
-                        # Pie chart
-                        fig = px.pie(
-                            stage_reasons,
-                            values='count',
-                            names='reason_label',
-                            title=f"Rejection Reasons Distribution - Stage {selected_stage_detail}",
-                            color_discrete_sequence=px.colors.qualitative.Set3
-                        )
-                        fig.update_layout(
-                            template="plotly_dark",
-                            paper_bgcolor='rgba(0,0,0,0)',
-                            plot_bgcolor='rgba(0,0,0,0)',
-                            height=350
-                        )
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    with col2:
-                        # Bar chart
-                        fig = px.bar(
-                            stage_reasons.sort_values('count', ascending=False),
-                            x='reason_label',
-                            y='count',
-                            color='count',
-                            color_continuous_scale='Oranges',
-                            text='count',
-                            title=f"Top Rejection Reasons - Stage {selected_stage_detail}"
-                        )
-                        fig.update_traces(textposition='outside')
-                        fig.update_layout(
-                            template="plotly_dark",
-                            paper_bgcolor='rgba(0,0,0,0)',
-                            plot_bgcolor='rgba(0,0,0,0)',
-                            xaxis_title="Rejection Reason",
-                            yaxis_title="Count",
-                            showlegend=False,
-                            height=350
-                        )
-                        fig.update_xaxes(tickangle=-45)
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    # Comparison to other stages
-                    st.markdown(f"**📊 Stage {selected_stage_detail} Comparison:**")
-
-                    # Calculate average rejection rate across all stages
-                    avg_rejection_rate = stage_df['rejection_rate'].mean()
-                    stage_rejection_rate = stage_info.get('rejection_rate', 0)
-
-                    if stage_rejection_rate > avg_rejection_rate:
-                        delta_text = f"{stage_rejection_rate - avg_rejection_rate:.1f}% above average"
-                        st.warning(f"⚠️ This stage has a rejection rate **{stage_rejection_rate:.1f}%**, which is **{delta_text}**")
-                    elif stage_rejection_rate < avg_rejection_rate:
-                        delta_text = f"{avg_rejection_rate - stage_rejection_rate:.1f}% below average"
-                        st.success(f"✅ This stage has a rejection rate **{stage_rejection_rate:.1f}%**, which is **{delta_text}**")
-                    else:
-                        st.info(f"ℹ️ This stage has an average rejection rate of **{stage_rejection_rate:.1f}%**")
-
-                    # Show detailed breakdown table
-                    st.markdown("**📋 Detailed Rejection Breakdown:**")
-                    st.dataframe(
-                        stage_reasons[['reason_label', 'count']].rename(columns={'reason_label': 'Rejection Reason', 'count': 'Count'}),
-                        use_container_width=True,
-                        hide_index=True
-                    )
-                else:
-                    st.info(f"No rejection reasons data available for Stage {selected_stage_detail}")
-            else:
-                st.info("No rejection reasons data available")
-    else:
-        st.info("No stage-level data available for this campaign")
-
-    st.markdown("---")
-
-    # ========================================================================
-    # REJECTION REASONS ANALYSIS (Interactive)
-    # ========================================================================
-    st.header("🔍 Rejection Reasons Analysis")
-
-    # Get rejection reasons data
-    reasons_df = analysis.get('rejection_reasons', pd.DataFrame())
-    reasons_by_stage_df = analysis.get('reasons_by_stage', pd.DataFrame())
-    reasons_by_model_df = analysis.get('reasons_by_model', pd.DataFrame())
-
-    if not reasons_df.empty:
-        # Overall rejection reasons
-        st.subheader("📊 Overall Rejection Reasons Distribution")
-
-        # Apply labels to reasons
-        reasons_display = reasons_df.copy()
-        reasons_display['reason_label'] = reasons_display['rejection_reason'].apply(get_rejection_label)
-
-        col1, col2 = st.columns(2)
-
-        with col1:
-            # Pie chart
-            fig = px.pie(
-                reasons_display,
-                values='count',
-                names='reason_label',
-                title="Rejection Reasons Breakdown",
-                color_discrete_sequence=px.colors.qualitative.Set3
-            )
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)'
-            )
-            st.plotly_chart(fig, use_container_width=True)
-
-        with col2:
-            # Bar chart
-            fig = px.bar(
-                reasons_display.sort_values('count', ascending=False),
-                x='reason_label',
-                y='count',
-                color='count',
-                color_continuous_scale='Reds',
-                text='count'
-            )
-            fig.update_traces(textposition='outside')
-            fig.update_layout(
-                template="plotly_dark",
-                paper_bgcolor='rgba(0,0,0,0)',
-                plot_bgcolor='rgba(0,0,0,0)',
-                xaxis_title="Rejection Reason",
-                yaxis_title="Count",
-                showlegend=False
-            )
-            fig.update_xaxes(tickangle=-45)
-            st.plotly_chart(fig, use_container_width=True)
-
-        st.markdown("---")
-
-        # Interactive filtering section
-        st.subheader("🎛️ Interactive Rejection Analysis")
-
-        tab1, tab2 = st.tabs(["📍 By Stage", "🤖 By Model"])
-
-        with tab1:
-            # Rejection reasons by stage
-            if not reasons_by_stage_df.empty:
-                # Apply labels
-                reasons_by_stage_display = reasons_by_stage_df.copy()
-                reasons_by_stage_display['reason_label'] = reasons_by_stage_display['rejection_reason'].apply(get_rejection_label)
-
-                # Stage selector
-                available_stages = sorted(reasons_by_stage_display['stage'].unique())
-
-                if len(available_stages) > 0:
-                    selected_stage = st.selectbox(
-                        "Select Stage to Analyze",
-                        available_stages,
-                        key='stage_selector'
-                    )
-
-                    # Filter by selected stage
-                    stage_reasons = reasons_by_stage_display[reasons_by_stage_display['stage'] == selected_stage]
-
-                    col1, col2 = st.columns(2)
-
-                    with col1:
-                        # Pie chart for selected stage
-                        fig = px.pie(
-                            stage_reasons,
-                            values='count',
-                            names='reason_label',
-                            title=f"Rejection Reasons - Stage {selected_stage}",
-                            color_discrete_sequence=px.colors.qualitative.Pastel
-                        )
-                        fig.update_layout(
-                            template="plotly_dark",
-                            paper_bgcolor='rgba(0,0,0,0)',
-                            plot_bgcolor='rgba(0,0,0,0)'
-                        )
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    with col2:
-                        # Bar chart for selected stage
-                        fig = px.bar(
-                            stage_reasons.sort_values('count', ascending=False),
-                            x='reason_label',
-                            y='count',
-                            color='count',
-                            color_continuous_scale='Oranges',
-                            text='count'
-                        )
-                        fig.update_traces(textposition='outside')
-                        fig.update_layout(
-                            template="plotly_dark",
-                            paper_bgcolor='rgba(0,0,0,0)',
-                            plot_bgcolor='rgba(0,0,0,0)',
-                            xaxis_title="Rejection Reason",
-                            yaxis_title="Count",
-                            showlegend=False
-                        )
-                        fig.update_xaxes(tickangle=-45)
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    # Heatmap across all stages
-                    st.markdown("#### 🔥 Rejection Heatmap Across All Stages")
-                    pivot_data = reasons_by_stage_display.pivot_table(
-                        index='reason_label',
-                        columns='stage',
-                        values='count',
-                        fill_value=0
-                    )
-
-                    fig = px.imshow(
-                        pivot_data,
-                        labels=dict(x="Stage", y="Rejection Reason", color="Count"),
-                        x=pivot_data.columns,
-                        y=pivot_data.index,
-                        color_continuous_scale='Reds',
-                        aspect='auto'
-                    )
-                    fig.update_layout(
-                        template="plotly_dark",
-                        paper_bgcolor='rgba(0,0,0,0)',
-                        plot_bgcolor='rgba(0,0,0,0)'
-                    )
-                    st.plotly_chart(fig, use_container_width=True)
-            else:
-                st.info("No stage-level rejection reason data available")
-
-        with tab2:
-            # Rejection reasons by model
-            if not reasons_by_model_df.empty:
-                # Apply labels
-                reasons_by_model_display = reasons_by_model_df.copy()
-                reasons_by_model_display['reason_label'] = reasons_by_model_display['rejection_reason'].apply(get_rejection_label)
-
-                # Model selector
-                available_models = sorted(reasons_by_model_display['llm_model'].unique())
-
-                if len(available_models) > 0:
-                    selected_model = st.selectbox(
-                        "Select Model to Analyze",
-                        available_models,
-                        key='model_selector'
-                    )
-
-                    # Filter by selected model
-                    model_reasons = reasons_by_model_display[reasons_by_model_display['llm_model'] == selected_model]
-
-                    col1, col2 = st.columns(2)
-
-                    with col1:
-                        # Pie chart for selected model
-                        fig = px.pie(
-                            model_reasons,
-                            values='count',
-                            names='reason_label',
-                            title=f"Rejection Reasons - {selected_model}",
-                            color_discrete_sequence=px.colors.qualitative.Set2
-                        )
-                        fig.update_layout(
-                            template="plotly_dark",
-                            paper_bgcolor='rgba(0,0,0,0)',
-                            plot_bgcolor='rgba(0,0,0,0)'
-                        )
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    with col2:
-                        # Bar chart for selected model
-                        fig = px.bar(
-                            model_reasons.sort_values('count', ascending=False),
-                            x='reason_label',
-                            y='count',
-                            color='count',
-                            color_continuous_scale='Blues',
-                            text='count'
-                        )
-                        fig.update_traces(textposition='outside')
-                        fig.update_layout(
-                            template="plotly_dark",
-                            paper_bgcolor='rgba(0,0,0,0)',
-                            plot_bgcolor='rgba(0,0,0,0)',
-                            xaxis_title="Rejection Reason",
-                            yaxis_title="Count",
-                            showlegend=False
-                        )
-                        fig.update_xaxes(tickangle=-45)
-                        st.plotly_chart(fig, use_container_width=True)
-
-                    # Heatmap across all models
-                    st.markdown("#### 🔥 Rejection Heatmap Across All Models")
-                    pivot_data = reasons_by_model_display.pivot_table(
-                        index='reason_label',
-                        columns='llm_model',
-                        values='count',
-                        fill_value=0
-                    )
-
-                    fig = px.imshow(
-                        pivot_data,
-                        labels=dict(x="Model", y="Rejection Reason", color="Count"),
-                        x=pivot_data.columns,
-                        y=pivot_data.index,
-                        color_continuous_scale='Blues',
-                        aspect='auto'
-                    )
-                    fig.update_layout(
-                        template="plotly_dark",
-                        paper_bgcolor='rgba(0,0,0,0)',
-                        plot_bgcolor='rgba(0,0,0,0)'
-                    )
-                    st.plotly_chart(fig, use_container_width=True)
-            else:
-                st.info("No model-level rejection reason data available")
-    else:
-        st.info("No rejection reason data available for this campaign")
-
-# ============================================================================
-# EXPORT SECTION
-# ============================================================================
-st.markdown("---")
-st.header("💾 Export Data")
-
-col1, col2, col3 = st.columns(3)
-
-with col1:
-    if st.button("📥 Export Campaigns Summary", use_container_width=True):
-        csv = campaigns_df.to_csv(index=False, encoding='utf-8')
-        st.download_button(
-            label="⬇️ Download Campaigns CSV",
-            data=csv,
-            file_name=f"{brand}_campaigns_summary_{datetime.now().strftime('%Y%m%d')}.csv",
-            mime="text/csv",
-            use_container_width=True
-        )
-
-with col2:
-    if st.button("📥 Export Experiments Summary", use_container_width=True):
-        csv = experiments_df.to_csv(index=False, encoding='utf-8')
-        st.download_button(
-            label="⬇️ Download Experiments CSV",
-            data=csv,
-            file_name=f"{brand}_experiments_summary_{datetime.now().strftime('%Y%m%d')}.csv",
-            mime="text/csv",
-            use_container_width=True
-        )
-
-with col3:
-    if st.session_state.get('selected_campaign') and st.session_state.get('campaign_analysis'):
-        if st.button("📥 Export Campaign Analysis", use_container_width=True):
-            # Combine all analysis dataframes
-            analysis = st.session_state['campaign_analysis']
-
-            # Create a writer object
-            from io import BytesIO
-            output = BytesIO()
-            with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
-                if not analysis['by_stage'].empty:
-                    analysis['by_stage'].to_excel(writer, sheet_name='By Stage', index=False)
-                if not analysis['by_model'].empty:
-                    analysis['by_model'].to_excel(writer, sheet_name='By Model', index=False)
-                if not analysis['rejection_reasons'].empty:
-                    analysis['rejection_reasons'].to_excel(writer, sheet_name='Rejection Reasons', index=False)
-                if not analysis['reasons_by_stage'].empty:
-                    analysis['reasons_by_stage'].to_excel(writer, sheet_name='Reasons by Stage', index=False)
-                if not analysis['reasons_by_model'].empty:
-                    analysis['reasons_by_model'].to_excel(writer, sheet_name='Reasons by Model', index=False)
-
-            st.download_button(
-                label="⬇️ Download Analysis Excel",
-                data=output.getvalue(),
-                file_name=f"{brand}_{selected_campaign}_analysis_{datetime.now().strftime('%Y%m%d')}.xlsx",
-                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                use_container_width=True
-            )
-
-st.markdown("---")
-st.markdown("**💡 Pro Tip:** Use the campaign selector to drill down into specific campaigns and identify patterns in model performance and rejection reasons!")

visualization/requirements.txt

@@ -1,23 +0,0 @@
-# AI Messaging System - Visualization Tool Requirements
-
-# Core Dependencies
-streamlit>=1.28.0
-pandas>=2.0.0
-python-dotenv>=1.0.0
-
-# Data Visualization
-plotly>=5.17.0
-
-# Snowflake Integration
-snowflake-snowpark-python>=1.9.0
-
-# AI/LLM APIs
-openai>=1.3.0
-google-generativeai>=0.3.0
-
-# Utility Libraries
-pathlib>=1.0.1
-tqdm>=4.66.0
-
-# Note: The ai_messaging_system_v2 package must be in the parent directory
-# and its dependencies will be inherited from the main project

visualization/utils/__init__.py

@@ -1,28 +0,0 @@
-"""
-Utility modules for the AI Messaging System Visualization Tool.
-
-Modules:
-- auth: Authentication and access control
-- data_loader: Data loading from Snowflake and CSV files
-- config_manager: Configuration persistence and management
-- theme: Brand-specific theming and styling
-- feedback_manager: Feedback storage and retrieval
-"""
-
-from .auth import verify_login, check_authentication, AUTHORIZED_EMAILS
-from .theme import get_brand_theme, apply_theme, BRAND_COLORS
-from .data_loader import DataLoader
-from .config_manager import ConfigManager
-from .feedback_manager import FeedbackManager
-
-__all__ = [
-    'verify_login',
-    'check_authentication',
-    'AUTHORIZED_EMAILS',
-    'get_brand_theme',
-    'apply_theme',
-    'BRAND_COLORS',
-    'DataLoader',
-    'ConfigManager',
-    'FeedbackManager',
-]

visualization/utils/auth.py

@@ -1,101 +0,0 @@
-"""
-Authentication module for the AI Messaging System Visualization Tool.
-
-Handles user authentication and access control.
-"""
-
-import os
-import streamlit as st
-from pathlib import Path
-from dotenv import load_dotenv
-
-# Load environment variables from .env file in visualization directory
-env_path = Path(__file__).parent.parent / '.env'
-if env_path.exists():
-    load_dotenv(env_path)
-else:
-    # Try parent directory .env
-    parent_env_path = Path(__file__).parent.parent.parent / '.env'
-    if parent_env_path.exists():
-        load_dotenv(parent_env_path)
-
-# Authorized emails - team members only
-AUTHORIZED_EMAILS = {
-    "danial@musora.com",
-    "danial.ebrat@gmail.com",
-    "simon@musora.com",
-    "una@musora.com",
-    "mark@musora.com",
-    "gabriel@musora.com",
-    "nikki@musora.com"
-}
-
-
-def get_credential(key: str) -> str:
-    """
-    Get credential from environment variables.
-
-    Args:
-        key: Credential key
-
-    Returns:
-        str: Credential value
-    """
-    return os.getenv(key, "")
-
-
-def get_valid_token() -> str:
-    """
-    Get the valid access token from environment.
-
-    Returns:
-        str: Valid access token
-    """
-    return get_credential("APP_TOKEN")
-
-
-def verify_login(email: str, token: str) -> bool:
-    """
-    Verify user login credentials.
-
-    Args:
-        email: User email address
-        token: Access token
-
-    Returns:
-        bool: True if credentials are valid, False otherwise
-    """
-    valid_token = get_valid_token()
-    email_normalized = email.lower().strip()
-
-    return (email_normalized in AUTHORIZED_EMAILS) and (token == valid_token)
-
-
-def check_authentication() -> bool:
-    """
-    Check if user is authenticated in current session.
-
-    Returns:
-        bool: True if authenticated, False otherwise
-    """
-    return st.session_state.get("authenticated", False)
-
-
-def get_current_user() -> str:
-    """
-    Get the currently logged-in user's email.
-
-    Returns:
-        str: User email or empty string if not authenticated
-    """
-    return st.session_state.get("user_email", "")
-
-
-def logout():
-    """
-    Log out the current user by clearing session state.
-    """
-    if "authenticated" in st.session_state:
-        del st.session_state["authenticated"]
-    if "user_email" in st.session_state:
-        del st.session_state["user_email"]

visualization/utils/config_manager.py

@@ -1,361 +0,0 @@
-"""
-Configuration management module for the AI Messaging System Visualization Tool.
-
-Handles saving, loading, and managing campaign configurations from Snowflake.
-"""
-
-import json
-from typing import Dict, List, Optional
-import streamlit as st
-from snowflake.snowpark import Session
-from .db_manager import UIDatabaseManager
-
-
-class ConfigManager:
-    """
-    Manages campaign configurations from Snowflake with automatic versioning.
-    """
-
-    def __init__(self, session: Optional[Session] = None):
-        """
-        Initialize ConfigManager with optional Snowflake session.
-
-        Args:
-            session: Optional Snowflake Snowpark session. If not provided,
-                    must be set later using set_session()
-        """
-        self.session = session
-        self.db_manager = None
-
-        if session:
-            self.db_manager = UIDatabaseManager(session)
-
-    def set_session(self, session: Session):
-        """
-        Set Snowflake session for database operations.
-
-        Args:
-            session: Snowflake Snowpark session
-        """
-        self.session = session
-        self.db_manager = UIDatabaseManager(session)
-
-    def _ensure_db_manager(self):
-        """Ensure database manager is initialized."""
-        if self.db_manager is None:
-            raise RuntimeError(
-                "ConfigManager requires a Snowflake session. "
-                "Call set_session() or provide session in constructor."
-            )
-
-    def load_default_config(self, brand: str, campaign_type: str = "re_engagement") -> Dict:
-        """
-        Load default configuration from Snowflake.
-        Looks for config named "{brand}_{campaign_type}_test".
-
-        Args:
-            brand: Brand name
-            campaign_type: Campaign type (default: re_engagement)
-
-        Returns:
-            dict: Campaign configuration
-        """
-        self._ensure_db_manager()
-
-        try:
-            config_name = f"{brand}_{campaign_type}_test"
-            all_configs = self.db_manager.load_configs(brand)
-
-            if config_name in all_configs:
-                return all_configs[config_name]
-            else:
-                st.warning(f"Default config '{config_name}' not found in Snowflake")
-                return {}
-
-        except Exception as e:
-            st.error(f"Error loading default config: {e}")
-            return {}
-
-    def save_custom_config(self, brand: str, config_name: str, config: Dict) -> bool:
-        """
-        Save custom configuration to Snowflake with automatic versioning.
-        If config exists, automatically increments CONFIG_VERSION.
-
-        Args:
-            brand: Brand name
-            config_name: Configuration name
-            config: Configuration dictionary
-
-        Returns:
-            bool: True if saved successfully, False otherwise
-        """
-        self._ensure_db_manager()
-
-        try:
-            # Ensure brand is set in config
-            config['brand'] = brand
-
-            # Save to Snowflake (versioning is automatic)
-            success = self.db_manager.save_config(config_name, config, brand)
-
-            if success:
-                version = self.db_manager.get_config_version(config_name, brand)
-                st.success(f"✅ Saved '{config_name}' as version {version}")
-
-            return success
-
-        except Exception as e:
-            st.error(f"Error saving config: {e}")
-            return False
-
-    def load_custom_config(self, brand: str, config_name: str) -> Optional[Dict]:
-        """
-        Load custom configuration from Snowflake.
-        Returns the latest version.
-
-        Args:
-            brand: Brand name
-            config_name: Configuration name
-
-        Returns:
-            dict or None: Configuration dictionary or None if not found
-        """
-        self._ensure_db_manager()
-
-        try:
-            all_configs = self.db_manager.load_configs(brand)
-
-            if config_name in all_configs:
-                return all_configs[config_name]
-            else:
-                return None
-
-        except Exception as e:
-            st.error(f"Error loading config: {e}")
-            return None
-
-    def list_custom_configs(self, brand: str) -> List[str]:
-        """
-        List all custom configurations for a brand from Snowflake.
-        Returns only the latest version of each config.
-
-        Args:
-            brand: Brand name
-
-        Returns:
-            list: List of configuration names
-        """
-        self._ensure_db_manager()
-
-        try:
-            all_configs = self.db_manager.load_configs(brand)
-            return sorted(list(all_configs.keys()))
-
-        except Exception as e:
-            st.error(f"Error listing configs: {e}")
-            return []
-
-    def delete_custom_config(self, brand: str, config_name: str) -> bool:
-        """
-        Delete configuration (not implemented for Snowflake version).
-        Configurations in Snowflake are versioned and should not be deleted.
-
-        Args:
-            brand: Brand name
-            config_name: Configuration name
-
-        Returns:
-            bool: Always False (not supported)
-        """
-        st.warning("⚠️ Config deletion is not supported in Snowflake version. Configs are versioned.")
-        return False
-
-    def config_exists(self, brand: str, config_name: str) -> bool:
-        """
-        Check if a custom configuration exists in Snowflake.
-
-        Args:
-            brand: Brand name
-            config_name: Configuration name
-
-        Returns:
-            bool: True if exists, False otherwise
-        """
-        self._ensure_db_manager()
-
-        try:
-            all_configs = self.db_manager.load_configs(brand)
-            return config_name in all_configs
-
-        except Exception as e:
-            st.error(f"Error checking config existence: {e}")
-            return False
-
-    def get_all_configs(self, brand: str) -> Dict[str, Dict]:
-        """
-        Get all configurations (default + custom) for a brand from Snowflake.
-        Returns the latest version of each config.
-
-        Args:
-            brand: Brand name
-
-        Returns:
-            dict: Dictionary mapping config names to config dictionaries
-        """
-        self._ensure_db_manager()
-
-        try:
-            return self.db_manager.load_configs(brand)
-
-        except Exception as e:
-            st.error(f"Error getting all configs: {e}")
-            return {}
-
-    def create_config_from_ui(
-        self,
-        brand: str,
-        campaign_name: str,
-        campaign_type: str,
-        num_stages: int,
-        campaign_instructions: Optional[str],
-        stages_config: Dict[int, Dict]
-    ) -> Dict:
-        """
-        Create a configuration dictionary from UI inputs.
-
-        Args:
-            brand: Brand name
-            campaign_name: Campaign name
-            campaign_type: Campaign type
-            num_stages: Number of stages
-            campaign_instructions: Campaign-wide instructions (optional)
-            stages_config: Dictionary mapping stage numbers to stage configurations
-
-        Returns:
-            dict: Complete configuration dictionary
-        """
-        config = {
-            "brand": brand,
-            "campaign_type": campaign_type,
-            "campaign_name": campaign_name,
-            "campaign_instructions": campaign_instructions,
-        }
-
-        # Add stage configurations
-        for stage_num in range(1, num_stages + 1):
-            if stage_num in stages_config:
-                config[str(stage_num)] = stages_config[stage_num]
-
-        return config
-
-    def extract_stage_config(self, config: Dict, stage: int) -> Dict:
-        """
-        Extract configuration for a specific stage.
-
-        Args:
-            config: Complete configuration dictionary
-            stage: Stage number
-
-        Returns:
-            dict: Stage configuration
-        """
-        return config.get(str(stage), {})
-
-    def validate_config(self, config: Dict) -> tuple[bool, str]:
-        """
-        Validate configuration structure and required fields.
-
-        Args:
-            config: Configuration dictionary
-
-        Returns:
-            tuple: (is_valid, error_message)
-        """
-        required_fields = ["brand", "campaign_name"]
-
-        # Check required top-level fields
-        for field in required_fields:
-            if field not in config:
-                return False, f"Missing required field: {field}"
-
-        # Check if at least stage 1 exists
-        if "1" not in config:
-            return False, "Configuration must have at least stage 1"
-
-        # Validate stage 1 config
-        stage1 = config["1"]
-        required_stage_fields = ["stage", "model"]
-
-        for field in required_stage_fields:
-            if field not in stage1:
-                return False, f"Stage 1 missing required field: {field}"
-
-        return True, ""
-
-    def duplicate_config(self, brand: str, source_name: str, new_name: str) -> bool:
-        """
-        Duplicate an existing configuration with a new name.
-        The new config will start at version 1.
-
-        Args:
-            brand: Brand name
-            source_name: Source configuration name
-            new_name: New configuration name
-
-        Returns:
-            bool: True if duplicated successfully, False otherwise
-        """
-        self._ensure_db_manager()
-
-        try:
-            # Load source config
-            source_config = self.load_custom_config(brand, source_name)
-
-            if source_config is None:
-                st.error(f"Source config '{source_name}' not found")
-                return False
-
-            # Update campaign name in config to match new config name
-            source_config['campaign_name'] = new_name
-
-            # Save as new config (will create version 1)
-            return self.save_custom_config(brand, new_name, source_config)
-
-        except Exception as e:
-            st.error(f"Error duplicating config: {e}")
-            return False
-
-    def get_config_version(self, brand: str, config_name: str) -> int:
-        """
-        Get the latest version number for a configuration.
-
-        Args:
-            brand: Brand name
-            config_name: Configuration name
-
-        Returns:
-            int: Latest version number (0 if config doesn't exist)
-        """
-        self._ensure_db_manager()
-
-        try:
-            return self.db_manager.get_config_version(config_name, brand)
-
-        except Exception as e:
-            st.error(f"Error getting config version: {e}")
-            return 0
-
-    def get_config_history(self, brand: str, config_name: str) -> List[int]:
-        """
-        Get version history for a configuration.
-
-        Args:
-            brand: Brand name
-            config_name: Configuration name
-
-        Returns:
-            list: List of version numbers
-        """
-        # Note: This would require additional implementation in db_manager
-        # For now, return empty list
-        return []

visualization/utils/data_loader.py

@@ -1,230 +0,0 @@
-"""
-Data loading module for the AI Messaging System Visualization Tool.
-
-Handles data loading from local CSV files only.
-"""
-
-import sys
-import pandas as pd
-from pathlib import Path
-from typing import Optional
-import streamlit as st
-
-# Add parent directory to path to import from ai_messaging_system_v2
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-try:
-    from ai_messaging_system_v2.Messaging_system.Permes import Permes
-except ImportError as e:
-    st.error(f"Error importing AI Messaging System modules: {e}")
-
-
-class DataLoader:
-    """
-    Handles all data loading operations for the visualization tool.
-    """
-
-    def __init__(self):
-        """Initialize DataLoader."""
-        self.base_path = Path(__file__).parent.parent
-        self.ui_users_path = self.base_path / "data" / "UI_users"
-        self.ui_output_path = Path(__file__).parent.parent.parent / "ai_messaging_system_v2" / "Data" / "ui_output"
-
-        # Create directories if they don't exist
-        self.ui_users_path.mkdir(parents=True, exist_ok=True)
-        self.ui_output_path.mkdir(parents=True, exist_ok=True)
-
-    def load_brand_users(self, brand: str) -> Optional[pd.DataFrame]:
-        """
-        Load all users for a brand from UI_users directory.
-
-        Args:
-            brand: Brand name
-
-        Returns:
-            pd.DataFrame or None: All users for the brand or None if file doesn't exist
-        """
-        file_path = self.ui_users_path / f"{brand}_users.csv"
-
-        if not file_path.exists():
-            st.error(f"User file not found: {brand}_users.csv")
-            return None
-
-        try:
-            users_df = pd.read_csv(file_path, encoding='utf-8-sig')
-            return users_df
-        except Exception as e:
-            st.error(f"Error loading users from {brand}_users.csv: {e}")
-            return None
-
-    def sample_users_randomly(self, brand: str, sample_size: int) -> Optional[pd.DataFrame]:
-        """
-        Randomly sample users from the brand's user file.
-
-        Args:
-            brand: Brand name
-            sample_size: Number of users to sample (1-25)
-
-        Returns:
-            pd.DataFrame or None: Sampled users or None if error
-        """
-        try:
-            # Load all users for the brand
-            all_users = self.load_brand_users(brand)
-
-            if all_users is None or len(all_users) == 0:
-                st.error(f"No users available for {brand}")
-                return None
-
-            # Validate sample size
-            if sample_size < 1:
-                sample_size = 1
-            if sample_size > min(25, len(all_users)):
-                sample_size = min(25, len(all_users))
-
-            # Randomly sample
-            sampled_users = all_users.sample(n=sample_size, random_state=None)
-
-            return sampled_users
-
-        except Exception as e:
-            st.error(f"Error sampling users: {e}")
-            return None
-
-    def has_brand_users(self, brand: str) -> bool:
-        """
-        Check if user file exists for a brand.
-
-        Args:
-            brand: Brand name
-
-        Returns:
-            bool: True if file exists, False otherwise
-        """
-        file_path = self.ui_users_path / f"{brand}_users.csv"
-        return file_path.exists()
-
-    def get_brand_user_count(self, brand: str) -> int:
-        """
-        Get the total number of users available for a brand.
-
-        Args:
-            brand: Brand name
-
-        Returns:
-            int: Number of users available
-        """
-        users_df = self.load_brand_users(brand)
-        if users_df is not None:
-            return len(users_df)
-        return 0
-
-    def load_generated_messages(self) -> Optional[pd.DataFrame]:
-        """
-        Load generated messages from UI output folder.
-
-        Returns:
-            pd.DataFrame or None: Generated messages or None if file doesn't exist
-        """
-        messages_file = self.ui_output_path / "messages.csv"
-
-        if messages_file.exists():
-            return pd.read_csv(messages_file, encoding='utf-8-sig')
-        return None
-
-    def clear_ui_output(self):
-        """
-        Clear UI output files (messages and costs).
-        """
-        try:
-            Permes.clear_ui_output()
-            st.success("UI output cleared successfully!")
-        except Exception as e:
-            st.error(f"Error clearing UI output: {e}")
-
-    def get_ui_output_path(self) -> Path:
-        """
-        Get path to UI output directory.
-
-        Returns:
-            Path: UI output directory path
-        """
-        return self.ui_output_path
-
-
-    def get_message_stats(self) -> dict:
-        """
-        Get statistics about generated messages.
-
-        Returns:
-            dict: Statistics including total messages, stages, users, etc.
-        """
-        messages_df = self.load_generated_messages()
-
-        if messages_df is None or len(messages_df) == 0:
-            return {
-                "total_messages": 0,
-                "total_users": 0,
-                "total_stages": 0,
-                "campaigns": []
-            }
-
-        stats = {
-            "total_messages": len(messages_df),
-            "total_users": messages_df['user_id'].nunique() if 'user_id' in messages_df.columns else 0,
-            "total_stages": messages_df['stage'].nunique() if 'stage' in messages_df.columns else 0,
-            "campaigns": messages_df['campaign_name'].unique().tolist() if 'campaign_name' in messages_df.columns else []
-        }
-
-        return stats
-
-    def filter_messages_by_stage(self, messages_df: pd.DataFrame, stage: int) -> pd.DataFrame:
-        """
-        Filter messages by stage number.
-
-        Args:
-            messages_df: Messages DataFrame
-            stage: Stage number
-
-        Returns:
-            pd.DataFrame: Filtered messages
-        """
-        if 'stage' in messages_df.columns:
-            return messages_df[messages_df['stage'] == stage]
-        return pd.DataFrame()
-
-    def filter_messages_by_user(self, messages_df: pd.DataFrame, user_id: int) -> pd.DataFrame:
-        """
-        Filter messages by user ID.
-
-        Args:
-            messages_df: Messages DataFrame
-            user_id: User ID
-
-        Returns:
-            pd.DataFrame: Filtered messages
-        """
-        if 'user_id' in messages_df.columns:
-            return messages_df[messages_df['user_id'] == user_id]
-        return pd.DataFrame()
-
-    def search_messages(self, messages_df: pd.DataFrame, search_term: str) -> pd.DataFrame:
-        """
-        Search messages by keyword in message content.
-
-        Args:
-            messages_df: Messages DataFrame
-            search_term: Search keyword
-
-        Returns:
-            pd.DataFrame: Filtered messages containing the search term
-        """
-        if len(search_term) == 0:
-            return messages_df
-
-        # Search in message column (which contains JSON)
-        if 'message' in messages_df.columns:
-            mask = messages_df['message'].astype(str).str.contains(search_term, case=False, na=False)
-            return messages_df[mask]
-
-        return pd.DataFrame()

visualization/utils/db_manager.py

@@ -1,700 +0,0 @@
-"""
-Database Manager for UI Operations
-
-Handles all Snowflake operations for the UI including:
-- Campaign configuration management
-- Feedback storage and retrieval
-- Experiment metadata tracking
-- Historical analytics queries
-"""
-
-import pandas as pd
-import json
-from datetime import datetime, timezone
-from typing import Dict, List, Optional, Tuple
-from snowflake.snowpark import Session
-import streamlit as st
-
-
-class UIDatabaseManager:
-    """
-    Manages all Snowflake database operations for the UI.
-    """
-
-    # Table names
-    CONFIG_TABLE = "MESSAGING_SYSTEM_V2.UI.CAMPAIGN_CONFIGURATIONS"
-    FEEDBACK_TABLE = "MESSAGING_SYSTEM_V2.UI.FEEDBACKS"
-    METADATA_TABLE = "MESSAGING_SYSTEM_V2.UI.EXPERIMENT_METADATA"
-
-    def __init__(self, session: Session):
-        """
-        Initialize database manager with Snowflake session.
-
-        Args:
-            session: Active Snowflake Snowpark session
-        """
-        self.session = session
-
-    # ========== CONFIG OPERATIONS ==========
-
-    def load_configs(self, brand: str) -> Dict[str, Dict]:
-        """
-        Load all configurations for a brand from Snowflake.
-        Returns the latest version of each config.
-
-        Args:
-            brand: Brand name
-
-        Returns:
-            dict: Dictionary mapping config names to config data
-        """
-        try:
-            # Get latest version of each config for the brand
-            query = f"""
-                WITH RankedConfigs AS (
-                    SELECT
-                        CONFIG_NAME,
-                        CONFIG_FILE,
-                        CONFIG_VERSION,
-                        BRAND,
-                        ROW_NUMBER() OVER (PARTITION BY CONFIG_NAME ORDER BY CONFIG_VERSION DESC) as rn
-                    FROM {self.CONFIG_TABLE}
-                    WHERE BRAND = '{brand}'
-                )
-                SELECT CONFIG_NAME, CONFIG_FILE, CONFIG_VERSION
-                FROM RankedConfigs
-                WHERE rn = 1
-                ORDER BY CONFIG_NAME
-            """
-
-            result_df = self.session.sql(query).to_pandas()
-
-            configs = {}
-            for _, row in result_df.iterrows():
-                config_name = row['CONFIG_NAME']
-                config_file = row['CONFIG_FILE']
-
-                # Parse JSON from VARIANT column
-                if isinstance(config_file, str):
-                    config_data = json.loads(config_file)
-                else:
-                    config_data = config_file
-
-                configs[config_name] = config_data
-
-            print(f"✅ Loaded {len(configs)} configs for {brand} from Snowflake")
-            return configs
-
-        except Exception as e:
-            st.error(f"Error loading configs from Snowflake: {e}")
-            return {}
-
-    def save_config(self, config_name: str, config_data: Dict, brand: str) -> bool:
-        """
-        Save configuration to Snowflake with automatic versioning.
-        If config exists, increments CONFIG_VERSION automatically.
-
-        Args:
-            config_name: Configuration name
-            config_data: Configuration dictionary
-            brand: Brand name
-
-        Returns:
-            bool: True if saved successfully
-        """
-        try:
-            # Get current max version for this config
-            query = f"""
-                SELECT MAX(CONFIG_VERSION) as MAX_VERSION
-                FROM {self.CONFIG_TABLE}
-                WHERE CONFIG_NAME = '{config_name}' AND BRAND = '{brand}'
-            """
-
-            result = self.session.sql(query).to_pandas()
-
-            if len(result) > 0 and pd.notna(result['MAX_VERSION'].iloc[0]):
-                new_version = int(result['MAX_VERSION'].iloc[0]) + 1
-            else:
-                new_version = 1
-
-            # Convert config to JSON string
-            config_json = json.dumps(config_data, ensure_ascii=False)
-
-            # Create dataframe with the config data
-            df = pd.DataFrame([{
-                'CONFIG_NAME': config_name,
-                'CONFIG_FILE': config_json,
-                'CONFIG_VERSION': new_version,
-                'BRAND': brand
-            }])
-
-            # Write to Snowflake using write_pandas (safer than raw SQL for JSON)
-            self.session.write_pandas(
-                df=df,
-                table_name=self.CONFIG_TABLE.split('.')[-1],
-                database=self.CONFIG_TABLE.split('.')[0],
-                schema=self.CONFIG_TABLE.split('.')[1],
-                auto_create_table=True,
-                overwrite=False
-            )
-
-            print(f"✅ Saved config '{config_name}' version {new_version} for {brand}")
-            return True
-
-        except Exception as e:
-            st.error(f"Error saving config to Snowflake: {e}")
-            import traceback
-            st.error(f"Traceback: {traceback.format_exc()}")
-            return False
-
-    def get_config_version(self, config_name: str, brand: str) -> int:
-        """
-        Get the latest version number for a configuration.
-
-        Args:
-            config_name: Configuration name
-            brand: Brand name
-
-        Returns:
-            int: Latest version number (0 if config doesn't exist)
-        """
-        try:
-            query = f"""
-                SELECT MAX(CONFIG_VERSION) as MAX_VERSION
-                FROM {self.CONFIG_TABLE}
-                WHERE CONFIG_NAME = '{config_name}' AND BRAND = '{brand}'
-            """
-
-            result = self.session.sql(query).to_pandas()
-
-            if len(result) > 0 and pd.notna(result['MAX_VERSION'].iloc[0]):
-                return int(result['MAX_VERSION'].iloc[0])
-            return 0
-
-        except Exception as e:
-            st.error(f"Error getting config version: {e}")
-            return 0
-
-    # ========== EXPERIMENT METADATA OPERATIONS ==========
-
-    def store_experiment_metadata(self, metadata: Dict) -> bool:
-        """
-        Store experiment metadata for a single stage.
-
-        Args:
-            metadata: Dictionary containing:
-                - experiment_id: Unique experiment identifier
-                - config_name: Configuration name used
-                - brand: Brand name
-                - campaign_name: Campaign name
-                - stage: Stage number
-                - llm_model: LLM model used
-                - total_messages: Number of messages generated
-                - total_users: Number of users
-                - platform: Platform (push/app)
-                - personalization: Boolean
-                - involve_recsys: Boolean
-                - recsys_contents: JSON string of content types
-                - segment_info: Segment description
-                - campaign_instructions: Campaign instructions
-                - per_message_instructions: Per-message instructions
-                - timestamp: Timestamp
-
-        Returns:
-            bool: True if stored successfully
-        """
-        try:
-            # Get timestamp and ensure it's a datetime object
-            timestamp_value = datetime.now(timezone.utc)
-
-            # Create dataframe from metadata
-            df = pd.DataFrame([{
-                'EXPERIMENT_ID': metadata.get('experiment_id'),
-                'CONFIG_NAME': metadata.get('config_name'),
-                'BRAND': metadata.get('brand'),
-                'CAMPAIGN_NAME': metadata.get('campaign_name'),
-                'STAGE': metadata.get('stage'),
-                'LLM_MODEL': metadata.get('llm_model'),
-                'TOTAL_MESSAGES': metadata.get('total_messages'),
-                'TOTAL_USERS': metadata.get('total_users'),
-                'PLATFORM': metadata.get('platform', 'push'),
-                'PERSONALIZATION': metadata.get('personalization', True),
-                'INVOLVE_RECSYS': metadata.get('involve_recsys', True),
-                'RECSYS_CONTENTS': json.dumps(metadata.get('recsys_contents', [])),
-                'SEGMENT_INFO': metadata.get('segment_info'),
-                'CAMPAIGN_INSTRUCTIONS': metadata.get('campaign_instructions'),
-                'PER_MESSAGE_INSTRUCTIONS': metadata.get('per_message_instructions'),
-                'TIMESTAMP': timestamp_value
-            }])
-
-            # Ensure TIMESTAMP column is datetime64
-            df['TIMESTAMP'] = pd.to_datetime(df['TIMESTAMP'], utc=True,errors="coerce")
-
-            # Write to Snowflake
-            self.session.write_pandas(
-                df=df,
-                table_name=self.METADATA_TABLE.split('.')[-1],
-                database=self.METADATA_TABLE.split('.')[0],
-                schema=self.METADATA_TABLE.split('.')[1],
-                auto_create_table=True,
-                overwrite=False,
-                use_logical_type=True
-            )
-
-            print(f"✅ Stored metadata for experiment {metadata.get('experiment_id')} stage {metadata.get('stage')}")
-            return True
-
-        except Exception as e:
-            st.error(f"Error storing experiment metadata: {e}")
-            return False
-
-    def store_experiment_metadata_batch(self, metadata_list: List[Dict]) -> bool:
-        """
-        Store multiple experiment metadata records (for multi-stage experiments).
-
-        Args:
-            metadata_list: List of metadata dictionaries
-
-        Returns:
-            bool: True if all stored successfully
-        """
-        try:
-            for metadata in metadata_list:
-                if not self.store_experiment_metadata(metadata):
-                    return False
-            return True
-        except Exception as e:
-            st.error(f"Error storing batch metadata: {e}")
-            return False
-
-    # ========== FEEDBACK OPERATIONS ==========
-
-    def store_feedback_batch(self, feedback_list: List[Dict]) -> bool:
-        """
-        Store a batch of feedback records to Snowflake.
-
-        Args:
-            feedback_list: List of feedback dictionaries containing:
-                - config_name
-                - brand
-                - experiment_id
-                - user_id
-                - stage
-                - feedback_type
-                - rejection_reason
-                - rejection_text
-                - campaign_name
-                - message_header
-                - message_body
-                - timestamp
-
-        Returns:
-            bool: True if stored successfully
-        """
-        try:
-            if not feedback_list or len(feedback_list) == 0:
-                print("⚠️  No feedback to store")
-                return True
-
-            # Create dataframe from feedback list with proper timestamp handling
-            records = []
-            for fb in feedback_list:
-                # Ensure timestamp is a datetime object
-                timestamp_value = datetime.now(timezone.utc)
-
-                records.append({
-                    'CONFIG_NAME': fb.get('config_name'),
-                    'BRAND': fb.get('brand'),
-                    'EXPERIMENT_ID': fb.get('experiment_id'),
-                    'USER_ID': fb.get('user_id'),
-                    'STAGE': fb.get('stage'),
-                    'FEEDBACK_TYPE': fb.get('feedback_type'),
-                    'REJECTION_REASON': fb.get('rejection_reason'),
-                    'REJECTION_TEXT': fb.get('rejection_text'),
-                    'CAMPAIGN_NAME': fb.get('campaign_name'),
-                    'MESSAGE_HEADER': fb.get('message_header'),
-                    'MESSAGE_BODY': fb.get('message_body'),
-                    'TIMESTAMP': timestamp_value
-                })
-
-            df = pd.DataFrame(records)
-
-            # Ensure TIMESTAMP column is datetime64
-            df['TIMESTAMP'] = pd.to_datetime(df['TIMESTAMP'], utc=True, errors="coerce")
-
-            # Write to Snowflake
-            self.session.write_pandas(
-                df=df,
-                table_name=self.FEEDBACK_TABLE.split('.')[-1],
-                database=self.FEEDBACK_TABLE.split('.')[0],
-                schema=self.FEEDBACK_TABLE.split('.')[1],
-                auto_create_table=True,
-                overwrite=False,
-                use_logical_type=True
-            )
-
-            print(f"✅ Stored {len(feedback_list)} feedback records to Snowflake")
-            return True
-
-        except Exception as e:
-            st.error(f"Error storing feedback batch: {e}")
-            return False
-
-    def load_historical_feedbacks(self, brand: Optional[str] = None,
-                                   start_date: Optional[datetime] = None,
-                                   end_date: Optional[datetime] = None) -> pd.DataFrame:
-        """
-        Load historical feedback records from Snowflake with optional filters.
-
-        Args:
-            brand: Optional brand filter
-            start_date: Optional start date filter
-            end_date: Optional end date filter
-
-        Returns:
-            pd.DataFrame: Feedback records
-        """
-        try:
-            where_clauses = []
-
-            if brand:
-                where_clauses.append(f"BRAND = '{brand}'")
-
-            if start_date:
-                where_clauses.append(f"TIMESTAMP >= '{start_date.isoformat()}'")
-
-            if end_date:
-                where_clauses.append(f"TIMESTAMP <= '{end_date.isoformat()}'")
-
-            where_sql = " AND ".join(where_clauses) if where_clauses else "1=1"
-
-            query = f"""
-                SELECT *
-                FROM {self.FEEDBACK_TABLE}
-                WHERE {where_sql}
-                ORDER BY TIMESTAMP DESC
-            """
-
-            result_df = self.session.sql(query).to_pandas()
-            result_df.columns = result_df.columns.str.lower()
-
-            print(f"✅ Loaded {len(result_df)} historical feedback records")
-            return result_df
-
-        except Exception as e:
-            st.error(f"Error loading historical feedbacks: {e}")
-            return pd.DataFrame()
-
-    # ========== HISTORICAL ANALYTICS OPERATIONS ==========
-
-    def load_historical_experiments(self, brand: Optional[str] = None,
-                                      start_date: Optional[datetime] = None,
-                                      end_date: Optional[datetime] = None) -> pd.DataFrame:
-        """
-        Load historical experiment metadata from Snowflake.
-
-        Args:
-            brand: Optional brand filter
-            start_date: Optional start date filter
-            end_date: Optional end date filter
-
-        Returns:
-            pd.DataFrame: Experiment metadata records
-        """
-        try:
-            where_clauses = []
-
-            if brand:
-                where_clauses.append(f"BRAND = '{brand}'")
-
-            if start_date:
-                where_clauses.append(f"TIMESTAMP >= '{start_date.isoformat()}'")
-
-            if end_date:
-                where_clauses.append(f"TIMESTAMP <= '{end_date.isoformat()}'")
-
-            where_sql = " AND ".join(where_clauses) if where_clauses else "1=1"
-
-            query = f"""
-                SELECT *
-                FROM {self.METADATA_TABLE}
-                WHERE {where_sql}
-                ORDER BY TIMESTAMP DESC, EXPERIMENT_ID, STAGE
-            """
-
-            result_df = self.session.sql(query).to_pandas()
-            result_df.columns = result_df.columns.str.lower()
-
-            print(f"✅ Loaded {len(result_df)} historical experiment records")
-            return result_df
-
-        except Exception as e:
-            st.error(f"Error loading historical experiments: {e}")
-            return pd.DataFrame()
-
-    def get_experiment_summary(self, brand: Optional[str] = None) -> pd.DataFrame:
-        """
-        Get summary statistics for all historical experiments.
-        Joins metadata and feedback tables for comprehensive view.
-
-        Args:
-            brand: Optional brand filter
-
-        Returns:
-            pd.DataFrame: Summary statistics per experiment
-        """
-        try:
-            brand_filter = f"WHERE m.BRAND = '{brand}'" if brand else ""
-
-            query = f"""
-                WITH ExperimentStats AS (
-                    SELECT
-                        m.EXPERIMENT_ID,
-                        m.BRAND,
-                        m.CAMPAIGN_NAME,
-                        m.CONFIG_NAME,
-                        MIN(m.TIMESTAMP) as START_TIME,
-                        MAX(m.TIMESTAMP) as END_TIME,
-                        COUNT(DISTINCT m.STAGE) as TOTAL_STAGES,
-                        SUM(m.TOTAL_MESSAGES) as TOTAL_MESSAGES,
-                        MAX(m.TOTAL_USERS) as TOTAL_USERS,
-                        LISTAGG(DISTINCT m.LLM_MODEL, ', ') as MODELS_USED
-                    FROM {self.METADATA_TABLE} m
-                    {brand_filter}
-                    GROUP BY m.EXPERIMENT_ID, m.BRAND, m.CAMPAIGN_NAME, m.CONFIG_NAME
-                ),
-                FeedbackStats AS (
-                    SELECT
-                        EXPERIMENT_ID,
-                        COUNT(*) as TOTAL_FEEDBACK,
-                        SUM(CASE WHEN FEEDBACK_TYPE = 'reject' THEN 1 ELSE 0 END) as TOTAL_REJECTS
-                    FROM {self.FEEDBACK_TABLE}
-                    {brand_filter.replace('m.', '')}
-                    GROUP BY EXPERIMENT_ID
-                )
-                SELECT
-                    e.*,
-                    COALESCE(f.TOTAL_FEEDBACK, 0) as TOTAL_FEEDBACK,
-                    COALESCE(f.TOTAL_REJECTS, 0) as TOTAL_REJECTS,
-                    CASE
-                        WHEN e.TOTAL_MESSAGES > 0
-                        THEN ROUND((COALESCE(f.TOTAL_REJECTS, 0) * 100.0 / e.TOTAL_MESSAGES), 2)
-                        ELSE 0
-                    END as REJECTION_RATE
-                FROM ExperimentStats e
-                LEFT JOIN FeedbackStats f ON e.EXPERIMENT_ID = f.EXPERIMENT_ID
-                ORDER BY e.START_TIME DESC
-            """
-
-            result_df = self.session.sql(query).to_pandas()
-            result_df.columns = result_df.columns.str.lower()
-
-            print(f"✅ Generated summary for {len(result_df)} experiments")
-            return result_df
-
-        except Exception as e:
-            st.error(f"Error generating experiment summary: {e}")
-            return pd.DataFrame()
-
-    def get_campaign_feedback_analysis(self, campaign_name: str, brand: Optional[str] = None) -> Dict:
-        """
-        Get detailed feedback analysis for a specific campaign.
-        Returns comprehensive statistics including model performance, stage analysis, and rejection reasons.
-
-        Args:
-            campaign_name: Campaign name to analyze
-            brand: Optional brand filter
-
-        Returns:
-            dict: Dictionary containing multiple analysis dataframes
-        """
-        try:
-            brand_filter = f"AND m.BRAND = '{brand}'" if brand else ""
-
-            # Query 1: Enhanced rejection distribution by stage (with messages and models)
-            stage_query = f"""
-                SELECT
-                    m.STAGE,
-                    SUM(m.TOTAL_MESSAGES) as TOTAL_MESSAGES,
-                    COUNT(f.EXPERIMENT_ID) as TOTAL_REJECTIONS,
-                    ROUND((COUNT(f.EXPERIMENT_ID) * 100.0 / NULLIF(SUM(m.TOTAL_MESSAGES), 0)), 2) as REJECTION_RATE,
-                    COUNT(DISTINCT f.USER_ID) as UNIQUE_USERS_REJECTED,
-                    COUNT(DISTINCT m.EXPERIMENT_ID) as EXPERIMENTS_COUNT,
-                    LISTAGG(DISTINCT m.LLM_MODEL, ', ') WITHIN GROUP (ORDER BY m.LLM_MODEL) as MODELS_USED
-                FROM {self.METADATA_TABLE} m
-                LEFT JOIN {self.FEEDBACK_TABLE} f
-                    ON m.EXPERIMENT_ID = f.EXPERIMENT_ID AND m.STAGE = f.STAGE
-                WHERE m.CAMPAIGN_NAME = '{campaign_name}' {brand_filter}
-                GROUP BY m.STAGE
-                ORDER BY m.STAGE
-            """
-
-            # Query 2: Rejection distribution by LLM model
-            model_query = f"""
-                SELECT
-                    m.LLM_MODEL,
-                    COUNT(f.EXPERIMENT_ID) as TOTAL_REJECTIONS,
-                    COUNT(DISTINCT f.USER_ID) as UNIQUE_USERS_REJECTED,
-                    SUM(m.TOTAL_MESSAGES) as TOTAL_MESSAGES_GENERATED,
-                    ROUND((COUNT(f.EXPERIMENT_ID) * 100.0 / NULLIF(SUM(m.TOTAL_MESSAGES), 0)), 2) as REJECTION_RATE
-                FROM {self.METADATA_TABLE} m
-                LEFT JOIN {self.FEEDBACK_TABLE} f
-                    ON m.EXPERIMENT_ID = f.EXPERIMENT_ID AND m.STAGE = f.STAGE
-                WHERE m.CAMPAIGN_NAME = '{campaign_name}' {brand_filter}
-                GROUP BY m.LLM_MODEL
-                ORDER BY REJECTION_RATE DESC
-            """
-
-            # Query 3: Rejection reasons breakdown
-            reasons_query = f"""
-                SELECT
-                    f.REJECTION_REASON,
-                    COUNT(*) as COUNT,
-                    COUNT(DISTINCT f.EXPERIMENT_ID) as EXPERIMENTS_AFFECTED
-                FROM {self.FEEDBACK_TABLE} f
-                JOIN {self.METADATA_TABLE} m
-                    ON f.EXPERIMENT_ID = m.EXPERIMENT_ID
-                WHERE m.CAMPAIGN_NAME = '{campaign_name}' {brand_filter}
-                GROUP BY f.REJECTION_REASON
-                ORDER BY COUNT DESC
-            """
-
-            # Query 4: Rejection reasons by stage
-            reasons_by_stage_query = f"""
-                SELECT
-                    f.STAGE,
-                    f.REJECTION_REASON,
-                    COUNT(*) as COUNT
-                FROM {self.FEEDBACK_TABLE} f
-                JOIN {self.METADATA_TABLE} m
-                    ON f.EXPERIMENT_ID = m.EXPERIMENT_ID
-                WHERE m.CAMPAIGN_NAME = '{campaign_name}' {brand_filter}
-                GROUP BY f.STAGE, f.REJECTION_REASON
-                ORDER BY f.STAGE, COUNT DESC
-            """
-
-            # Query 5: Rejection reasons by model
-            reasons_by_model_query = f"""
-                SELECT
-                    m.LLM_MODEL,
-                    f.REJECTION_REASON,
-                    COUNT(*) as COUNT
-                FROM {self.FEEDBACK_TABLE} f
-                JOIN {self.METADATA_TABLE} m
-                    ON f.EXPERIMENT_ID = m.EXPERIMENT_ID AND f.STAGE = m.STAGE
-                WHERE m.CAMPAIGN_NAME = '{campaign_name}' {brand_filter}
-                GROUP BY m.LLM_MODEL, f.REJECTION_REASON
-                ORDER BY m.LLM_MODEL, COUNT DESC
-            """
-
-            # Execute all queries
-            stage_df = self.session.sql(stage_query).to_pandas()
-            stage_df.columns = stage_df.columns.str.lower()
-
-            model_df = self.session.sql(model_query).to_pandas()
-            model_df.columns = model_df.columns.str.lower()
-
-            reasons_df = self.session.sql(reasons_query).to_pandas()
-            reasons_df.columns = reasons_df.columns.str.lower()
-
-            reasons_by_stage_df = self.session.sql(reasons_by_stage_query).to_pandas()
-            reasons_by_stage_df.columns = reasons_by_stage_df.columns.str.lower()
-
-            reasons_by_model_df = self.session.sql(reasons_by_model_query).to_pandas()
-            reasons_by_model_df.columns = reasons_by_model_df.columns.str.lower()
-
-            print(f"✅ Generated feedback analysis for campaign '{campaign_name}'")
-
-            return {
-                'by_stage': stage_df,
-                'by_model': model_df,
-                'rejection_reasons': reasons_df,
-                'reasons_by_stage': reasons_by_stage_df,
-                'reasons_by_model': reasons_by_model_df
-            }
-
-        except Exception as e:
-            st.error(f"Error generating campaign feedback analysis: {e}")
-            import traceback
-            st.error(f"Traceback: {traceback.format_exc()}")
-            return {
-                'by_stage': pd.DataFrame(),
-                'by_model': pd.DataFrame(),
-                'rejection_reasons': pd.DataFrame(),
-                'reasons_by_stage': pd.DataFrame(),
-                'reasons_by_model': pd.DataFrame()
-            }
-
-    def get_all_campaigns_summary(self, brand: Optional[str] = None) -> pd.DataFrame:
-        """
-        Get summary statistics for all campaigns (aggregating experiments by campaign).
-
-        Args:
-            brand: Optional brand filter
-
-        Returns:
-            pd.DataFrame: Summary statistics per campaign
-        """
-        try:
-            brand_filter = f"WHERE m.BRAND = '{brand}'" if brand else ""
-
-            query = f"""
-                WITH CampaignStats AS (
-                    SELECT
-                        m.CAMPAIGN_NAME,
-                        m.BRAND,
-                        COUNT(DISTINCT m.EXPERIMENT_ID) as TOTAL_EXPERIMENTS,
-                        COUNT(DISTINCT m.STAGE) as TOTAL_STAGES,
-                        SUM(m.TOTAL_MESSAGES) as TOTAL_MESSAGES,
-                        MAX(m.TOTAL_USERS) as TOTAL_USERS,
-                        LISTAGG(DISTINCT m.LLM_MODEL, ', ') WITHIN GROUP (ORDER BY m.LLM_MODEL) as MODELS_USED,
-                        MIN(m.TIMESTAMP) as FIRST_EXPERIMENT,
-                        MAX(m.TIMESTAMP) as LAST_EXPERIMENT
-                    FROM {self.METADATA_TABLE} m
-                    {brand_filter}
-                    GROUP BY m.CAMPAIGN_NAME, m.BRAND
-                ),
-                FeedbackStats AS (
-                    SELECT
-                        m.CAMPAIGN_NAME,
-                        COUNT(*) as TOTAL_FEEDBACK,
-                        COUNT(DISTINCT f.REJECTION_REASON) as UNIQUE_REJECTION_REASONS
-                    FROM {self.FEEDBACK_TABLE} f
-                    JOIN {self.METADATA_TABLE} m
-                        ON f.EXPERIMENT_ID = m.EXPERIMENT_ID
-                    {brand_filter.replace('m.', 'm.')}
-                    GROUP BY m.CAMPAIGN_NAME
-                )
-                SELECT
-                    c.*,
-                    COALESCE(f.TOTAL_FEEDBACK, 0) as TOTAL_REJECTIONS,
-                    COALESCE(f.UNIQUE_REJECTION_REASONS, 0) as UNIQUE_REJECTION_REASONS,
-                    CASE
-                        WHEN c.TOTAL_MESSAGES > 0
-                        THEN ROUND((COALESCE(f.TOTAL_FEEDBACK, 0) * 100.0 / c.TOTAL_MESSAGES), 2)
-                        ELSE 0
-                    END as REJECTION_RATE
-                FROM CampaignStats c
-                LEFT JOIN FeedbackStats f ON c.CAMPAIGN_NAME = f.CAMPAIGN_NAME
-                ORDER BY c.LAST_EXPERIMENT DESC
-            """
-
-            result_df = self.session.sql(query).to_pandas()
-            result_df.columns = result_df.columns.str.lower()
-
-            print(f"✅ Generated summary for {len(result_df)} campaigns")
-            return result_df
-
-        except Exception as e:
-            st.error(f"Error generating campaigns summary: {e}")
-            import traceback
-            st.error(f"Traceback: {traceback.format_exc()}")
-            return pd.DataFrame()
-
-    def close(self):
-        """Close the Snowflake session."""
-        try:
-            self.session.close()
-            print("✅ Snowflake session closed")
-        except Exception as e:
-            st.error(f"Error closing session: {e}")

visualization/utils/experiment_runner.py

@@ -1,276 +0,0 @@
-"""
-Experiment Runner Module
-
-Handles message generation for single and AB testing experiments.
-Works with session_state for in-memory data storage.
-"""
-
-import pandas as pd
-from datetime import datetime
-from typing import Dict, Tuple, Optional
-import streamlit as st
-from snowflake.snowpark import Session
-
-
-class ExperimentRunner:
-    """
-    Runs message generation experiments and manages in-memory data.
-    """
-
-    def __init__(self, brand: str, system_config: dict):
-        """
-        Initialize experiment runner.
-
-        Args:
-            brand: Brand name
-            system_config: System configuration dict
-        """
-        self.brand = brand
-        self.system_config = system_config
-
-    def run_single_experiment(
-        self,
-        config: dict,
-        sampled_users_df: pd.DataFrame,
-        experiment_id: str,
-        create_session_func,
-        progress_container=None
-    ) -> Tuple[bool, pd.DataFrame, list]:
-        """
-        Run a single experiment across all stages.
-        Accumulates results in ui_log_data dataframe.
-
-        Args:
-            config: Campaign configuration
-            sampled_users_df: Sampled users dataframe
-            experiment_id: Unique experiment identifier
-            create_session_func: Function to create Snowflake session
-            progress_container: Streamlit container for progress updates
-
-        Returns:
-            tuple: (success, ui_log_data_df, metadata_list)
-        """
-        from ai_messaging_system_v2.Messaging_system.Permes import Permes
-
-        # Determine if we're in threaded mode (no UI updates)
-        threaded_mode = progress_container is None
-
-        if not threaded_mode:
-            # Use the provided container for UI updates
-            container = progress_container
-            container.markdown(f"### 📊 Experiment Progress")
-        else:
-            # Threaded mode - no UI updates, just print to console
-            print(f"Starting experiment: {experiment_id}")
-
-        permes = Permes()
-
-        # Get campaign-level configurations
-        campaign_name = config.get("campaign_name", "UI-Campaign")
-        campaign_instructions = config.get("campaign_instructions", None)
-        num_stages = len([k for k in config.keys() if k.isdigit()])
-
-        # Initialize accumulation variables
-        ui_log_data = None  # Will accumulate dataframes from all stages
-        metadata_list = []
-        generation_successful = True
-
-        for stage in range(1, num_stages + 1):
-            if not threaded_mode:
-                container.markdown(f"#### Stage {stage} of {num_stages}")
-                progress_bar = container.progress(0)
-                status_text = container.empty()
-                status_text.text(f"Generating messages for stage {stage}...")
-            else:
-                print(f"  Stage {stage} of {num_stages} - Starting...")
-                # Create dummy objects that do nothing
-                class DummyProgress:
-                    def progress(self, val): pass
-                class DummyStatus:
-                    def text(self, msg): print(f"    {msg}")
-                    def success(self, msg): print(f"    ✅ {msg}")
-                    def warning(self, msg): print(f"    ⚠️ {msg}")
-                    def error(self, msg): print(f"    ❌ {msg}")
-
-                progress_bar = DummyProgress()
-                status_text = DummyStatus()
-
-            session = None
-            try:
-                session = create_session_func()
-                progress_bar.progress(10)
-
-                # Get stage configuration
-                stage_config = config.get(str(stage), {})
-
-                if not stage_config:
-                    status_text.error(f"❌ Stage {stage}: Configuration not found")
-                    generation_successful = False
-                    if session:
-                        session.close()
-                    continue
-
-                # Extract stage parameters
-                model = stage_config.get("model", "gemini-2.5-flash-lite")
-                segment_info = stage_config.get("segment_info", "")
-                recsys_contents = stage_config.get("recsys_contents", [])
-                involve_recsys_result = stage_config.get("involve_recsys_result", True)
-                personalization = stage_config.get("personalization", True)
-                sample_example = stage_config.get("sample_examples", "")
-                per_message_instructions = stage_config.get("instructions", None)
-                specific_content_id = stage_config.get("specific_content_id", None)
-
-                progress_bar.progress(20)
-
-                # Call Permes to generate messages
-                # For stage > 1, pass accumulated ui_log_data
-                users_message = permes.create_personalize_messages(
-                    session=session,
-                    model=model,
-                    users=sampled_users_df.copy(),
-                    brand=self.brand,
-                    config_file=self.system_config,
-                    segment_info=segment_info,
-                    involve_recsys_result=involve_recsys_result,
-                    identifier_column="user_id",
-                    recsys_contents=recsys_contents,
-                    sample_example=sample_example,
-                    campaign_name=campaign_name,
-                    personalization=personalization,
-                    stage=stage,
-                    test_mode=False,
-                    mode="ui",
-                    campaign_instructions=campaign_instructions,
-                    per_message_instructions=per_message_instructions,
-                    specific_content_id=specific_content_id,
-                    ui_experiment_id=experiment_id,
-                    ui_log_data=ui_log_data  # Pass accumulated data for stage > 1
-                )
-
-                progress_bar.progress(100)
-
-                if users_message is not None and len(users_message) > 0:
-                    # Accumulate results
-                    if ui_log_data is None:
-                        ui_log_data = users_message.copy()
-                    else:
-                        # Append new stage to accumulated data
-                        ui_log_data = pd.concat([ui_log_data, users_message], ignore_index=True)
-
-                    # Track metadata for this stage
-                    metadata = {
-                        "experiment_id": experiment_id,
-                        "config_name": config.get("campaign_name", "Unknown"),
-                        "brand": self.brand,
-                        "campaign_name": campaign_name,
-                        "stage": stage,
-                        "llm_model": model,
-                        "total_messages": len(users_message),
-                        "total_users": sampled_users_df['user_id'].nunique() if 'user_id' in sampled_users_df.columns else len(sampled_users_df),
-                        "platform": stage_config.get("platform", "push"),
-                        "personalization": personalization,
-                        "involve_recsys": involve_recsys_result,
-                        "recsys_contents": recsys_contents,
-                        "segment_info": segment_info,
-                        "campaign_instructions": campaign_instructions,
-                        "per_message_instructions": per_message_instructions,
-                        "timestamp": datetime.now()
-                    }
-                    metadata_list.append(metadata)
-
-                    status_text.success(
-                        f"✅ Stage {stage}: Generated {len(users_message)} messages"
-                    )
-                else:
-                    status_text.warning(f"⚠️ Stage {stage}: No messages generated")
-                    generation_successful = False
-
-            except Exception as e:
-                progress_bar.progress(0)
-                import traceback
-                error_details = traceback.format_exc()
-                status_text.error(f"❌ Stage {stage}: Error - {str(e)}")
-                if not threaded_mode:
-                    st.error(f"**Detailed Error Information:**\n```\n{error_details}\n```")
-                else:
-                    print(f"Error details: {error_details}")
-                generation_successful = False
-
-            finally:
-                if session:
-                    try:
-                        session.close()
-                    except:
-                        pass
-
-        return generation_successful, ui_log_data, metadata_list
-
-    def run_ab_test_parallel(
-        self,
-        config_a: dict,
-        config_b: dict,
-        sampled_users_df: pd.DataFrame,
-        experiment_a_id: str,
-        experiment_b_id: str,
-        create_session_func
-    ) -> Dict:
-        """
-        Run two experiments (A and B) in parallel threads.
-        Returns results for both experiments.
-
-        Args:
-            config_a: Configuration for experiment A
-            config_b: Configuration for experiment B
-            sampled_users_df: Sampled users (same for both)
-            experiment_a_id: Experiment A ID
-            experiment_b_id: Experiment B ID
-            create_session_func: Function to create Snowflake session
-
-        Returns:
-            dict: {
-                'a': {'success': bool, 'ui_log_data': df, 'metadata': list, 'error': str},
-                'b': {...}
-            }
-        """
-        import threading
-
-        results = {
-            'a': {'success': False, 'ui_log_data': None, 'metadata': [], 'error': None},
-            'b': {'success': False, 'ui_log_data': None, 'metadata': [], 'error': None}
-        }
-
-        def run_experiment(exp_key: str, config: dict, exp_id: str):
-            """Run single experiment in thread."""
-            try:
-                success, ui_log_data, metadata = self.run_single_experiment(
-                    config=config,
-                    sampled_users_df=sampled_users_df,
-                    experiment_id=exp_id,
-                    create_session_func=create_session_func,
-                    progress_container=None  # No UI updates from thread
-                )
-
-                results[exp_key]['success'] = success
-                results[exp_key]['ui_log_data'] = ui_log_data
-                results[exp_key]['metadata'] = metadata
-
-            except Exception as e:
-                import traceback
-                error_trace = traceback.format_exc()
-                results[exp_key]['error'] = f"{str(e)}\n\nTraceback:\n{error_trace}"
-                results[exp_key]['success'] = False
-                print(f"Error in experiment {exp_key}: {error_trace}")
-
-        # Create threads
-        thread_a = threading.Thread(target=run_experiment, args=('a', config_a, experiment_a_id))
-        thread_b = threading.Thread(target=run_experiment, args=('b', config_b, experiment_b_id))
-
-        # Start both threads
-        thread_a.start()
-        thread_b.start()
-
-        # Wait for both to complete
-        thread_a.join()
-        thread_b.join()
-
-        return results

visualization/utils/feedback_manager.py

@@ -1,414 +0,0 @@
-"""
-Feedback management module for the AI Messaging System Visualization Tool.
-
-Handles storage and retrieval of user feedback on generated messages.
-"""
-
-import pandas as pd
-from pathlib import Path
-from datetime import datetime
-from typing import Optional, List, Dict
-import streamlit as st
-
-
-# Rejection reason categories
-REJECTION_REASONS = {
-    "poor_header": "Poor Header",
-    "poor_body": "Poor Body/Content",
-    "grammar_issues": "Grammar Issues",
-    "emoji_problems": "Emoji Problems",
-    "recommendation_issues": "Recommendation Issues",
-    "wrong_information": "Wrong/Inaccurate Information",
-    "tone_issues": "Tone Issues",
-    "similarity": "Similar To Previous Header/Messages",
-    "other": "Other"
-}
-
-
-class FeedbackManager:
-    """
-    Manages feedback storage and retrieval for generated messages.
-    """
-
-    def __init__(self):
-        """Initialize FeedbackManager."""
-        self.base_path = Path(__file__).parent.parent
-        self.feedback_path = self.base_path / "data" / "feedback"
-
-        # Create directory if it doesn't exist
-        self.feedback_path.mkdir(parents=True, exist_ok=True)
-
-    def get_feedback_file_path(self, experiment_id: str) -> Path:
-        """
-        Get path to feedback file for an experiment.
-
-        Args:
-            experiment_id: Experiment ID
-
-        Returns:
-            Path: Feedback file path
-        """
-        return self.feedback_path / f"{experiment_id}_feedback.csv"
-
-    def save_feedback(
-        self,
-        experiment_id: str,
-        user_id: int,
-        stage: int,
-        feedback_type: str,
-        rejection_reason: Optional[str] = None,
-        rejection_text: Optional[str] = None,
-        campaign_name: Optional[str] = None,
-        message_header: Optional[str] = None,
-        message_body: Optional[str] = None
-    ) -> bool:
-        """
-        Save feedback for a message.
-
-        Args:
-            experiment_id: Experiment ID
-            user_id: User ID
-            stage: Stage number
-            feedback_type: 'reject' (we focus on rejects)
-            rejection_reason: Category of rejection (optional)
-            rejection_text: Additional text for rejection (optional)
-            campaign_name: Campaign name (optional)
-            message_header: Message header text (optional)
-            message_body: Message body text (optional)
-
-        Returns:
-            bool: True if saved successfully, False otherwise
-        """
-        try:
-            feedback_file = self.get_feedback_file_path(experiment_id)
-
-            # Create feedback record
-            feedback_record = {
-                "experiment_id": experiment_id,
-                "user_id": user_id,
-                "stage": stage,
-                "feedback_type": feedback_type,
-                "rejection_reason": rejection_reason,
-                "rejection_text": rejection_text,
-                "campaign_name": campaign_name,
-                "message_header": message_header,
-                "message_body": message_body,
-                "timestamp": datetime.now().isoformat()
-            }
-
-            # Convert to DataFrame
-            new_feedback = pd.DataFrame([feedback_record])
-
-            # Append to existing file or create new
-            if feedback_file.exists():
-                existing_feedback = pd.read_csv(feedback_file, encoding='utf-8-sig')
-
-                # Check if this exact feedback already exists
-                duplicate = existing_feedback[
-                    (existing_feedback['user_id'] == user_id) &
-                    (existing_feedback['stage'] == stage) &
-                    (existing_feedback['experiment_id'] == experiment_id)
-                ]
-
-                if len(duplicate) > 0:
-                    # Update existing feedback
-                    existing_feedback.loc[
-                        (existing_feedback['user_id'] == user_id) &
-                        (existing_feedback['stage'] == stage) &
-                        (existing_feedback['experiment_id'] == experiment_id),
-                        ['feedback_type', 'rejection_reason', 'rejection_text', 'message_header', 'message_body', 'timestamp']
-                    ] = [feedback_type, rejection_reason, rejection_text, message_header, message_body, datetime.now().isoformat()]
-
-                    updated_feedback = existing_feedback
-                else:
-                    # Append new feedback
-                    updated_feedback = pd.concat([existing_feedback, new_feedback], ignore_index=True)
-            else:
-                updated_feedback = new_feedback
-
-            # Save to CSV
-            updated_feedback.to_csv(feedback_file, index=False, encoding='utf-8-sig')
-            return True
-
-        except Exception as e:
-            st.error(f"Error saving feedback: {e}")
-            return False
-
-    def load_feedback(self, experiment_id: str) -> Optional[pd.DataFrame]:
-        """
-        Load feedback for an experiment.
-
-        Args:
-            experiment_id: Experiment ID
-
-        Returns:
-            pd.DataFrame or None: Feedback DataFrame or None if not found
-        """
-        try:
-            feedback_file = self.get_feedback_file_path(experiment_id)
-
-            if not feedback_file.exists():
-                return pd.DataFrame(columns=[
-                    'experiment_id', 'user_id', 'stage', 'feedback_type',
-                    'rejection_reason', 'rejection_text', 'campaign_name',
-                    'message_header', 'message_body', 'timestamp'
-                ])
-
-            return pd.read_csv(feedback_file, encoding='utf-8-sig')
-
-        except Exception as e:
-            st.error(f"Error loading feedback: {e}")
-            return None
-
-    def get_feedback_for_message(
-        self,
-        experiment_id: str,
-        user_id: int,
-        stage: int
-    ) -> Optional[Dict]:
-        """
-        Get feedback for a specific message.
-
-        Args:
-            experiment_id: Experiment ID
-            user_id: User ID
-            stage: Stage number
-
-        Returns:
-            dict or None: Feedback record or None if not found
-        """
-        feedback_df = self.load_feedback(experiment_id)
-
-        if feedback_df is None or len(feedback_df) == 0:
-            return None
-
-        # Filter for specific message
-        message_feedback = feedback_df[
-            (feedback_df['user_id'] == user_id) &
-            (feedback_df['stage'] == stage) &
-            (feedback_df['experiment_id'] == experiment_id)
-        ]
-
-        if len(message_feedback) > 0:
-            return message_feedback.iloc[0].to_dict()
-
-        return None
-
-    def delete_feedback(
-        self,
-        experiment_id: str,
-        user_id: int,
-        stage: int
-    ) -> bool:
-        """
-        Delete feedback for a specific message.
-
-        Args:
-            experiment_id: Experiment ID
-            user_id: User ID
-            stage: Stage number
-
-        Returns:
-            bool: True if deleted successfully, False otherwise
-        """
-        try:
-            feedback_df = self.load_feedback(experiment_id)
-
-            if feedback_df is None or len(feedback_df) == 0:
-                return False
-
-            # Remove the feedback
-            updated_feedback = feedback_df[
-                ~((feedback_df['user_id'] == user_id) &
-                  (feedback_df['stage'] == stage) &
-                  (feedback_df['experiment_id'] == experiment_id))
-            ]
-
-            # Save updated feedback
-            feedback_file = self.get_feedback_file_path(experiment_id)
-            updated_feedback.to_csv(feedback_file, index=False, encoding='utf-8-sig')
-
-            return True
-
-        except Exception as e:
-            st.error(f"Error deleting feedback: {e}")
-            return False
-
-    def get_feedback_stats(self, experiment_id: str, total_messages: int = None) -> Dict:
-        """
-        Get feedback statistics for an experiment.
-
-        Args:
-            experiment_id: Experiment ID
-            total_messages: Total number of messages generated (optional, for accurate rejection rate)
-
-        Returns:
-            dict: Feedback statistics
-        """
-        feedback_df = self.load_feedback(experiment_id)
-
-        if feedback_df is None or len(feedback_df) == 0:
-            return {
-                "total_feedback": 0,
-                "total_rejects": 0,
-                "reject_rate": 0.0,
-                "rejection_reasons": {}
-            }
-
-        total_feedback = len(feedback_df)
-        total_rejects = len(feedback_df[feedback_df['feedback_type'] == 'reject'])
-
-        # Count rejection reasons
-        rejection_reasons = {}
-        if total_rejects > 0:
-            reason_counts = feedback_df[
-                feedback_df['feedback_type'] == 'reject'
-            ]['rejection_reason'].value_counts().to_dict()
-
-            rejection_reasons = {
-                REJECTION_REASONS.get(k, k): v
-                for k, v in reason_counts.items()
-                if k is not None and pd.notna(k)
-            }
-
-        # Calculate rejection rate based on total messages (not total feedback)
-        # Since users only provide feedback for rejected messages
-        if total_messages is not None and total_messages > 0:
-            reject_rate = (total_rejects / total_messages * 100)
-        else:
-            # Fallback to old calculation if total_messages not provided
-            reject_rate = (total_rejects / total_feedback * 100) if total_feedback > 0 else 0.0
-
-        stats = {
-            "total_feedback": total_feedback,
-            "total_rejects": total_rejects,
-            "reject_rate": reject_rate,
-            "rejection_reasons": rejection_reasons
-        }
-
-        return stats
-
-    def get_stage_feedback_stats(self, experiment_id: str, messages_df: pd.DataFrame = None) -> pd.DataFrame:
-        """
-        Get feedback statistics by stage.
-
-        Args:
-            experiment_id: Experiment ID
-            messages_df: DataFrame of all messages (optional, for accurate rejection rate per stage)
-
-        Returns:
-            pd.DataFrame: Stage-wise feedback statistics
-        """
-        feedback_df = self.load_feedback(experiment_id)
-
-        if feedback_df is None or len(feedback_df) == 0:
-            return pd.DataFrame(columns=['stage', 'total_messages', 'total_feedback', 'rejects', 'reject_rate'])
-
-        # Get total messages per stage from messages_df if provided
-        stage_message_counts = {}
-        if messages_df is not None and 'stage' in messages_df.columns:
-            stage_message_counts = messages_df.groupby('stage').size().to_dict()
-
-        # Group by stage
-        stage_stats = []
-        for stage in sorted(feedback_df['stage'].unique()):
-            stage_feedback = feedback_df[feedback_df['stage'] == stage]
-            total_feedback = len(stage_feedback)
-            rejects = len(stage_feedback[stage_feedback['feedback_type'] == 'reject'])
-
-            # Calculate rejection rate based on total messages for this stage
-            total_messages_for_stage = stage_message_counts.get(stage, total_feedback)
-            reject_rate = (rejects / total_messages_for_stage * 100) if total_messages_for_stage > 0 else 0.0
-
-            stage_stats.append({
-                'stage': stage,
-                'total_messages': total_messages_for_stage,
-                'total_feedback': total_feedback,
-                'rejects': rejects,
-                'reject_rate': reject_rate
-            })
-
-        return pd.DataFrame(stage_stats)
-
-    def compare_experiments(
-        self,
-        experiment_id_a: str,
-        experiment_id_b: str,
-        total_messages_a: int = None,
-        total_messages_b: int = None
-    ) -> Dict:
-        """
-        Compare feedback statistics between two experiments.
-
-        Args:
-            experiment_id_a: First experiment ID
-            experiment_id_b: Second experiment ID
-            total_messages_a: Total messages in experiment A (optional, for accurate rejection rate)
-            total_messages_b: Total messages in experiment B (optional, for accurate rejection rate)
-
-        Returns:
-            dict: Comparison statistics
-        """
-        stats_a = self.get_feedback_stats(experiment_id_a, total_messages=total_messages_a)
-        stats_b = self.get_feedback_stats(experiment_id_b, total_messages=total_messages_b)
-
-        comparison = {
-            "experiment_a": {
-                "id": experiment_id_a,
-                "stats": stats_a
-            },
-            "experiment_b": {
-                "id": experiment_id_b,
-                "stats": stats_b
-            },
-            "difference": {
-                "reject_rate": stats_a['reject_rate'] - stats_b['reject_rate']
-            }
-        }
-
-        return comparison
-
-    def export_feedback(self, experiment_id: str, export_path: Path) -> bool:
-        """
-        Export feedback to CSV file.
-
-        Args:
-            experiment_id: Experiment ID
-            export_path: Export file path
-
-        Returns:
-            bool: True if exported successfully, False otherwise
-        """
-        try:
-            feedback_df = self.load_feedback(experiment_id)
-
-            if feedback_df is None:
-                return False
-
-            feedback_df.to_csv(export_path, index=False, encoding='utf-8-sig')
-            return True
-
-        except Exception as e:
-            st.error(f"Error exporting feedback: {e}")
-            return False
-
-    def get_rejection_reason_label(self, reason_key: str) -> str:
-        """
-        Get human-readable label for rejection reason key.
-
-        Args:
-            reason_key: Rejection reason key
-
-        Returns:
-            str: Human-readable label
-        """
-        return REJECTION_REASONS.get(reason_key, reason_key)
-
-    def get_all_rejection_reasons(self) -> Dict[str, str]:
-        """
-        Get all available rejection reasons.
-
-        Returns:
-            dict: Dictionary mapping keys to labels
-        """
-        return REJECTION_REASONS.copy()

visualization/utils/session_feedback_manager.py

@@ -1,310 +0,0 @@
-"""
-Session-based Feedback Manager
-
-Manages feedback in streamlit session_state instead of local files.
-Works with the new in-memory architecture.
-"""
-
-import pandas as pd
-from datetime import datetime
-from typing import Optional, List, Dict
-import streamlit as st
-
-
-# Rejection reason categories
-REJECTION_REASONS = {
-    "poor_header": "Poor Header",
-    "poor_body": "Poor Body/Content",
-    "grammar_issues": "Grammar Issues",
-    "emoji_problems": "Emoji Problems",
-    "recommendation_issues": "Recommendation Issues",
-    "wrong_information": "Wrong/Inaccurate Information",
-    "tone_issues": "Tone Issues",
-    "similarity": "Similar To Previous Header/Messages",
-    "other": "Other"
-}
-
-
-class SessionFeedbackManager:
-    """
-    Manages feedback in streamlit session_state for in-memory operations.
-    """
-
-    @staticmethod
-    def add_feedback(
-        experiment_id: str,
-        user_id: int,
-        stage: int,
-        feedback_type: str,
-        rejection_reason: Optional[str] = None,
-        rejection_text: Optional[str] = None,
-        campaign_name: Optional[str] = None,
-        config_name: Optional[str] = None,
-        brand: Optional[str] = None,
-        message_header: Optional[str] = None,
-        message_body: Optional[str] = None,
-        feedback_list_key: str = "current_feedbacks"
-    ) -> bool:
-        """
-        Add feedback to session_state list.
-
-        Args:
-            experiment_id: Experiment ID
-            user_id: User ID
-            stage: Stage number
-            feedback_type: 'reject' or other
-            rejection_reason: Category of rejection (optional)
-            rejection_text: Additional text for rejection (optional)
-            campaign_name: Campaign name (optional)
-            config_name: Config name (optional)
-            brand: Brand name (optional)
-            message_header: Message header text (optional)
-            message_body: Message body text (optional)
-            feedback_list_key: Key in session_state for feedback list (default: "current_feedbacks")
-
-        Returns:
-            bool: True if added successfully
-        """
-        try:
-            # Create feedback record
-            feedback_record = {
-                "experiment_id": experiment_id,
-                "user_id": user_id,
-                "stage": stage,
-                "feedback_type": feedback_type,
-                "rejection_reason": rejection_reason,
-                "rejection_text": rejection_text,
-                "campaign_name": campaign_name,
-                "config_name": config_name,
-                "brand": brand,
-                "message_header": message_header,
-                "message_body": message_body,
-                "timestamp": datetime.now()
-            }
-
-            # Initialize feedback list if not exists
-            if feedback_list_key not in st.session_state:
-                st.session_state[feedback_list_key] = []
-
-            # Check if feedback already exists for this (experiment_id, user_id, stage)
-            existing_idx = None
-            for idx, fb in enumerate(st.session_state[feedback_list_key]):
-                if (fb['experiment_id'] == experiment_id and
-                    fb['user_id'] == user_id and
-                    fb['stage'] == stage):
-                    existing_idx = idx
-                    break
-
-            if existing_idx is not None:
-                # Update existing feedback
-                st.session_state[feedback_list_key][existing_idx] = feedback_record
-            else:
-                # Add new feedback
-                st.session_state[feedback_list_key].append(feedback_record)
-
-            return True
-
-        except Exception as e:
-            st.error(f"Error adding feedback: {e}")
-            return False
-
-    @staticmethod
-    def get_feedback(
-        experiment_id: str,
-        user_id: int,
-        stage: int,
-        feedback_list_key: str = "current_feedbacks"
-    ) -> Optional[Dict]:
-        """
-        Get feedback for a specific message from session_state.
-
-        Args:
-            experiment_id: Experiment ID
-            user_id: User ID
-            stage: Stage number
-            feedback_list_key: Key in session_state for feedback list
-
-        Returns:
-            dict or None: Feedback record or None if not found
-        """
-        if feedback_list_key not in st.session_state:
-            return None
-
-        for fb in st.session_state[feedback_list_key]:
-            if (fb['experiment_id'] == experiment_id and
-                fb['user_id'] == user_id and
-                fb['stage'] == stage):
-                return fb
-
-        return None
-
-    @staticmethod
-    def delete_feedback(
-        experiment_id: str,
-        user_id: int,
-        stage: int,
-        feedback_list_key: str = "current_feedbacks"
-    ) -> bool:
-        """
-        Delete feedback for a specific message from session_state.
-
-        Args:
-            experiment_id: Experiment ID
-            user_id: User ID
-            stage: Stage number
-            feedback_list_key: Key in session_state for feedback list
-
-        Returns:
-            bool: True if deleted successfully
-        """
-        try:
-            if feedback_list_key not in st.session_state:
-                return False
-
-            # Find and remove feedback
-            st.session_state[feedback_list_key] = [
-                fb for fb in st.session_state[feedback_list_key]
-                if not (fb['experiment_id'] == experiment_id and
-                       fb['user_id'] == user_id and
-                       fb['stage'] == stage)
-            ]
-
-            return True
-
-        except Exception as e:
-            st.error(f"Error deleting feedback: {e}")
-            return False
-
-    @staticmethod
-    def get_feedback_stats(
-        experiment_id: str,
-        total_messages: int,
-        feedback_list_key: str = "current_feedbacks"
-    ) -> Dict:
-        """
-        Get feedback statistics for an experiment from session_state.
-
-        Args:
-            experiment_id: Experiment ID
-            total_messages: Total number of messages generated
-            feedback_list_key: Key in session_state for feedback list
-
-        Returns:
-            dict: Feedback statistics
-        """
-        if feedback_list_key not in st.session_state:
-            return {
-                "total_feedback": 0,
-                "total_rejects": 0,
-                "reject_rate": 0.0,
-                "rejection_reasons": {}
-            }
-
-        # Filter feedback for this experiment
-        experiment_feedback = [
-            fb for fb in st.session_state[feedback_list_key]
-            if fb['experiment_id'] == experiment_id
-        ]
-
-        total_feedback = len(experiment_feedback)
-        total_rejects = len([fb for fb in experiment_feedback if fb['feedback_type'] == 'reject'])
-
-        # Count rejection reasons
-        rejection_reasons = {}
-        for fb in experiment_feedback:
-            if fb['feedback_type'] == 'reject' and fb['rejection_reason']:
-                reason_label = REJECTION_REASONS.get(fb['rejection_reason'], fb['rejection_reason'])
-                rejection_reasons[reason_label] = rejection_reasons.get(reason_label, 0) + 1
-
-        # Calculate rejection rate based on total messages
-        reject_rate = (total_rejects / total_messages * 100) if total_messages > 0 else 0.0
-
-        return {
-            "total_feedback": total_feedback,
-            "total_rejects": total_rejects,
-            "reject_rate": reject_rate,
-            "rejection_reasons": rejection_reasons
-        }
-
-    @staticmethod
-    def get_stage_feedback_stats(
-        experiment_id: str,
-        messages_df: pd.DataFrame,
-        feedback_list_key: str = "current_feedbacks"
-    ) -> pd.DataFrame:
-        """
-        Get feedback statistics by stage from session_state.
-
-        Args:
-            experiment_id: Experiment ID
-            messages_df: DataFrame of all messages
-            feedback_list_key: Key in session_state for feedback list
-
-        Returns:
-            pd.DataFrame: Stage-wise feedback statistics
-        """
-        if feedback_list_key not in st.session_state or 'stage' not in messages_df.columns:
-            return pd.DataFrame(columns=['stage', 'total_messages', 'total_feedback', 'rejects', 'reject_rate'])
-
-        # Filter feedback for this experiment
-        experiment_feedback = [
-            fb for fb in st.session_state[feedback_list_key]
-            if fb['experiment_id'] == experiment_id
-        ]
-
-        # Get total messages per stage
-        stage_message_counts = messages_df.groupby('stage').size().to_dict()
-
-        # Group feedback by stage
-        stage_stats = []
-        for stage in sorted(messages_df['stage'].unique()):
-            stage_feedback = [fb for fb in experiment_feedback if fb['stage'] == stage]
-            total_feedback = len(stage_feedback)
-            rejects = len([fb for fb in stage_feedback if fb['feedback_type'] == 'reject'])
-
-            total_messages_for_stage = stage_message_counts.get(stage, 0)
-            reject_rate = (rejects / total_messages_for_stage * 100) if total_messages_for_stage > 0 else 0.0
-
-            stage_stats.append({
-                'stage': stage,
-                'total_messages': total_messages_for_stage,
-                'total_feedback': total_feedback,
-                'rejects': rejects,
-                'reject_rate': reject_rate
-            })
-
-        return pd.DataFrame(stage_stats)
-
-    @staticmethod
-    def get_all_rejection_reasons() -> Dict[str, str]:
-        """
-        Get all available rejection reasons.
-
-        Returns:
-            dict: Dictionary mapping keys to labels
-        """
-        return REJECTION_REASONS.copy()
-
-    @staticmethod
-    def get_rejection_reason_label(reason_key: str) -> str:
-        """
-        Get human-readable label for rejection reason key.
-
-        Args:
-            reason_key: Rejection reason key
-
-        Returns:
-            str: Human-readable label
-        """
-        return REJECTION_REASONS.get(reason_key, reason_key)
-
-    @staticmethod
-    def clear_all_feedbacks(feedback_list_key: str = "current_feedbacks"):
-        """
-        Clear all feedbacks from session_state.
-
-        Args:
-            feedback_list_key: Key in session_state for feedback list
-        """
-        if feedback_list_key in st.session_state:
-            st.session_state[feedback_list_key] = []

visualization/utils/theme.py

@@ -1,335 +0,0 @@
-"""
-Brand-specific theming module for the AI Messaging System Visualization Tool.
-
-Provides dynamic color schemes and styling based on selected brand.
-"""
-
-import streamlit as st
-from typing import Dict, Tuple
-
-# Brand color definitions (primary, secondary, accent)
-BRAND_COLORS = {
-    "base": {
-        "primary": "#B8860B",      # Dark Goldenrod
-        "secondary": "#2C2C2C",    # Dark gray
-        "accent": "#1A1A1A",       # Black
-        "text": "#FFFFFF",         # White
-        "background": "#0D0D0D",   # Very dark
-        "sidebar_bg": "#7A5C00"    # Darker gold for sidebar
-    },
-    "drumeo": {
-        "primary": "#5DADE2",      # Light blue
-        "secondary": "#B8860B",    # Dark Goldenrod
-        "accent": "#2874A6",       # Darker blue
-        "text": "#FFFFFF",         # White
-        "background": "#1C2833",   # Dark blue-gray
-        "sidebar_bg": "#1A4D6B"    # Darker blue for sidebar
-    },
-    "pianote": {
-        "primary": "#EC7063",      # Light red
-        "secondary": "#B8860B",    # Dark Goldenrod
-        "accent": "#C0392B",       # Darker red
-        "text": "#FFFFFF",         # White
-        "background": "#1C1C1C",   # Dark
-        "sidebar_bg": "#8B2500"    # Darker red for sidebar
-    },
-    "guitareo": {
-        "primary": "#58D68D",      # Light green
-        "secondary": "#B8860B",    # Dark Goldenrod
-        "accent": "#229954",       # Darker green
-        "text": "#FFFFFF",         # White
-        "background": "#1C2E1F",   # Dark green-gray
-        "sidebar_bg": "#1B5E20"    # Darker green for sidebar
-    },
-    "singeo": {
-        "primary": "#BB8FCE",      # Light purple
-        "secondary": "#B8860B",    # Dark Goldenrod
-        "accent": "#7D3C98",       # Darker purple
-        "text": "#FFFFFF",         # White
-        "background": "#1F1926",   # Dark purple-gray
-        "sidebar_bg": "#4A148C"    # Darker purple for sidebar
-    }
-}
-
-# Brand emojis
-BRAND_EMOJIS = {
-    "drumeo": "🥁",
-    "pianote": "🎹",
-    "guitareo": "🎸",
-    "singeo": "🎤"
-}
-
-
-def get_brand_theme(brand: str) -> Dict[str, str]:
-    """
-    Get color theme for specified brand.
-
-    Args:
-        brand: Brand name (drumeo, pianote, guitareo, singeo)
-
-    Returns:
-        dict: Color theme dictionary
-    """
-    brand_lower = brand.lower() if brand else "base"
-    return BRAND_COLORS.get(brand_lower, BRAND_COLORS["base"])
-
-
-def get_brand_emoji(brand: str) -> str:
-    """
-    Get emoji for specified brand.
-
-    Args:
-        brand: Brand name
-
-    Returns:
-        str: Brand emoji
-    """
-    brand_lower = brand.lower() if brand else ""
-    return BRAND_EMOJIS.get(brand_lower, "🎵")
-
-
-def apply_theme(brand: str = None):
-    """
-    Apply brand-specific theme to Streamlit app.
-
-    Args:
-        brand: Brand name (optional, uses session state if not provided)
-    """
-    if brand is None:
-        brand = st.session_state.get("selected_brand", "base")
-
-    theme = get_brand_theme(brand)
-
-    # Custom CSS for brand theming
-    css = f"""
-    <style>
-    /* Global styles */
-    .stApp {{
-        background-color: {theme['background']};
-    }}
-
-    /* Text colors */
-    h1, h2, h3, h4, h5, h6 {{
-        color: {theme['primary']} !important;
-    }}
-
-    p, span, div {{
-        color: {theme['text']} !important;
-    }}
-
-    /* Button styles */
-    .stButton > button {{
-        background-color: {theme['primary']};
-        color: {theme['background']};
-        border: none;
-        border-radius: 8px;
-        padding: 0.5rem 1rem;
-        font-weight: 600;
-        transition: all 0.3s ease;
-    }}
-
-    .stButton > button:hover {{
-        background-color: {theme['secondary']};
-        transform: translateY(-2px);
-        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
-    }}
-
-    /* Download button */
-    .stDownloadButton > button {{
-        background-color: {theme['accent']};
-        color: {theme['text']};
-        border-radius: 8px;
-        font-weight: 600;
-    }}
-
-    /* Input fields */
-    .stTextInput > div > div > input,
-    .stTextArea > div > div > textarea,
-    .stNumberInput > div > div > input {{
-        background-color: {theme['secondary']};
-        color: {theme['text']};
-        border: 1px solid {theme['primary']};
-        border-radius: 5px;
-    }}
-
-    /* Select boxes */
-    .stSelectbox > div > div {{
-        background-color: {theme['secondary']};
-        color: {theme['text']};
-        border-radius: 5px;
-    }}
-
-    /* Multiselect */
-    .stMultiSelect > div > div {{
-        background-color: {theme['secondary']};
-        border-radius: 5px;
-    }}
-
-    /* Tabs */
-    .stTabs [data-baseweb="tab-list"] {{
-        gap: 8px;
-    }}
-
-    .stTabs [data-baseweb="tab"] {{
-        background-color: {theme['secondary']};
-        color: {theme['text']};
-        border-radius: 5px 5px 0 0;
-        padding: 10px 20px;
-        font-weight: 600;
-    }}
-
-    .stTabs [aria-selected="true"] {{
-        background-color: {theme['primary']};
-        color: {theme['background']};
-    }}
-
-    /* Progress bar */
-    .stProgress > div > div > div {{
-        background-color: {theme['primary']};
-    }}
-
-    /* Expanders */
-    .streamlit-expanderHeader {{
-        background-color: {theme['secondary']};
-        color: {theme['primary']};
-        border-radius: 5px;
-        font-weight: 600;
-    }}
-
-    /* Cards/Containers */
-    .element-container {{
-        background-color: transparent;
-    }}
-
-    /* Sidebar */
-    [data-testid="stSidebar"] {{
-        background-color: {theme['sidebar_bg']};
-    }}
-
-    [data-testid="stSidebar"] h1,
-    [data-testid="stSidebar"] h2,
-    [data-testid="stSidebar"] h3 {{
-        color: {theme['text']} !important;
-    }}
-
-    [data-testid="stSidebar"] p,
-    [data-testid="stSidebar"] span,
-    [data-testid="stSidebar"] div,
-    [data-testid="stSidebar"] label {{
-        color: {theme['text']} !important;
-    }}
-
-    /* Metrics */
-    [data-testid="stMetricValue"] {{
-        color: {theme['primary']} !important;
-        font-size: 2rem;
-        font-weight: bold;
-    }}
-
-    /* Divider */
-    hr {{
-        border-color: {theme['primary']};
-        opacity: 0.3;
-    }}
-
-    /* Checkbox */
-    .stCheckbox {{
-        color: {theme['text']};
-    }}
-
-    /* Radio */
-    .stRadio > div {{
-        color: {theme['text']};
-    }}
-
-    /* Success/Info/Warning/Error boxes */
-    .stSuccess {{
-        background-color: rgba(88, 214, 141, 0.1);
-        color: {theme['text']};
-    }}
-
-    .stInfo {{
-        background-color: rgba(93, 173, 226, 0.1);
-        color: {theme['text']};
-    }}
-
-    .stWarning {{
-        background-color: rgba(184, 134, 11, 0.1);
-        color: {theme['text']};
-    }}
-
-    .stError {{
-        background-color: rgba(236, 112, 99, 0.1);
-        color: {theme['text']};
-    }}
-
-    /* DataFrames */
-    .dataframe {{
-        border: 1px solid {theme['primary']};
-    }}
-
-    /* Custom card styling */
-    .message-card {{
-        background-color: {theme['secondary']};
-        border-left: 4px solid {theme['primary']};
-        border-radius: 8px;
-        padding: 1rem;
-        margin: 0.5rem 0;
-        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.2);
-    }}
-
-    .message-card:hover {{
-        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
-        transform: translateX(4px);
-        transition: all 0.3s ease;
-    }}
-
-    /* Small text */
-    .small {{
-        font-size: 0.85rem;
-        opacity: 0.7;
-    }}
-
-    /* Badge styles */
-    .badge {{
-        display: inline-block;
-        padding: 0.25rem 0.5rem;
-        border-radius: 12px;
-        font-size: 0.75rem;
-        font-weight: 600;
-        background-color: {theme['accent']};
-        color: {theme['text']};
-    }}
-    </style>
-    """
-
-    st.markdown(css, unsafe_allow_html=True)
-
-
-def create_card(content: str, key: str = None) -> None:
-    """
-    Create a styled card container.
-
-    Args:
-        content: HTML content to display in card
-        key: Optional unique key for the card
-    """
-    st.markdown(
-        f'<div class="message-card">{content}</div>',
-        unsafe_allow_html=True
-    )
-
-
-def create_badge(text: str, color: str = None) -> str:
-    """
-    Create a styled badge element.
-
-    Args:
-        text: Badge text
-        color: Optional custom color
-
-    Returns:
-        str: HTML for badge
-    """
-    style = f'background-color: {color};' if color else ''
-    return f'<span class="badge" style="{style}">{text}</span>'