Updating UI with all changes

README.md

@@ -74,17 +74,6 @@ visualization/
 └── 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

app.py

@@ -1,384 +1,19 @@
 """
-AI Messaging System - Visualization Tool
-Main entry point with authentication and brand selection.
+Hugging Face Spaces wrapper for AI Messaging System Visualization Tool
+This wrapper imports and runs the main app from the visualization folder.
 """
 
-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 the visualization directory to Python path
+visualization_dir = Path(__file__).parent / "visualization"
+sys.path.insert(0, str(visualization_dir))
+sys.path.insert(0, str(Path(__file__).parent))
 
-# 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
+# Change to visualization directory context for relative imports
 import os
+os.chdir(visualization_dir)
 
-# 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**")
+# Import and run the main app
+from visualization import app

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

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

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

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

pages/1_Campaign_Builder.py

@@ -1,1100 +1,27 @@
 """
-Page 1: Campaign Builder
-Configure and run message generation campaigns with A/B testing support.
+Hugging Face Spaces wrapper for Campaign Builder page
+This wrapper imports and runs the page from the visualization folder.
 """
 
-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")
+# Add the project root and visualization directory to Python path
+project_root = Path(__file__).parent.parent
+visualization_dir = project_root / "visualization"
 
-        system_config = get_system_config()
+sys.path.insert(0, str(visualization_dir))
+sys.path.insert(0, str(project_root))
 
-        # Setup Permes for message generation
-        permes = Permes()
-        original_output_file = permes.UI_OUTPUT_FILE
-        ui_experiment_id = None
+# Change to visualization directory for relative imports
+os.chdir(visualization_dir)
 
-        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!")
+# Import the actual page module
+import importlib.util
+spec = importlib.util.spec_from_file_location(
+    "campaign_builder",
+    visualization_dir / "pages" / "1_Campaign_Builder.py"
+)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)

pages/2_Message_Viewer.py

@@ -1,939 +1,27 @@
 """
-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.
+Hugging Face Spaces wrapper for Message Viewer page
+This wrapper imports and runs the page from the visualization folder.
 """
 
-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:
-            # Display thumbnail as clickable image
-            col1, col2 = st.columns([1, 2])
-
-            with col1:
-                st.image(thumbnail_url, use_container_width=True)
-
-            with col2:
-                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']
+# Add the project root and visualization directory to Python path
+project_root = Path(__file__).parent.parent
+visualization_dir = project_root / "visualization"
 
-                # Parse message content
-                message_content = parse_message_content(row.get('message', ''))
+sys.path.insert(0, str(visualization_dir))
+sys.path.insert(0, str(project_root))
 
-                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
+# Change to visualization directory for relative imports
+os.chdir(visualization_dir)
 
-                    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.
-                """)
-
-            st.balloons()
-
-        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
-            )
+# Import the actual page module
+import importlib.util
+spec = importlib.util.spec_from_file_location(
+    "message_viewer",
+    visualization_dir / "pages" / "2_Message_Viewer.py"
+)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)

pages/4_Analytics.py

@@ -1,886 +1,27 @@
 """
-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.
+Hugging Face Spaces wrapper for Analytics page
+This wrapper imports and runs the page from the visualization folder.
 """
 
-import streamlit as st
 import sys
 from pathlib import Path
-import pandas as pd
+import os
 
-# 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**
+# Add the project root and visualization directory to Python path
+project_root = Path(__file__).parent.parent
+visualization_dir = project_root / "visualization"
 
-    Plotly is not installed in the current Python environment.
+sys.path.insert(0, str(visualization_dir))
+sys.path.insert(0, str(project_root))
 
-    **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`
+# Change to visualization directory for relative imports
+os.chdir(visualization_dir)
 
-    **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"
+# Import the actual page module
+import importlib.util
+spec = importlib.util.spec_from_file_location(
+    "analytics",
+    visualization_dir / "pages" / "4_Analytics.py"
 )
-
-# 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("---")
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)

pages/5_Historical_Analytics.py

@@ -1,381 +1,27 @@
 """
