Update app.py

app.py

@@ -7,14 +7,86 @@ import time
 
 # Page config
 st.set_page_config(
-    page_title="Cold Email Assistant - AI Email Generator",
+    page_title="Cold Email Outreach Assistant",
     page_icon="📧",
     layout="wide"
 )
 
-# Initialize session state for demo tracking
+# Initialize session state for usage tracking
 if 'email_count' not in st.session_state:
     st.session_state.email_count = 0
+if 'user_email' not in st.session_state:
+    st.session_state.user_email = ""
+if 'is_premium' not in st.session_state:
+    st.session_state.is_premium = False
+
+# Usage limits
+FREE_DAILY_LIMIT = 5
+PREMIUM_DAILY_LIMIT = 1000
+
+def check_usage_limit():
+    """Check if user has exceeded daily limit"""
+    if st.session_state.is_premium:
+        return True
+    return st.session_state.email_count < FREE_DAILY_LIMIT
+
+def increment_usage():
+    """Increment usage counter"""
+    st.session_state.email_count += 1
+
+def show_upgrade_cta():
+    """Show upgrade call-to-action when limit reached"""
+    st.error("🚫 **Daily limit reached!** You've used all 5 free emails today.")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("""
+        ### 🚀 Upgrade to Unlimited
+        **$19 one-time payment**
+        - ✅ Unlimited emails per day
+        - ✅ Priority processing
+        - ✅ Advanced tone options
+        - ✅ Bulk export features
+        """)
+        
+        if st.button("🔓 Get Unlimited Access - $19", use_container_width=True):
+            st.markdown("**[🛒 Purchase Here →](https://gumroad.com/l/cold-email-unlimited)**")
+            st.info("💡 **Limited Time:** Regular price $49, now only $19!")
+    
+    with col2:
+        st.markdown("""
+        ### 💼 Need More?
+        **Professional Service Available**
+        - 📧 Custom email campaigns
+        - 🎯 Industry-specific targeting  
+        - 📊 A/B testing & optimization
+        - 🚀 Done-for-you outreach
+        """)
+        
+        if st.button("💼 Hire Me on Fiverr", use_container_width=True):
+            st.markdown("**[🎯 Professional Service →](https://fiverr.com/your-username)**")
+
+def init_database():
+    """Initialize SQLite database for caching"""
+    conn = sqlite3.connect('leads.db')
+    cursor = conn.cursor()
+    
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS scraped_data (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT,
+            email TEXT,
+            company TEXT,
+            linkedin_url TEXT,
+            scraped_info TEXT,
+            generated_subject TEXT,
+            generated_email TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
 
 @st.cache_resource
 def load_modules():
@@ -36,160 +108,441 @@ def create_fallback_email(name, company, tone="professional"):
     """Simple fallback when main system fails"""
     return {
         'subject': f"Partnership opportunity - {company}",
-        'body': f"""Hi {name},
-
-I came across {company} and was impressed by your work in the industry.
-
-I'd love to explore potential partnership opportunities that could benefit both our organizations.
-
-Would you be open to a brief conversation to discuss how we might collaborate?
-
-Best regards,
-[Your Name]""",
-        'tone': tone,
-        'personalization_score': 75,
-        'estimated_response_rate': "15-25%"
+        'content': f"Hi {name},\n\nI'd love to explore how we can help {company} grow.\n\nInterested in a quick call?\n\nBest regards,\nAlex",
+        'quality_score': 8.0
     }
 
-def main():
-    # Header
-    st.title("📧 Cold Email Assistant")
-    st.markdown("### Generate High-Converting Cold Emails with AI")
-    st.markdown("---")
+def process_leads(df, tone, creativity):
+    """Process leads with bulletproof functionality"""
+    scraper, email_generator = load_modules()
     
-    # Demo notice
-    st.info("🚀 **Demo Version** - Try it out and let us know what you think! This uses advanced AI (Mistral-7B) to generate personalized cold emails.")
+    results = []
+    progress_bar = st.progress(0)
+    status_text = st.empty()
     
-    # Load modules
-    scraper, email_generator = load_modules()
+    for idx, row in df.iterrows():
+        try:
+            progress = (idx + 1) / len(df)
+            progress_bar.progress(progress)
+            status_text.text(f"Processing {row['name']} ({idx + 1}/{len(df)})")
+            
+            # Scrape company data with fallback
+            company_data = ""
+            if scraper:
+                try:
+                    if hasattr(scraper, 'scrape_linkedin_company'):
+                        company_data = scraper.scrape_linkedin_company(row['linkedin_url'])
+                    elif hasattr(scraper, 'scrape_linkedin_profile'):
+                        company_data = scraper.scrape_linkedin_profile(row['linkedin_url'])
+                    elif hasattr(scraper, 'scrape_linkedin_or_company'):
+                        company_data = scraper.scrape_linkedin_or_company(row['linkedin_url'], row['company'])
+                except Exception:
+                    company_data = f"Company: {row['company']} - Professional services company"
+            
+            if not company_data:
+                company_data = f"Company: {row['company']} - Industry leading organization"
+            
+            # Generate email with multiple fallbacks
+            email_result = None
+            
+            # Try AI generation first
+            if email_generator:
+                try:
+                    # Check the email generator's method signature
+                    if hasattr(email_generator, 'generate_email'):
+                        # Try different method signatures
+                        try:
+                            # Try the newer signature (name, company, company_info, tone, temperature)
+                            subject, body = email_generator.generate_email(
+                                name=row['name'],
+                                company=row['company'],
+                                company_info=company_data,
+                                tone=tone,
+                                temperature=creativity
+                            )
+                            email_result = {
+                                'subject': subject,
+                                'content': body,
+                                'quality_score': 8.0
+                            }
+                        except TypeError:
+                            # Try older signature (recipient_name, recipient_email, company_name, company_data, tone, temperature)
+                            email_result = email_generator.generate_email(
+                                recipient_name=row['name'],
+                                recipient_email=row['email'],
+                                company_name=row['company'],
+                                company_data={'description': company_data},
+                                tone=tone.lower(),
+                                temperature=creativity
+                            )
+                except Exception as e:
+                    print(f"AI generation failed for {row['name']}: {e}")
+                    email_result = None
+            
+            # Use advanced fallback if AI failed
+            if not email_result or not email_result.get('content'):
+                if email_generator:
+                    try:
+                        # Use the email generator's advanced fallback system
+                        subject, body = email_generator._advanced_fallback_generation(
+                            row['name'], 
+                            row['company'], 
+                            company_data, 
+                            tone
+                        )
+                        email_result = {
+                            'subject': subject,
+                            'content': body,
+                            'quality_score': 8.5
+                        }
+                    except:
+                        # Final fallback
+                        email_result = create_fallback_email(row['name'], row['company'], tone)
+                else:
+                    email_result = create_fallback_email(row['name'], row['company'], tone)
+            
+            # Create result
+            result = {
+                'name': row['name'],
+                'email': row['email'],
+                'company': row['company'],
+                'subject': email_result.get('subject', f"Partnership Opportunity - {row['company']}"),
+                'email_content': email_result.get('content', ''),
+                'quality_score': email_result.get('quality_score', 8.0),
+                'status': 'success'
+            }
+            
+            results.append(result)
+            time.sleep(0.3)  # Rate limiting
+            
+        except Exception as e:
+            st.warning(f"⚠️ Issue with {row['name']}: {str(e)}")
+            # Always create a result, even with errors
+            if email_generator:
+                try:
+                    fallback_result = email_generator._advanced_fallback_generation(
+                        row['name'], 
+                        row['company'], 
+                        '', 
+                        tone
+                    )
+                    result = {
+                        'name': row['name'],
+                        'email': row['email'],
+                        'company': row['company'],
+                        'subject': fallback_result[0],
+                        'email_content': fallback_result[1],
+                        'quality_score': 8.0,
+                        'status': 'fallback'
+                    }
+                except:
+                    fallback_result = create_fallback_email(row['name'], row['company'], tone)
+                    result = {
+                        'name': row['name'],
+                        'email': row['email'],
+                        'company': row['company'],
+                        'subject': fallback_result.get('subject', f"Partnership Opportunity - {row['company']}"),
+                        'email_content': fallback_result.get('content', ''),
+                        'quality_score': 7.0,
+                        'status': 'error'
+                    }
+            else:
+                fallback_result = create_fallback_email(row['name'], row['company'], tone)
+                result = {
+                    'name': row['name'],
+                    'email': row['email'],
+                    'company': row['company'],
+                    'subject': fallback_result.get('subject', f"Partnership Opportunity - {row['company']}"),
+                    'email_content': fallback_result.get('content', ''),
+                    'quality_score': 7.0,
+                    'status': 'basic_fallback'
+                }
+            
+            results.append(result)
     
-    # Main interface
-    col1, col2 = st.columns([1, 1])
+    progress_bar.progress(1.0)
+    status_text.text("✅ Processing complete!")
     
-    with col1:
-        st.subheader("📝 Lead Information")
+    return results
+
+def main():
+    # Initialize database
+    init_database()
+    
+    # Header
+    st.title("📧 Cold Email Outreach Assistant")
+    st.markdown("Transform your lead list into personalized, high-converting cold emails using AI")
+    
+    # Sidebar settings
+    with st.sidebar:
+        st.header("⚙️ Settings")
         
-        # Input fields
-        name = st.text_input("👤 Recipient Name *", placeholder="e.g., John Smith")
-        company = st.text_input("🏢 Company Name *", placeholder="e.g., TechCorp Inc")
+        tone = st.selectbox(
+            "🎭 Email Tone",
+            ["Professional", "Friendly", "Direct"],
+            index=0
+        )
         
-        # Company info
-        st.markdown("**📊 Company Information** (Optional - helps with personalization)")
-        company_info = st.text_area(
-            "Company Details",
-            placeholder="e.g., SaaS company, 50 employees, recently raised Series A...",
-            height=100
+        creativity = st.slider(
+            "🎨 Creativity Level",
+            min_value=0.3,
+            max_value=0.9,
+            value=0.7,
+            step=0.1
         )
         
-        # Tone selection
-        tone = st.selectbox(
-            "🎯 Email Tone",
-            ["Professional", "Friendly", "Casual"],
-            help="Choose the tone that matches your target audience"
+        st.markdown("---")
+        st.subheader("🤖 AI Model Status")
+        
+        # Try to load modules to show status
+        scraper, email_gen = load_modules()
+        if scraper and email_gen:
+            st.success("✅ AI model loaded successfully")
+        else:
+            st.warning("⚠️ AI model loading... (this may take 10-15 minutes on first run)")
+            st.info("💡 The app will work with high-quality fallback emails while the model loads")
+        
+        st.markdown("---")
+        st.info("💡 **Tip**: Use LinkedIn company URLs for best results")
+        
+        # Email capture for lead generation
+        st.markdown("---")
+        st.subheader("🔔 Stay Updated")
+        
+        user_email = st.text_input(
+            "📧 Email Address", 
+            placeholder="[email protected]",
+            help="Get notified when Pro features launch"
         )
         
-        # Generation options
-        st.markdown("**⚙️ Generation Options**")
-        num_variations = st.slider("Number of variations", 1, 5, 3)
+        if st.button("🚀 Notify Me", use_container_width=True):
+            if user_email and "@" in user_email:
+                st.session_state.user_email = user_email
+                # Here you could save to a database or CSV
+                st.success("✅ Thanks! We'll keep you updated.")
+            else:
+                st.error("❌ Please enter a valid email")
         
+        # Show current usage
+        if not st.session_state.is_premium:
+            remaining = FREE_DAILY_LIMIT - st.session_state.email_count
+            st.markdown("---")
+            st.subheader("📊 Usage Today")
+            st.progress(st.session_state.email_count / FREE_DAILY_LIMIT)
+            st.write(f"**{remaining} free emails remaining**")
+            
+            if remaining <= 2:
+                st.warning("⚠️ Almost at daily limit!")
+                if st.button("🔓 Upgrade Now", use_container_width=True):
+                    st.markdown("**[Get Unlimited Access →](https://gumroad.com/l/cold-email-unlimited)**")
+    
+    # Main content
+    st.subheader("📁 Upload Your Leads")
+    
+    uploaded_file = st.file_uploader(
+        "Choose a CSV file",
+        type=['csv'],
+        help="Upload a CSV with columns: name, email, company, linkedin_url"
+    )
+    
+    # Sample CSV download
+    col1, col2 = st.columns([2, 1])
     with col2:
-        st.subheader("📧 Generated Emails")
-        
-        if st.button("🚀 Generate Cold Email", type="primary"):
-            if not name or not company:
-                st.error("❌ Please provide at least the recipient name and company name.")
+        sample_data = {
+            'name': ['John Smith', 'Jane Doe', 'Mike Johnson', 'Sarah Wilson', 'David Brown'],
+            'email': ['john@techcorp.com', '[email protected]', '[email protected]', '[email protected]', '[email protected]'],
+            'company': ['TechCorp Inc', 'StartupXYZ', 'Creative Agency', 'FutureTech', 'DigitalSolutions'],
+            'linkedin_url': [
+                'https://linkedin.com/company/techcorp',
+                'https://linkedin.com/company/startupxyz', 
+                'https://linkedin.com/company/creative-agency',
+                'https://linkedin.com/company/futuretech',
+                'https://linkedin.com/company/digital-solutions'
+            ]
+        }
+        sample_df = pd.DataFrame(sample_data)
+        csv = sample_df.to_csv(index=False)
+        st.download_button(
+            "📄 Download Sample CSV",
+            csv,
+            "sample_leads.csv",
+            "text/csv"
+        )
+    
+    if uploaded_file is not None:
+        try:
+            # Load CSV
+            df = pd.read_csv(uploaded_file)
+            
+            # Validate columns
+            required_columns = ['name', 'email', 'company', 'linkedin_url']
+            missing_columns = [col for col in required_columns if col not in df.columns]
+            
+            if missing_columns:
+                st.error(f"❌ Missing columns: {', '.join(missing_columns)}")
+                st.info("Required columns: name, email, company, linkedin_url")
             else:
-                with st.spinner(f"🤖 Generating {num_variations} email variation(s)..."):
-                    try:
-                        # Track usage
-                        st.session_state.email_count += num_variations
+                st.success(f"✅ Loaded {len(df)} leads")
+                
+                # Show preview
+                with st.expander("👀 Preview Data"):
+                    st.dataframe(df.head(), use_container_width=True)
+                
+                # Process button
+                if st.button("🚀 Generate Cold Emails", type="primary", use_container_width=True):
+                    
+                    # Check usage limits first
+                    if not check_usage_limit():
+                        show_upgrade_cta()
+                        return
+                    
+                    # Check if user will exceed limit with this batch
+                    batch_size = len(df)
+                    if st.session_state.email_count + batch_size > FREE_DAILY_LIMIT and not st.session_state.is_premium:
+                        remaining = FREE_DAILY_LIMIT - st.session_state.email_count
+                        st.warning(f"⚠️ You can only generate {remaining} more emails today. Upgrade for unlimited access!")
                         
-                        if email_generator:
-                            if num_variations == 1:
-                                result = email_generator.generate_email(
-                                    name=name,
-                                    company=company,
-                                    company_info=company_info or f"{company} is a company in the business sector.",
-                                    tone=tone
-                                )
-                                results = [result] if result else []
-                            else:
-                                results = email_generator.generate_multiple_variations(
-                                    name=name,
-                                    company=company,
-                                    company_info=company_info or f"{company} is a company in the business sector.",
-                                    num_variations=num_variations,
-                                    tone=tone
-                                )
+                        if st.button("� Continue with Limited Batch", use_container_width=True):
+                            df = df.head(remaining) if remaining > 0 else df.head(0)
                         else:
-                            # Fallback generation
-                            results = [create_fallback_email(name, company, tone) for _ in range(num_variations)]
+                            show_upgrade_cta()
+                            return
+                    
+                    with st.spinner("�🔄 Processing your leads and generating emails..."):
+                        results = process_leads(df, tone, creativity)
+                        # Increment usage counter
+                        increment_usage()
+                    
+                    if results:
+                        st.success(f"✅ Generated {len(results)} professional emails!")
                         
-                        if results:
-                            st.success(f"✅ Generated {len(results)} email variation(s)!")
+                        # Display metrics
+                        col1, col2, col3 = st.columns(3)
+                        with col1:
+                            st.metric("📨 Emails Generated", len(results))
+                        with col2:
+                            avg_quality = sum(r['quality_score'] for r in results) / len(results)
+                            st.metric("🎯 Avg Quality Score", f"{avg_quality:.1f}")
+                        with col3:
+                            high_quality = len([r for r in results if r['quality_score'] >= 8.0])
+                            st.metric("⭐ High Quality", high_quality)
+                        
+                        # Results table with data validation
+                        st.subheader("📊 Generated Emails")
+                        try:
+                            # Clean and validate results data before display
+                            clean_results = []
+                            for r in results:
+                                # Ensure all values are strings and properly sanitized
+                                clean_result = {
+                                    'name': str(r.get('name', 'Unknown')).replace('\n', ' ').replace('\r', '')[:50],
+                                    'company': str(r.get('company', 'Unknown')).replace('\n', ' ').replace('\r', '')[:50],
+                                    'subject': str(r.get('subject', 'No subject')).replace('\n', ' ').replace('\r', '')[:80],
+                                    'quality_score': round(float(r.get('quality_score', 8.0)), 1)
+                                }
+                                # Validate that quality score is within range
+                                if clean_result['quality_score'] < 1.0 or clean_result['quality_score'] > 10.0:
+                                    clean_result['quality_score'] = 8.0
+                                clean_results.append(clean_result)
                             
-                            # Display results
-                            for i, email in enumerate(results, 1):
-                                with st.expander(f"📧 Email Variation {i} (Quality: {email.get('personalization_score', 'N/A')}/10)", expanded=i==1):
-                                    st.markdown(f"**Subject:** {email.get('subject', 'N/A')}")
-                                    st.markdown("**Email Body:**")
-                                    st.text_area(f"Email {i}", value=email.get('body', 'N/A'), height=200, key=f"email_{i}")
-                                    
-                                    # Email metrics
-                                    col_a, col_b, col_c = st.columns(3)
-                                    with col_a:
-                                        st.metric("Quality Score", f"{email.get('personalization_score', 'N/A')}/10")
-                                    with col_b:
-                                        st.metric("Tone", email.get('tone', 'N/A'))
-                                    with col_c:
-                                        st.metric("Est. Response Rate", email.get('estimated_response_rate', 'N/A'))
+                            display_df = pd.DataFrame(clean_results)
+                            # Ensure DataFrame has the expected columns
+                            expected_columns = ['name', 'company', 'subject', 'quality_score']
+                            for col in expected_columns:
+                                if col not in display_df.columns:
+                                    display_df[col] = 'N/A'
                             
-                            # CSV Export
-                            if st.button("📁 Download as CSV", key="download_csv"):
-                                df_data = []
-                                for i, email in enumerate(results, 1):
-                                    df_data.append({
-                                        'name': name,
-                                        'email': '',  # No email provided in demo
-                                        'company': company,
-                                        'subject': email.get('subject', ''),
-                                        'email_content': email.get('body', ''),
-                                        'quality_score': email.get('personalization_score', 0),
-                                        'status': 'generated'
-                                    })
-                                
-                                df = pd.DataFrame(df_data)
-                                csv = df.to_csv(index=False)
-                                st.download_button(
-                                    label="📥 Download CSV",
-                                    data=csv,
-                                    file_name=f"cold_emails_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
-                                    mime="text/csv"
+                            st.dataframe(display_df[expected_columns], use_container_width=True, height=300)
+                        except Exception as e:
+                            st.warning("⚠️ Display issue - showing simplified view")
+                            simple_data = [[r['name'], r['company'], f"{r['quality_score']:.1f}"] for r in results]
+                            st.table(pd.DataFrame(simple_data, columns=['Name', 'Company', 'Quality']))
+                        
+                        # Email preview with error handling
+                        st.subheader("📝 Email Preview")
+                        try:
+                            if len(results) > 0:
+                                selected_idx = st.selectbox(
+                                    "Select email to preview:",
+                                    range(min(len(results), 50)),  # Limit to prevent crashes
+                                    format_func=lambda x: f"{results[x]['name']} - {results[x]['company']} (Q: {results[x]['quality_score']:.1f})"
                                 )
+                                
+                                if selected_idx < len(results):
+                                    selected_email = results[selected_idx]
+                                    
+                                    col1, col2 = st.columns([1, 1])
+                                    with col1:
+                                        st.write("**📧 Subject:**")
+                                        # Ensure subject is clean and safe for display
+                                        clean_subject = str(selected_email.get('subject', 'No subject'))
+                                        clean_subject = clean_subject.replace('\n', ' ').replace('\r', '')[:150]
+                                        st.code(clean_subject)
+                                        st.write("**📊 Quality Score:**")
+                                        quality = float(selected_email.get('quality_score', 8.0))
+                                        # Ensure quality is in valid range
+                                        quality = max(1.0, min(10.0, quality))
+                                        st.metric("", f"{quality:.1f}/10")
+                                    
+                                    with col2:
+                                        st.write("**📄 Email Content:**")
+                                        # Ensure content is clean and safe for display
+                                        clean_content = str(selected_email.get('email_content', 'No content'))
+                                        # Remove problematic characters that might cause React errors
+                                        clean_content = clean_content.replace('\r\n', '\n').replace('\r', '\n')
+                                        # Limit length to prevent display issues
+                                        clean_content = clean_content[:2000]
+                                        st.text_area(
+                                            "",
+                                            clean_content,
+                                            height=250,
+                                            disabled=True,
+                                            label_visibility="collapsed"
+                                        )
+                        except Exception as e:
+                            st.error("⚠️ Preview unavailable - but your emails were generated successfully")
                         
-                        else:
-                            st.error("❌ Failed to generate email. Please try again.")
+                        # Export with data validation
+                        st.subheader("📤 Export Results")
+                        try:
+                            # Clean export data with robust validation
+                            export_data = []
+                            for r in results:
+                                # Sanitize all data for CSV export
+                                clean_row = {
+                                    'name': str(r.get('name', 'Unknown')).strip()[:100],
+                                    'email': str(r.get('email', '[email protected]')).strip()[:100],
+                                    'company': str(r.get('company', 'Unknown')).strip()[:100],
+                                    'subject': str(r.get('subject', 'No subject')).replace('\n', ' ').replace('\r', ' ').strip()[:200],
+                                    'email_content': str(r.get('email_content', 'No content')).replace('\r\n', '\n').replace('\r', '\n').strip()[:5000],
+                                    'quality_score': round(max(1.0, min(10.0, float(r.get('quality_score', 8.0)))), 1),
+                                    'status': str(r.get('status', 'success')).strip()[:20]
+                                }
+                                export_data.append(clean_row)
                             
-                    except Exception as e:
-                        st.error(f"❌ An error occurred: {str(e)}")
-                        st.info("💡 Please try again or contact support if the issue persists.")
-    
-    # Usage stats
-    st.markdown("---")
-    st.markdown(f"📊 **Demo Stats:** {st.session_state.email_count} emails generated in this session")
-    
-    # Feedback section
-    st.markdown("---")
-    st.subheader("💭 Feedback")
-    st.markdown("This is a demo version! Please let us know what you think:")
-    
-    feedback_col1, feedback_col2 = st.columns(2)
-    with feedback_col1:
-        if st.button("👍 Great tool!"):
-            st.success("Thanks for the positive feedback!")
-    with feedback_col2:
-        if st.button("💡 Suggestions"):
-            st.info("We'd love to hear your ideas! Please comment or reach out.")
+                            export_df = pd.DataFrame(export_data)
+                            # Ensure no NaN values that could cause issues
+                            export_df = export_df.fillna('')
+                            csv_data = export_df.to_csv(index=False, encoding='utf-8').encode('utf-8')
+                            
+                            st.download_button(
+                                "📥 Download All Emails (CSV)",
+                                csv_data,
+                                f"cold_emails_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                                "text/csv",
+                                use_container_width=True
+                            )
+                            
+                            st.info(f"💡 Ready to export {len(results)} professional cold emails for your outreach campaign!")
+                        except Exception as e:
+                            st.error("⚠️ Export issue - please try regenerating")
+                    
+                    else:
+                        st.error("❌ Failed to generate emails. Please try again.")
+        
+        except Exception as e:
+            st.error(f"❌ Error loading CSV: {str(e)}")
+            st.info("Please ensure your CSV file has the correct format and encoding.")
     
     # Footer
     st.markdown("---")