Create app.py

app.py

@@ -0,0 +1,207 @@
+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()