Update app.py

app.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
 """
-Email Validator API - Hugging Face Spaces Edition (Fixed)
-Uses working validation logic from test_email.py
+Email Validator - Hugging Face Spaces (Gradio Version)
+Works perfectly on Hugging Face because Gradio is native
 """
 
-from flask import Flask, request, jsonify
+import gradio as gr
 import socket
 import time
 import uuid
@@ -13,13 +13,11 @@ import dns.resolver
 import smtplib
 import logging
 
-app = Flask(__name__)
 logging.basicConfig(level=logging.INFO)
 
 FROM_ADDRESS = 'verifier@yourdomain.com'
 SMTP_TIMEOUT = 15
 RATE_LIMIT_SECONDS = 1.0
-MAX_BATCH_SIZE = 100
 
 # Domain cache
 domain_cache = {}
@@ -80,11 +78,11 @@ def smtp_probe_recipient(mx_host: str, from_addr: str, recipient: str):
             pass
         return False, None, None, 'SMTPRecipientsRefused'
     
-    except (smtplib.SMTPConnectError, smtplib.SMTPServerDisconnected, socket.timeout, ConnectionRefusedError, OSError) as net_err:
-        return False, None, None, f'NETWORK_ERROR: {net_err}'
+    except (smtplib.SMTPConnectError, smtplib.SMTPServerDisconnected, socket.timeout, ConnectionRefusedError, OSError):
+        return False, None, None, 'NETWORK_ERROR'
     
-    except Exception as ex:
-        return False, None, None, f'ERROR: {ex}'
+    except Exception:
+        return False, None, None, 'ERROR'
 
 def decide_outcome(email, mx_host, rcpt_code, catch_all_flag, probe_error):
     """Determine if email is valid or invalid"""
@@ -94,39 +92,33 @@ def decide_outcome(email, mx_host, rcpt_code, catch_all_flag, probe_error):
     if not mx_host:
         return 'INVALID', 'UNDELIVERABLE_NO_MX'
     
-    if probe_error:
+    if probe_error or rcpt_code is None:
         return 'INVALID', 'PROBE_FAILED_NETWORK'
     
-    if rcpt_code is None:
-        return 'INVALID', 'PROBE_FAILED_NETWORK'
-    
-    # 5xx = definitive rejection
     if 500 <= rcpt_code <= 599:
         return 'INVALID', 'MAILBOX_DOES_NOT_EXIST'
     
-    # 2xx = accepted
     if 200 <= rcpt_code <= 299:
         if catch_all_flag:
             return 'VALID', 'UNKNOWN_CATCHALL'
         else:
             return 'VALID', 'MAILBOX_EXISTS'
     
-    # 4xx = temporary error
     if 400 <= rcpt_code <= 499:
         return 'INVALID', 'TEMPORARY_ERROR'
     
     return 'INVALID', 'UNKNOWN_STATUS'
 
-def probe_email(email: str, domain_cache: Dict):
-    """Probe a single email and return validation result"""
+def validate_email_function(email: str) -> Dict:
+    """Validate a single email"""
     email = email.strip().lower()
     
     if not is_valid_format(email):
         return {
-            'email': email,
-            'status': 'INVALID',
-            'reason': 'INVALID_FORMAT',
-            'smtp_code': None
+            'Email': email,
+            'Status': '❌ INVALID',
+            'Reason': 'Invalid format',
+            'Valid': 'No'
         }
     
     domain = email.split('@')[1].lower()
@@ -140,10 +132,10 @@ def probe_email(email: str, domain_cache: Dict):
     
     if not hosts:
         return {
-            'email': email,
-            'status': 'INVALID',
-            'reason': 'UNDELIVERABLE_NO_MX',
-            'smtp_code': None
+            'Email': email,
+            'Status': '❌ INVALID',
+            'Reason': 'No MX records',
+            'Valid': 'No'
         }
     
     mx_host = hosts[0]
@@ -158,8 +150,6 @@ def probe_email(email: str, domain_cache: Dict):
         catch_all = False
         if ok and code and 200 <= code <= 299:
             catch_all = True
-        elif not ok and err and 'NETWORK_ERROR' in str(err):
-            catch_all = None
         
         domain_cache[domain]['catch_all'] = catch_all
         time.sleep(RATE_LIMIT_SECONDS)
@@ -177,135 +167,113 @@ def probe_email(email: str, domain_cache: Dict):
         probe_error=(not ok or err is not None)
     )
     
+    is_valid = status == 'VALID'
+    status_display = '✅ VALID' if is_valid else '❌ INVALID'
+    valid_text = 'Yes' if is_valid else 'No'
+    
     return {
-        'email': email,
-        'status': status,
-        'reason': reason,
-        'smtp_code': code
+        'Email': email,
+        'Status': status_display,
+        'Reason': reason,
+        'Valid': valid_text
     }
 
-@app.route('/', methods=['GET'])
-def home():
-    """API Documentation"""
-    return jsonify({
-        'name': 'Email Validator API',
-        'version': '2.0',
-        'description': 'Validates emails using DNS MX records and SMTP probing',
-        'endpoints': {
-            '/validate': {
-                'method': 'POST',
-                'description': 'Validate a single email',
-                'example': {'email': 'test@gmail.com'},
-            },
-            '/batch-validate': {
-                'method': 'POST',
-                'description': 'Validate multiple emails',
-                'example': {'emails': ['test1@gmail.com', 'test2@yahoo.com']}
-            }
-        }
-    })
+def validate_batch(emails_text: str) -> str:
+    """Validate multiple emails from text input"""
+    emails = [e.strip() for e in emails_text.split('\n') if e.strip()]
+    
+    if not emails:
+        return "Please enter at least one email"
+    
+    results = []
+    valid_count = 0
+    
+    for email in emails:
+        result = validate_email_function(email)
+        results.append(result)
+        if result['Valid'] == 'Yes':
+            valid_count += 1
+    
+    # Format output
+    output = f"**Total: {len(emails)} | Valid: {valid_count} | Invalid: {len(emails) - valid_count}**\n\n"
+    output += "| Email | Status | Reason | Valid |\n"
+    output += "|-------|--------|--------|-------|\n"
+    
+    for r in results:
+        output += f"| {r['Email']} | {r['Status']} | {r['Reason']} | {r['Valid']} |\n"
+    
+    return output
 
