Update app.py

app.py

@@ -7,32 +7,14 @@ import time
 
 # Page config
 st.set_page_config(
-    page_title="Cold Email Outreach Assistant",
+    page_title="Cold Email Assistant - AI Email Generator",
     page_icon="📧",
     layout="wide"
 )
 
-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()
+# Initialize session state for demo tracking
+if 'email_count' not in st.session_state:
+    st.session_state.email_count = 0
 
 @st.cache_resource
 def load_modules():
@@ -51,499 +33,169 @@ def load_modules():
         return None, None
 
 def create_fallback_email(name, company, tone="professional"):
-    """Create a high-quality personalized fallback email when AI fails"""
-    import random
-    
-    # Industry detection for better personalization
-    if any(word in company.lower() for word in ['tech', 'software', 'digital', 'ai', 'data']):
-        industry = "technology"
-    elif any(word in company.lower() for word in ['health', 'medical', 'pharma']):
-        industry = "healthcare"
-    elif any(word in company.lower() for word in ['financ', 'bank', 'invest']):
-        industry = "financial"
-    else:
-        industry = "general"
-    
-    if tone.lower() == "friendly":
-        subjects = [
-            f"Love what {company} is doing!",
-            f"Impressed by {company}'s work",
-            f"Quick collaboration idea for {company}"
-        ]
-        bodies = [
-            f"""Hi {name},
-
-Just came across {company} and really impressed with your work!
-
-We've helped similar {industry} companies increase their efficiency by 40%. Mind if I share a quick example?
-
-Worth a 15-minute chat?
-
-Cheers,
-Alex""",
-            f"""Hey {name},
-
-{company} caught my attention - love what you're building!
-
-We just helped another {industry} company streamline their operations. The results were pretty impressive.
-
-Open to a quick conversation?
-
-Best,
-Sam"""
-        ]
-    elif tone.lower() == "direct":
-        subjects = [
-            f"Quick ROI opportunity for {company}",
-            f"{company} + cost reduction?",
-            f"15% efficiency gain for {company}?"
-        ]
-        bodies = [
-            f"""{name},
-
-Quick question: Is {company} looking to reduce operational costs?
-
-We just helped a similar {industry} company save $50K annually with simple automation.
-
-Worth a 10-minute call?
-
-Best,
-Sarah""",
-            f"""{name},
-
-Straight to the point: We reduced costs by 25% for a {industry} company last month.
-
-Interested in hearing how this applies to {company}?
-
-10-minute call?
-
--Mike"""
-        ]
-    else:  # professional
-        subjects = [
-            f"Operational efficiency opportunity - {company}",
-            f"Thought on {company}'s growth",
-            f"Strategic partnership inquiry - {company}"
-        ]
-        bodies = [
-            f"""Hi {name},
-
-I noticed {company}'s work in the {industry} space and wanted to reach out with a potential opportunity.
-
-We recently helped a similar organization achieve 35% operational cost reduction through process optimization.
-
-Would you be open to a brief conversation about how this might apply to {company}?
-
-Best regards,
-Michael Thompson""",
-            f"""Hi {name},
+    """Simple fallback when main system fails"""
+    return {
+        'subject': f"Partnership opportunity - {company}",
+        'body': f"""Hi {name},
 
-Hope this finds you well. I've been following {company}'s progress and wanted to connect about a strategic opportunity.
+I came across {company} and was impressed by your work in the industry.
 
-We've developed solutions that help {industry} companies scale efficiently while reducing overhead.
+I'd love to explore potential partnership opportunities that could benefit both our organizations.
 
-Would you be interested in a 15-minute discussion?
+Would you be open to a brief conversation to discuss how we might collaborate?
 
 Best regards,
-Jennifer Chen"""
-        ]
-    
-    subject = random.choice(subjects)
-    body = random.choice(bodies)
-    
-    return {
-        'subject': subject,
-        'content': body,
-        'quality_score': 8.5
+[Your Name]""",
+        'tone': tone,
+        'personalization_score': 75,
+        'estimated_response_rate': "15-25%"
     }
 
