app.py

import pandas as pd
import re
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import streamlit as st
import os
from datetime import datetime

# Function to validate email using regular expression
def is_valid_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zAZ0-9.-]+\.[a-zA-Z]{2,}$'
    return re.match(pattern, email) is not None

# Function to validate email via SMTP server
def check_smtp_validity(email, smtp_server='smtp.gmail.com', smtp_port=587, sender_email='[email protected]', sender_password='your_email_password'):
    try:
        server = smtplib.SMTP(smtp_server, smtp_port)
        server.starttls()
        server.login(sender_email, sender_password)

        msg = MIMEMultipart()
        msg['From'] = sender_email
        msg['To'] = email
        msg['Subject'] = 'Congratulations! You’ve won a prize!'

        body = 'Click this link to claim your prize: http://example.com'
        msg.attach(MIMEText(body, 'plain'))

        server.sendmail(sender_email, email, msg.as_string())
        server.quit()

        return 'valid'
    
    except smtplib.SMTPRecipientsRefused:
        return 'invalid'
    except Exception as e:
        return 'invalid'

# Function to read different types of files
def read_file(file):
    if file.name.endswith('.xls') or file.name.endswith('.xlsx'):
        return pd.read_excel(file)
    elif file.name.endswith('.csv'):
        return pd.read_csv(file)
    elif file.name.endswith('.ods'):
        return pd.read_excel(file, engine="odf")
    else:
        st.error("Unsupported file format. Please upload a valid Excel (.xls, .xlsx), CSV, or ODS file.")
        return None

# Function to validate emails and save results to a new file
def verify_emails(input_df, output_file, sender_email, sender_password, batch_start, batch_size=500):
    try:
        # Process only a batch of 500 emails per day
        batch_df = input_df.iloc[batch_start:batch_start + batch_size]
        
        # Validate the emails in the batch
        batch_df['status'] = batch_df['emails'].apply(lambda email: check_smtp_validity(email, sender_email=sender_email, sender_password=sender_password))

        # Save the result to output file
        if output_file.endswith('.csv'):
            batch_df.to_csv(output_file, index=False)
        elif output_file.endswith('.ods'):
            batch_df.to_excel(output_file, index=False, engine='odf')
        else:
            batch_df.to_excel(output_file, index=False)
        
        return batch_df, batch_start + len(batch_df)
        
    except Exception as e:
        st.error(f"Error: {e}")
        return None, batch_start

# Function to send email with results as attachment
def send_email_result(output_file, recipient_email, sender_email, sender_password):
    try:
        # Create the email message
        msg = MIMEMultipart()
        msg['From'] = sender_email
        msg['To'] = recipient_email
        msg['Subject'] = 'Email Validation Results'

        body = 'Please find the attached email validation results.'
        msg.attach(MIMEText(body, 'plain'))

        # Attach the output file (Excel with validation results)
        with open(output_file, 'rb') as attachment:
            part = MIMEText(attachment.read(), 'base64', 'utf-8')
            part.add_header('Content-Disposition', 'attachment', filename=os.path.basename(output_file))
            msg.attach(part)

        # Send the email
        with smtplib.SMTP('smtp.gmail.com', 587) as server:
            server.starttls()
            server.login(sender_email, sender_password)
            server.sendmail(sender_email, recipient_email, msg.as_string())
        
        st.success(f"Results successfully sent to {recipient_email}")
    
    except Exception as e:
        st.error(f"Error sending email: {e}")

# Function to load settings (sender email, app password, recipient email)
def load_settings():
    if os.path.exists("settings.txt"):
        with open("settings.txt", "r") as f:
            settings = f.read().splitlines()
        return settings
    return None

# Function to save settings (sender email, app password, recipient email)
def save_settings(sender_email, sender_password, recipient_email):
    with open("settings.txt", "w") as f:
        f.write(f"{sender_email}\n{sender_password}\n{recipient_email}")

# Function to load progress (last processed email index)
def load_progress():
    if os.path.exists("progress.txt"):
        with open("progress.txt", "r") as f:
            return int(f.read().strip())
    return 0

# Function to save progress (last processed email index)
def save_progress(progress):
    with open("progress.txt", "w") as f:
        f.write(str(progress))

# Streamlit App
def main():
    st.title("Email Validation App")

    # Display instructions to create a Gmail App Password
    st.markdown("""
    **To send emails using your Gmail account, you need to generate an App Password:**

    1. Go to [Google App Passwords](https://myaccount.google.com/apppasswords).
    2. Sign in to your Google account if prompted.
    3. Under "Select App," choose **Other (Custom name)** from the dropdown list.
    4. Enter a name for the app (e.g., "Email Validation App") and click **Generate**.
    5. Copy the generated password and paste it into the "App Password" field in this app.
    6. Use this App Password instead of your regular Gmail password when sending emails.
    """)

    # Load settings if they exist
    settings = load_settings()
    
    # Step 1: Upload the file (Excel, CSV, or ODS) only if settings are already saved
    if settings:
        st.info("Settings already saved. You can upload your email file to continue processing.")
    else:
        st.warning("No settings found. Please provide your Gmail credentials and recipient email first.")

    uploaded_file = st.file_uploader("Upload your file with emails (Excel, CSV, or ODS)", type=["xls", "xlsx", "csv", "ods"])

    # Load the file and process emails only if it's uploaded
    if uploaded_file:
        input_df = read_file(uploaded_file)
        
        if input_df is None:
            return
        
        # Ensure the file contains an 'emails' column
        if 'emails' not in input_df.columns:
            st.error("Error: 'emails' column not found in the uploaded file.")
            return

        # Step 2: Input Gmail credentials if not already saved
        if not settings:
            sender_email = st.text_input("Enter temporary Gmail ID", type="default")
            sender_password = st.text_input("Enter Gmail App Password", type="password")
            recipient_email = st.text_input("Enter recipient email for results", type="default")

            if sender_email and sender_password and recipient_email:
                if st.button("Save Settings"):
                    save_settings(sender_email, sender_password, recipient_email)
                    st.success("Settings saved. You can now upload your email file and continue processing.")
                    st.experimental_rerun()  # Rerun the app to load the new settings and show the process button
        else:
            # Use saved settings
            sender_email, sender_password, recipient_email = settings

        # Process emails in batches of 500
        batch_start = load_progress()
        output_file = f"output_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
        
        if uploaded_file.name.endswith('.csv'):
            output_file += '.csv'
        elif uploaded_file.name.endswith('.ods'):
            output_file += '.ods'
        else:
            output_file += '.xlsx'

        # After saving settings, now show the "Process Next Batch" button
        if st.button("Process Next Batch"):
            batch_df, new_progress = verify_emails(input_df, output_file, sender_email, sender_password, batch_start)
            if batch_df is not None:
                save_progress(new_progress)
                send_email_result(output_file, recipient_email, sender_email, sender_password)
                st.success(f"Processed and sent results for batch {batch_start // 500 + 1}. Progress saved.")
            else:
                st.error("Error processing the batch.")

if __name__ == "__main__":
    if not os.path.exists("uploaded_files"):
        os.makedirs("uploaded_files")
    main()