-@app.route('/validate', methods=['POST'])
-def validate():
-    """Validate a single email"""
-    try:
-        data = request.get_json()
-        
-        if not data or 'email' not in data:
-            return jsonify({
-                'error': 'Missing email parameter',
-                'example': {'email': 'test@example.com'}
-            }), 400
+# Create Gradio Interface
+with gr.Blocks(title="Email Validator") as demo:
+    gr.Markdown("# 📧 Email Validator API")
+    gr.Markdown("Validate emails using DNS MX records and SMTP probing")
+    
+    with gr.Tab("Single Email"):
+        with gr.Row():
+            email_input = gr.Textbox(
+                label="Email Address",
+                placeholder="Enter email to validate",
+                value="test@gmail.com"
+            )
         
-        email = data['email']
+        validate_btn = gr.Button("Validate", variant="primary", size="lg")
         
-        if not isinstance(email, str):
-            return jsonify({'error': 'Email must be a string'}), 400
+        with gr.Row():
+            email_output = gr.Textbox(label="Email", interactive=False)
+            status_output = gr.Textbox(label="Status", interactive=False)
         
-        result = probe_email(email, domain_cache)
+        with gr.Row():
+            reason_output = gr.Textbox(label="Reason", interactive=False)
+            valid_output = gr.Textbox(label="Valid", interactive=False)
         
-        return jsonify({
-            'email': result['email'],
-            'valid': result['status'] == 'VALID',
-            'status': result['status'],
-            'reason': result['reason'],
-            'smtp_code': result['smtp_code']
-        }), 200
+        validate_btn.click(
+            fn=validate_email_function,
+            inputs=email_input,
+            outputs=[email_output, status_output, reason_output, valid_output]
+        )
     
-    except Exception as e:
-        logging.error(f"Error in /validate: {str(e)}")
-        return jsonify({
-            'error': 'Internal server error',
-            'message': str(e)
-        }), 500
-
-@app.route('/batch-validate', methods=['POST'])
-def batch_validate():
-    """Validate multiple emails"""
-    try:
-        data = request.get_json()
+    with gr.Tab("Batch Validation"):
+        with gr.Row():
+            batch_input = gr.Textbox(
+                label="Emails (one per line)",
+                placeholder="test1@gmail.com\ntest2@yahoo.com\ninvalid@test.com",
+                lines=10
+            )
         
-        if not data or 'emails' not in data:
-            return jsonify({
-                'error': 'Missing emails parameter',
-                'example': {'emails': ['test@gmail.com', 'user@yahoo.com']}
-            }), 400
+        batch_btn = gr.Button("Validate Batch", variant="primary", size="lg")
+        batch_output = gr.Markdown(label="Results")
         
-        emails = data['emails']
-        
-        if not isinstance(emails, list):
-            return jsonify({'error': 'Emails must be a list'}), 400
+        batch_btn.click(
+            fn=validate_batch,
+            inputs=batch_input,
+            outputs=batch_output
+        )
+    
+    with gr.Tab("API Docs"):
+        gr.Markdown("""
+        ## API Endpoints
         
-        if len(emails) > MAX_BATCH_SIZE:
-            return jsonify({'error': f'Maximum {MAX_BATCH_SIZE} emails per request'}), 400
+        ### Single Email Validation
+        - **URL:** `/api/validate`
+        - **Method:** POST
+        - **Payload:** `{"email": "test@gmail.com"}`
         
-        results = []
-        valid_count = 0
+        ### Batch Validation
+        - **URL:** `/api/batch`
+        - **Method:** POST
+        - **Payload:** `{"emails": ["test1@gmail.com", "test2@yahoo.com"]}`
         
-        for email in emails:
-            if not isinstance(email, str):
-                results.append({
-                    'email': str(email),
-                    'valid': False,
-                    'error': 'Invalid type'
-                })
-                continue
-            
-            result = probe_email(email, domain_cache)
-            is_valid = result['status'] == 'VALID'
-            
-            results.append({
-                'email': result['email'],
-                'valid': is_valid,
-                'status': result['status'],
-                'reason': result['reason']
-            })
-            
-            if is_valid:
-                valid_count += 1
-        
-        return jsonify({
-            'total': len(emails),
-            'valid_count': valid_count,
-            'invalid_count': len(emails) - valid_count,
-            'results': results
-        }), 200
-    
-    except Exception as e:
-        logging.error(f"Error in /batch-validate: {str(e)}")
-        return jsonify({
-            'error': 'Internal server error',
-            'message': str(e)
-        }), 500
-
-@app.route('/health', methods=['GET'])
-def health():
-    """Health check endpoint"""
-    return jsonify({
-        'status': 'healthy',
-        'service': 'Email Validator API',
-        'version': '2.0'
-    }), 200
+        ## Response
+        ```
+        {
+            "Email": "test@gmail.com",
+            "Status": "✅ VALID",
+            "Reason": "MAILBOX_EXISTS",
+            "Valid": "Yes"
+        }
+        ```
+        """)
 
-if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=7860, debug=False)
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)