-Page 5: Historical Analytics
-View performance metrics and insights from all previous experiments stored in Snowflake.
+Hugging Face Spaces wrapper for Historical Analytics page
+This wrapper imports and runs the page from the visualization folder.
 """
 
-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
-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
-
-# 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"📚 Historical Analytics - {emoji} {brand.title()}")
-st.markdown("**View performance metrics from all previous experiments stored in Snowflake**")
-
-st.markdown("---")
-
-# Load Data Button
-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 experiment summary (joins metadata + feedback)
-                    experiments_df = db_manager.get_experiment_summary(brand=brand)
-
-                    # Store in session_state
-                    st.session_state['historical_experiments'] = experiments_df
-                    st.session_state['historical_data_loaded'] = True
-
-                    # Close session
-                    db_manager.close()
-
-                    st.success(f"✅ Loaded {len(experiments_df)} experiments from Snowflake!")
-                    st.rerun()
-
-                except Exception as e:
-                    st.error(f"Error loading historical data: {e}")
-                    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 experiment data from Snowflake")
-    st.stop()
-
-# Get loaded data
-experiments_df = st.session_state.get('historical_experiments', pd.DataFrame())
-
-if experiments_df is None or len(experiments_df) == 0:
-    st.warning("⚠️ No historical experiments found in Snowflake. Generate and store experiments first using Campaign Builder.")
-    st.stop()
-
-# Sidebar - Filters
-with st.sidebar:
-    st.header("🔍 Filters")
-
-    # Date range filter
-    st.subheader("Date Range")
-    show_all = st.checkbox("Show All Experiments", value=True)
-
-    start_date = None
-    end_date = None
-
-    if not show_all:
-        # Use actual timestamps from data
-        if 'start_time' in experiments_df.columns:
-            experiments_df['start_time'] = pd.to_datetime(experiments_df['start_time'])
-            min_date = experiments_df['start_time'].min().date()
-            max_date = experiments_df['start_time'].max().date()
-
-            start_date = st.date_input("Start Date", min_date)
-            end_date = st.date_input("End Date", max_date)
-
-            # Filter by date range
-            experiments_df = experiments_df[
-                (experiments_df['start_time'].dt.date >= start_date) &
-                (experiments_df['start_time'].dt.date <= end_date)
-            ]
-
-    st.markdown("---")
-
-    # Refresh button
-    if st.button("🔄 Reload Data", use_container_width=True):
-        st.session_state['historical_data_loaded'] = False
-        st.rerun()
-
-# ============================================================================
-# OVERVIEW STATISTICS
-# ============================================================================
-st.header("📊 Overview Statistics")
-
-col1, col2, col3, col4 = st.columns(4)
-
-with col1:
-    st.metric("Total Experiments", len(experiments_df))
-
-with col2:
-    total_messages = experiments_df['total_messages'].sum() if 'total_messages' in experiments_df.columns else 0
-    st.metric("Total Messages", f"{total_messages:,}")
-
-with col3:
-    total_rejects = experiments_df['total_rejects'].sum() if 'total_rejects' in experiments_df.columns else 0
-    st.metric("Total Rejections", f"{total_rejects:,}")
-
-with col4:
-    avg_rejection_rate = experiments_df['rejection_rate'].mean() if 'rejection_rate' in experiments_df.columns else 0
-    st.metric("Avg Rejection Rate", f"{avg_rejection_rate:.1f}%")
-
-st.markdown("---")
-
-# ============================================================================
-# EXPERIMENTS SUMMARY TABLE
-# ============================================================================
-st.header("📈 All Experiments")
-
-# Display summary table
-display_df = experiments_df.copy()
+import os
 
-# Format columns for display
-if 'start_time' in display_df.columns:
-    display_df['start_time'] = pd.to_datetime(display_df['start_time']).dt.strftime('%Y-%m-%d %H:%M')
+# Add the project root and visualization directory to Python path
+project_root = Path(__file__).parent.parent
+visualization_dir = project_root / "visualization"
 
-# Select columns to display
-display_columns = ['campaign_name', 'config_name', 'start_time', 'total_messages',
-                   'total_users', 'total_stages', 'total_rejects', 'rejection_rate']
+sys.path.insert(0, str(visualization_dir))
+sys.path.insert(0, str(project_root))
 
-# Only show columns that exist
-display_columns = [col for col in display_columns if col in display_df.columns]
+# Change to visualization directory for relative imports
+os.chdir(visualization_dir)
 
-st.dataframe(
-    display_df[display_columns],
-    use_container_width=True,
-    hide_index=True,
-    column_config={
-        "campaign_name": "Campaign",
-        "config_name": "Config",
-        "start_time": "Date",
-        "total_messages": "Messages",
-        "total_users": "Users",
-        "total_stages": "Stages",
-        "total_rejects": "Rejects",
-        "rejection_rate": st.column_config.NumberColumn(
-            "Reject Rate (%)",
-            format="%.1f%%"
-        )
-    }
+# Import the actual page module
+import importlib.util
+spec = importlib.util.spec_from_file_location(
+    "historical_analytics",
+    visualization_dir / "pages" / "5_Historical_Analytics.py"
 )
-
-st.markdown("---")
-
-# ============================================================================
-# REJECTION RATE TREND OVER TIME
-# ============================================================================
-st.header("📉 Rejection Rate Trend Over Time")
-
-if 'start_time' in experiments_df.columns and 'rejection_rate' in experiments_df.columns:
-    # Sort by time
-    trend_df = experiments_df.copy()
-    trend_df['start_time'] = pd.to_datetime(trend_df['start_time'])
-    trend_df = trend_df.sort_values('start_time')
-
-    fig = go.Figure()
-
-    fig.add_trace(go.Scatter(
-        x=trend_df['start_time'],
-        y=trend_df['rejection_rate'],
-        mode='lines+markers',
-        name='Rejection Rate',
-        line=dict(color=theme['accent'], width=3),
-        marker=dict(size=10),
-        text=trend_df['campaign_name'],
-        hovertemplate='<b>%{text}</b><br>Date: %{x}<br>Rejection Rate: %{y:.1f}%<extra></extra>'
-    ))
-
-    fig.update_layout(
-        xaxis_title="Experiment Date",
-        yaxis_title="Rejection Rate (%)",
-        template="plotly_dark",
-        paper_bgcolor='rgba(0,0,0,0)',
-        plot_bgcolor='rgba(0,0,0,0)',
-        hovermode='closest'
-    )
-
-    st.plotly_chart(fig, use_container_width=True)
-else:
-    st.info("Not enough data for trend visualization")
-
-st.markdown("---")
-
-# ============================================================================
-# PERFORMANCE COMPARISON
-# ============================================================================
-st.header("📊 Performance Comparison")
-
-if len(experiments_df) > 1 and 'config_name' in experiments_df.columns:
-    # Group by config and compare
-    config_summary = experiments_df.groupby('config_name').agg({
-        'rejection_rate': 'mean',
-        'total_messages': 'sum',
-        'total_rejects': 'sum'
-    }).reset_index()
-
-    config_summary = config_summary.sort_values('rejection_rate')
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        # Bar chart comparing configs
-        fig = px.bar(
-            config_summary,
-            x='config_name',
-            y='rejection_rate',
-            title="Average Rejection Rate by Configuration",
-            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="Configuration",
-            yaxis_title="Rejection Rate (%)"
-        )
-
-        st.plotly_chart(fig, use_container_width=True)
-
-    with col2:
-        # Summary metrics
-        best_config = config_summary.iloc[0]
-        worst_config = config_summary.iloc[-1]
-
-        st.markdown("### 🏆 Best Performing Config")
-        st.metric(
-            best_config['config_name'],
-            f"{best_config['rejection_rate']:.1f}%",
-            delta=f"{worst_config['rejection_rate'] - best_config['rejection_rate']:.1f}% better than worst"
-        )
-
-        st.markdown("### 📊 Config Comparison")
-        st.dataframe(
-            config_summary,
-            use_container_width=True,
-            hide_index=True,
-            column_config={
-                "config_name": "Configuration",
-                "rejection_rate": st.column_config.NumberColumn(
-                    "Avg Rejection Rate (%)",
-                    format="%.1f%%"
-                ),
-                "total_messages": st.column_config.NumberColumn(
-                    "Total Messages",
-                    format="%d"
-                ),
-                "total_rejects": st.column_config.NumberColumn(
-                    "Total Rejects",
-                    format="%d"
-                )
-            }
-        )
-else:
-    st.info("Need at least 2 experiments for performance comparison")
-
-st.markdown("---")
-
-# Export options
-st.header("💾 Export Historical Data")
-
-col1, col2 = st.columns(2)
-
-with col1:
-    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 Summary CSV",
-            data=csv,
-            file_name=f"{brand}_experiments_summary_{datetime.now().strftime('%Y%m%d')}.csv",
-            mime="text/csv",
-            use_container_width=True
-        )
-
-with col2:
-    st.button("📥 Export Detailed Feedback", use_container_width=True, disabled=True)
-    st.caption("💡 Detailed feedback export coming soon. Use Snowflake queries to access feedback data directly.")
-
-st.markdown("---")
-st.markdown("**💡 Tip:** Use historical analytics to track improvements over time and identify which configurations perform best!")
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)

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',
-]

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

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 []

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

utils/db_manager.py

@@ -1,505 +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 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}")

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

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

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] = []

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": "#FFD700",      # Gold
-        "secondary": "#2C2C2C",    # Dark gray
-        "accent": "#1A1A1A",       # Black
-        "text": "#FFFFFF",         # White
-        "background": "#0D0D0D",   # Very dark
-        "sidebar_bg": "#8B7500"    # Darker gold for sidebar
-    },
-    "drumeo": {
-        "primary": "#5DADE2",      # Light blue
-        "secondary": "#FFD700",    # Gold
-        "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": "#FFD700",    # Gold
-        "accent": "#C0392B",       # Darker red
-        "text": "#FFFFFF",         # White
-        "background": "#1C1C1C",   # Dark
-        "sidebar_bg": "#8B2500"    # Darker red for sidebar
-    },
-    "guitareo": {
-        "primary": "#58D68D",      # Light green
-        "secondary": "#FFD700",    # Gold
-        "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": "#FFD700",    # Gold
-        "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(255, 215, 0, 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>'