Uploaded

Dockerfile

@@ -1,3 +1,4 @@
+# Dockerfile
 FROM python:3.11-slim
 
 WORKDIR /app
@@ -5,18 +6,20 @@ WORKDIR /app
 ENV DEBIAN_FRONTEND=noninteractive
 ENV TZ=Etc/UTC
 
-# Install Chrome and dependencies
+# Install Chrome and dependencies for HuggingFace Spaces
 RUN apt-get update && apt-get install -y --no-install-recommends \
     chromium \
     chromium-driver \
     ca-certificates \
     fonts-liberation \
-    libnss3 \
-    libxss1 \
     libasound2 \
-    libxtst6 \
     libatk-bridge2.0-0 \
+    libdrm2 \
     libgtk-3-0 \
+    libnspr4 \
+    libnss3 \
+    libxss1 \
+    libxtst6 \
     libgbm1 \
     libxrandr2 \
     libxcomposite1 \
@@ -24,15 +27,26 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     procps \
     && rm -rf /var/lib/apt/lists/*
 
-# Install Python packages
+# Copy requirements first
 COPY requirements.txt .
+
+# Install Python packages as root BEFORE switching users
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Now switch to non-root user for HuggingFace Spaces
 USER 1000
 
+# Set environment for user 1000
+ENV HOME=/tmp/hf-user
+ENV PYTHONUSERBASE=/tmp/hf-user/.local
+ENV PATH="/tmp/hf-user/.local/bin:$PATH"
+
+# Copy application files
 COPY --chown=1000:1000 . .
+
+# Create config directory
 RUN mkdir -p config
 
 EXPOSE 7860
 
-CMD ["python", "server.py"]
+CMD ["python", "server.py"]

requirements.txt

@@ -5,4 +5,6 @@ Flask-Cors
 eventlet
 python-dotenv
 selenium
-psutil
+google-api-python-client
+google-auth-httplib2
+google-auth-oauthlib

server.py

@@ -1,9 +1,13 @@
+# server.py
 import eventlet
 eventlet.monkey_patch()
 
 import pandas as pd
 import io
+import threading
 import os
+import base64
+import json
 from datetime import datetime
 from flask import Flask, Response
 from flask_socketio import SocketIO, emit
@@ -20,9 +24,11 @@ load_dotenv()
 
 app = Flask(__name__)
 app.config['SECRET_KEY'] = 'secret-key-for-hillside-automation'
-FRONTEND_ORIGIN = os.getenv('FRONTEND_URL', 'https://quantbot.netlify.app') 
-CORS(app, resources={r"/*": {"origins": [FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500", "null"]}})
-socketio = SocketIO(app, cors_allowed_origins=[FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500", "null"], async_mode='eventlet')
+
+# Configure CORS for both local development and your Netlify frontend
+FRONTEND_ORIGIN = os.getenv('FRONTEND_URL', 'https://quantbot.netlify.app')
+CORS(app, resources={r"/*": {"origins": [FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500"]}})
+socketio = SocketIO(app, cors_allowed_origins=[FRONTEND_ORIGIN, "http://localhost:3000", "http://127.0.0.1:5500"], async_mode='eventlet')
 
 bot_instance = None
 session_data = {}
@@ -32,7 +38,9 @@ class EmailService:
         self.sender_email = os.getenv('EMAIL_SENDER')
         self.password = os.getenv('EMAIL_PASSWORD')
         self.smtp_server = "smtp.gmail.com"; self.smtp_port = 587
-        if not self.sender_email or not self.password: print("[Email] WARNING: Email credentials not found in secrets.")
+        if not self.sender_email or not self.password:
+            print("[Email] WARNING: Email credentials not found in environment variables.")
+    
     def send_report(self, recipients, subject, body, attachments=None):
         if not self.sender_email or not self.password: return False
         try:
@@ -46,7 +54,8 @@ class EmailService:
             with smtplib.SMTP(self.smtp_server, self.smtp_port) as server:
                 server.starttls(); server.login(self.sender_email, self.password); server.send_message(msg)
             print(f"Email sent successfully to {', '.join(recipients)}"); return True
-        except Exception as e: print(f"Failed to send email: {e}"); return False
+        except Exception as e:
+            print(f"Failed to send email: {e}"); return False
 
 class GoogleDriveService:
     def __init__(self):
@@ -56,12 +65,15 @@ class GoogleDriveService:
             from google.oauth2 import service_account
             from googleapiclient.discovery import build
             base64_creds = os.getenv('GDRIVE_SA_KEY_BASE64')
-            if not base64_creds or not self.folder_id: raise ValueError("Google Drive secrets not found.")
+            if not base64_creds or not self.folder_id:
+                raise ValueError("Google Drive secrets not found.")
             creds_json = base64.b64decode(base64_creds).decode('utf-8'); creds_dict = json.loads(creds_json)
             self.creds = service_account.Credentials.from_service_account_info(creds_dict, scopes=['https://www.googleapis.com/auth/drive'])
             self.service = build('drive', 'v3', credentials=self.creds)
-            print("[G-Drive] Service initialized securely from secrets.")
-        except Exception as e: print(f"[G-Drive] CRITICAL ERROR: Could not initialize Google Drive service: {e}")
+            print("[G-Drive] Service initialized securely from environment variables.")
+        except Exception as e:
+            print(f"[G-Drive] CRITICAL ERROR: Could not initialize Google Drive service: {e}")
+    
     def upload_file(self, filename, file_content):
         if not self.service: return False
         try:
@@ -71,15 +83,18 @@ class GoogleDriveService:
             self.service.files().create(body=file_metadata, media_body=media, fields='id').execute()
             print(f"[G-Drive] File '{filename}' uploaded successfully.")
             return True
-        except Exception as e: print(f"[G-Drive] ERROR: File upload failed: {e}"); return False
+        except Exception as e:
+            print(f"[G-Drive] ERROR: File upload failed: {e}"); return False
 
 email_service = EmailService()
 drive_service = GoogleDriveService()
 
 def get_email_list():
     try:
-        with open('config/emails.conf', 'r') as f: return [line.strip() for line in f if line.strip()]
-    except FileNotFoundError: return []
+        with open('config/emails.conf', 'r') as f:
+            return [line.strip() for line in f if line.strip()]
+    except FileNotFoundError:
+        return []
 
 def run_automation_process(session_id):
     global bot_instance
@@ -97,11 +112,9 @@ def run_automation_process(session_id):
         socketio.emit('error', {'message': f'A fatal error occurred: {e}'})
     finally:
         socketio.emit('micro_status_update', {'message': 'Generating final reports...'})
-        # We now call the report generation in the main thread via an event
-        socketio.emit('request_finalization', {
-            'session_id': session_id, 'results': results, 
-            'is_crash': is_crash, 'is_terminated': is_terminated
-        })
+        generate_and_send_reports(session_id, results, is_crash_report=is_crash, is_terminated=is_terminated)
+        if bot_instance: bot_instance.shutdown(); bot_instance = None
+        if session_id in session_data: del session_data[session_id]
 
 def generate_and_send_reports(session_id, results, is_crash_report=False, is_terminated=False):
     if not results:
@@ -118,7 +131,7 @@ def generate_and_send_reports(session_id, results, is_crash_report=False, is_ter
     attachments = {full_report_name: full_report_content, bad_report_name: bad_df.to_csv(index=False)}
     status_text = "terminated by user" if is_terminated else "crashed due to an error" if is_crash_report else "completed successfully"
     subject = f"Automation Report [{status_text.upper()}]: {custom_name}"
-    body = f"""<html><body><h2>Hillside's Quantum Automation Report</h2><p><b>The process was {status_text}.</b></p><p><b>Total Patients in File:</b> {len(full_df)}</p><p><b>Processed in this run:</b> {len(results)}</p><p><b>Successful ('Done'):</b> {len([r for r in results if r['Status'] == 'Done'])}</p><p><b>Bad State ('Bad'):</b> {len([r for r in results if r['Status'] == 'Bad'])}</p><p>The full report is in Google Drive and also attached here, along with a list of 'Bad' status patients.</p></body></html>"""
+    body = f"""<html><body><h2>Hillside's Quantum Automation Report</h2><p><b>The process was {status_text}.</b></p><p><b>Total Patients in File:</b> {len(full_df)}</p><p><b>Processed in this run:</b> {len(results)}</p><p><b>Successful ('Done'):</b> {len([r for r in results if r['Status'] == 'Done'])}</p><p><b>Bad State ('Bad'):</b> {len([r for r in results if r['Status'] == 'Bad'])}</p><p>The full report and a list of 'Bad' status patients from this run are attached.</p></body></html>"""
     email_service.send_report(data.get('emails'), subject, body, attachments)
     socketio.emit('process_complete', {'message': f'Process {status_text}. Report sent.'})
 
@@ -129,7 +142,7 @@ def status_page():
 
 @socketio.on('connect')
 def handle_connect():
-    print(f'Frontend connected.')
+    print(f'Frontend connected from: {FRONTEND_ORIGIN}')
     emit('email_list', {'emails': get_email_list()})
 
 @socketio.on('initialize_session')
@@ -138,9 +151,12 @@ def handle_init(data):
     session_data[session_id] = {'csv_content': data['content'], 'emails': data['emails'], 'filename': data['filename']}
     if bot_instance: bot_instance.shutdown()
     bot_instance = QuantumBot(socketio, app)
+
     is_success, error_message = bot_instance.initialize_driver()
-    if is_success: emit('bot_initialized')
-    else: emit('error', {'message': f'Failed to initialize automation bot: {error_message}'})
+    if is_success:
+        emit('bot_initialized')
+    else:
+        emit('error', {'message': f'Failed to initialize automation bot: {error_message}'})
 
 @socketio.on('start_login')
 def handle_login(credentials):
@@ -156,6 +172,7 @@ def handle_otp(data):
     if is_success:
         emit('login_successful')
         session_id = 'user_session'
+        # Fixed syntax for background task
         socketio.start_background_task(run_automation_process, session_id)
     else: emit('error', {'message': f'OTP failed: {error_message}'})
 
@@ -163,26 +180,11 @@ def handle_otp(data):
 def handle_terminate():
     if bot_instance: print("Termination signal received."); bot_instance.stop()
 
-@socketio.on('request_finalization')
-def handle_finalize(data):
-    print("Finalization requested by worker thread.")
-    global bot_instance
-    session_id = data.get('session_id')
-    results = data.get('results', [])
-    is_crash = data.get('is_crash', False)
-    is_terminated = data.get('is_terminated', False)
-    
-    generate_and_send_reports(session_id, results, is_crash_report=is_crash, is_terminated=is_terminated)
-    if bot_instance:
-        bot_instance.shutdown()
-        bot_instance = None
-    if session_id in session_data:
-        del session_data[session_id]
-
 if __name__ == '__main__':
     print("====================================================================")
     print("  🤗 Hillside Automation Backend - HuggingFace Spaces")
     print(f"  Frontend URL: {FRONTEND_ORIGIN}")
     print(f"  Port: {os.getenv('PORT', 7860)}")
     print("====================================================================")
-    socketio.run(app, host='0.0.0.0', port=int(os.getenv('PORT', 7860)))
+    socketio.run(app, host='0.0.0.0', port=int(os.getenv('PORT', 7860)))
+

worker.py

@@ -1,14 +1,15 @@
-import pandas as pd
 import time
-import io
 import threading
+import subprocess
+
 from selenium import webdriver
 from selenium.webdriver.chrome.service import Service as ChromeService
 from selenium.webdriver.chrome.options import Options as ChromeOptions
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
-from selenium.common.exceptions import TimeoutException, NoSuchElementException, ElementNotInteractableException
+from selenium.common.exceptions import TimeoutException
+
 
 class QuantumBot:
     def __init__(self, socketio, app):
@@ -18,26 +19,52 @@ class QuantumBot:
         self.DEFAULT_TIMEOUT = 30
         self.termination_event = threading.Event()
 
+    def _kill_chrome_processes(self):
+        """Kill any existing Chrome processes to prevent conflicts"""
+        try:
+            subprocess.run(['pkill', '-f', 'chrome'], capture_output=True, text=True, timeout=5)
+            subprocess.run(['pkill', '-f', 'chromium'], capture_output=True, text=True, timeout=5)
+            time.sleep(1)
+        except:
+            pass
+
     def initialize_driver(self):
         try:
             self.micro_status("Initializing headless browser...")
+            
+            # Kill any existing Chrome processes first
+            self._kill_chrome_processes()
+            
             options = ChromeOptions()
             options.binary_location = "/usr/bin/chromium"
-            user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
-            options.add_argument(f"user-agent={user_agent}")
+            
+            # DON'T set --user-data-dir - let Chrome handle it automatically
+            # This prevents the "already in use" error
+            
+            # Minimal required flags for HuggingFace Spaces
             options.add_argument("--headless=new")
-            options.add_argument("--window-size=1920,1080")
             options.add_argument("--no-sandbox")
             options.add_argument("--disable-dev-shm-usage")
             options.add_argument("--disable-gpu")
+            options.add_argument("--remote-debugging-port=0")
+            options.add_argument("--window-size=1920,1080")
+            options.add_argument("--no-first-run")
+            options.add_argument("--disable-extensions")
+            
+            # User agent for better compatibility
+            user_agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+            options.add_argument(f"--user-agent={user_agent}")
             
             service = ChromeService(executable_path="/usr/bin/chromedriver")
             self.driver = webdriver.Chrome(service=service, options=options)
             
+            # Anti-detection
             self.driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
                 'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
             })
+            
             return True, None
+            
         except Exception as e:
             error_message = f"Message: {str(e)}"
             print(f"CRITICAL ERROR in WebDriver Initialization: {error_message}")
@@ -58,11 +85,19 @@ class QuantumBot:
             self.driver.get("https://gateway.quantumepay.com/")
             time.sleep(2)
             self.micro_status("Entering credentials...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "Username"))).send_keys(username)
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "Password"))).send_keys(password)
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.presence_of_element_located((By.ID, "Username"))
+            ).send_keys(username)
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.presence_of_element_located((By.ID, "Password"))
+            ).send_keys(password)
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.element_to_be_clickable((By.ID, "login"))
+            ).click()
             self.micro_status("Waiting for OTP screen...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.presence_of_element_located((By.ID, "code1")))
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.presence_of_element_located((By.ID, "code1"))
+            )
             return True, None
         except Exception as e:
             error_message = f"Error during login: {str(e)}"
@@ -75,9 +110,13 @@ class QuantumBot:
             otp_digits = list(otp)
             for i in range(6):
                 self.driver.find_element(By.ID, f"code{i+1}").send_keys(otp_digits[i])
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.ID, "login"))).click()
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.element_to_be_clickable((By.ID, "login"))
+            ).click()
             self.micro_status("Verifying login success...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//span[text()='Payments']")))
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.element_to_be_clickable((By.XPATH, "//span[text()='Payments']"))
+            )
             return True, None
         except Exception as e:
             error_message = f"Error during OTP submission: {str(e)}"
@@ -90,66 +129,91 @@ class QuantumBot:
             if self.termination_event.is_set():
                 print("[Bot] Termination detected. Stopping process.")
                 break
-            
+            with self.app.app_context():
+                self.socketio.emit('stats_update', {
+                    'processed': len(results),
+                    'remaining': len(patient_list) - len(results)
+                })
             self.micro_status(f"Processing '{patient_name}' ({index + 1}/{len(patient_list)})...")
             status = self._process_single_patient(patient_name)
             results.append({'Name': patient_name, 'Status': status})
-            
             with self.app.app_context():
-                bad_count = len([r for r in results if r['Status'] == 'Bad'])
                 self.socketio.emit('log_update', {'name': patient_name, 'status': status})
-                self.socketio.emit('stats_update', {
-                    'processed': len(results),
-                    'remaining': len(patient_list) - len(results),
-                    'bad': bad_count
-                })
         return results
 
     def _process_single_patient(self, patient_name):
         try:
             self.micro_status(f"Navigating to Void page for '{patient_name}'")
             self.driver.get("https://gateway.quantumepay.com/credit-card/void")
-            
+
             search_successful = False
             for attempt in range(15):
                 try:
                     self.micro_status(f"Searching for patient (Attempt {attempt + 1})...")
-                    WebDriverWait(self.driver, 2).until(EC.presence_of_element_located((By.XPATH, "//div[contains(@class, 'table-wrapper')]")))
-                    search_box = WebDriverWait(self.driver, 2).until(EC.element_to_be_clickable((By.XPATH, "//input[@placeholder='Search']")))
+                    WebDriverWait(self.driver, 2).until(
+                        EC.presence_of_element_located((By.XPATH, "//div[contains(@class, 'table-wrapper')]"))
+                    )
+                    search_box = WebDriverWait(self.driver, 2).until(
+                        EC.element_to_be_clickable((By.XPATH, "//input[@placeholder='Search']"))
+                    )
                     search_box.click(); time.sleep(0.5)
                     search_box.clear(); time.sleep(0.5)
                     search_box.send_keys(patient_name)
                     search_successful = True
                     break
-                except Exception: time.sleep(1)
-            if not search_successful: raise Exception("Failed to search for patient.")
-            
+                except Exception:
+                    time.sleep(1)
+
+            if not search_successful:
+                raise Exception("Failed to search for patient.")
+
             time.sleep(3)
             self.micro_status("Opening transaction details...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, f"//tr[contains(., \"{patient_name}\")]//button[@data-v-b6b33fa0]"))).click()
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.LINK_TEXT, "Transaction Detail"))).click()
-            
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.element_to_be_clickable((By.XPATH, f"//tr[contains(., \"{patient_name}\")]//button[@data-v-b6b33fa0]"))
+            ).click()
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.element_to_be_clickable((By.LINK_TEXT, "Transaction Detail"))
+            ).click()
+
             self.micro_status("Adding to Vault...")
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Add to Vault']"))).click()
-            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//div[@class='modal-footer']//button/span[normalize-space()='Confirm']"))).click()
-            
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Add to Vault']"))
+            ).click()
+            WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                EC.element_to_be_clickable((By.XPATH, "//div[@class='modal-footer']//button/span[normalize-space()='Confirm']"))
+            ).click()
+
             try:
                 self.micro_status("Verifying success and saving...")
-                company_input = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable((By.NAME, "company_name")))
+                company_input = WebDriverWait(self.driver, 10).until(
+                    EC.element_to_be_clickable((By.NAME, "company_name"))
+                )
                 company_input.clear()
                 company_input.send_keys(patient_name)
-                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Save Changes']"))).click()
-                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))).click()
+                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button/span[normalize-space()='Save Changes']"))
+                ).click()
+                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Confirm']]"))
+                ).click()
                 time.sleep(5)
                 return 'Done'
             except TimeoutException:
                 self.micro_status(f"'{patient_name}' is in a bad state, cancelling.")
-                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))).click()
+                WebDriverWait(self.driver, self.DEFAULT_TIMEOUT).until(
+                    EC.element_to_be_clickable((By.XPATH, "//button[.//span[normalize-space()='Cancel']]"))
+                ).click()
                 return 'Bad'
         except Exception as e:
             print(f"An error occurred while processing {patient_name}: {e}")
             return 'Error'
-            
+
     def shutdown(self):
-        if self.driver:
-            self.driver.quit()
+        try:
+            if self.driver:
+                self.driver.quit()
+            self._kill_chrome_processes()
+            print("[Bot] Chrome session closed and cleaned up.")
+        except Exception as e:
+            print(f"[Bot] Error during shutdown: {e}")