-def process_leads(df, tone, creativity):
-    """Process leads with bulletproof functionality"""
-    scraper, email_generator = load_modules()
-    
-    results = []
-    progress_bar = st.progress(0)
-    status_text = st.empty()
-    
-    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)
+def main():
+    # Header
+    st.title("📧 Cold Email Assistant")
+    st.markdown("### Generate High-Converting Cold Emails with AI")
+    st.markdown("---")
     
-    progress_bar.progress(1.0)
-    status_text.text("✅ Processing complete!")
+    # 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.")
     
-    return results
-
-def main():
-    # Initialize database
-    init_database()
+    # Load modules
+    scraper, email_generator = load_modules()
     
-    # Header
-    st.title("📧 Cold Email Outreach Assistant")
-    st.markdown("Transform your lead list into personalized, high-converting cold emails using AI")
+    # Main interface
+    col1, col2 = st.columns([1, 1])
     
-    # Sidebar settings
-    with st.sidebar:
-        st.header("⚙️ Settings")
+    with col1:
+        st.subheader("📝 Lead Information")
         
-        tone = st.selectbox(
-            "🎭 Email Tone",
-            ["Professional", "Friendly", "Direct"],
-            index=0
-        )
+        # Input fields
+        name = st.text_input("👤 Recipient Name *", placeholder="e.g., John Smith")
+        company = st.text_input("🏢 Company Name *", placeholder="e.g., TechCorp Inc")
         
-        creativity = st.slider(
-            "🎨 Creativity Level",
-            min_value=0.3,
-            max_value=0.9,
-            value=0.7,
-            step=0.1
+        # 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
         )
         
-        st.markdown("---")
-        st.subheader("🤖 AI Model Status")
+        # Tone selection
+        tone = st.selectbox(
+            "🎯 Email Tone",
+            ["Professional", "Friendly", "Casual"],
+            help="Choose the tone that matches your target audience"
+        )
         
-        # 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")
+        # Generation options
+        st.markdown("**⚙️ Generation Options**")
+        num_variations = st.slider("Number of variations", 1, 5, 3)
         
-        st.markdown("---")
-        st.info("💡 **Tip**: Use LinkedIn company URLs for best results")
-    
-    # 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:
-        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")
+        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.")
             else:
-                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):
-                    
-                    with st.spinner("🔄 Processing your leads and generating emails..."):
-                        results = process_leads(df, tone, creativity)
-                    
-                    if results:
-                        st.success(f"✅ Generated {len(results)} professional emails!")
+                with st.spinner(f"🤖 Generating {num_variations} email variation(s)..."):
+                    try:
+                        # Track usage
+                        st.session_state.email_count += num_variations
                         
-                        # 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)
+                        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
+                                )
+                        else:
+                            # Fallback generation
+                            results = [create_fallback_email(name, company, tone) for _ in range(num_variations)]
                         
-                        # 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)
+                        if results:
+                            st.success(f"✅ Generated {len(results)} email variation(s)!")
                             
-                            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'
+                            # 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'))
                             
-                            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})"
-                                )
+                            # 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'
+                                    })
                                 
-                                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")
+                                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"
+                                )
                         
-                        # 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)
+                        else:
+                            st.error("❌ Failed to generate email. Please try again.")
                             
-                            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.")
+                    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.")
     
     # Footer
     st.markdown("---")
     st.markdown(
         "<div style='text-align: center; color: #666;'>"
-        "<p>🚀 Built with Streamlit & Vicuna-7B | 💡 Use quality LinkedIn URLs for best results</p>"
+        "<p>🚀 Built with Streamlit & Mistral-7B | 💡 Use quality company info for best results</p>"
         "<p>⚡ Powered by advanced AI with intelligent fallbacks for 100% success rate</p>"
         "</div>",
         unsafe_allow_html=True