Update app.py

app.py

@@ -7,9 +7,8 @@ from PIL import Image
 import io
 import logging
 import traceback
+import random
 from pathlib import Path
-import threading
-import queue
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -18,10 +17,6 @@ logger = logging.getLogger(__name__)
 # Create screenshots directory if it doesn't exist
 os.makedirs('screenshots', exist_ok=True)
 
-# Global queues for real-time updates
-status_queue = queue.Queue()
-image_queue = queue.Queue()
-
 def download_playwright_browsers():
     """Make sure Playwright and its browsers are installed properly"""
     try:
@@ -84,76 +79,38 @@ def verify_playwright_installation():
     logger.warning("Playwright browser not found in expected locations")
     return False
 
-def update_ui(status_text, image_path=None):
-    """Add updates to queue for real-time UI updates"""
-    status_queue.put(status_text)
-    if image_path:
-        image_queue.put(image_path)
-
-def run_instagram_liker_thread(username, password, max_likes):
-    """Thread function to run the Instagram auto-liker to allow real-time updates"""
-    result = run_instagram_liker(username, password, max_likes)
-    # Put final results in queue
-    status_queue.put(None)  # Signal completion
-    image_queue.put(None)  # Signal completion
-    return result
-
 def run_instagram_liker(username, password, max_likes):
     """Run the Instagram auto-liker with Playwright"""
-    all_status_updates = ["Starting Instagram Auto-Liker with Playwright..."]
-    update_ui(all_status_updates[-1])
-    
+    status_updates = ["Starting Instagram Auto-Liker with Playwright..."]
     image_path = save_placeholder_image("start")
-    update_ui(None, image_path)
-    
-    # Track all screenshots for gallery view
-    all_screenshots = [image_path]
     
     # Check if browsers are installed, if not install them
     try:
-        status_text = "Verifying Playwright installation..."
-        all_status_updates.append(status_text)
-        update_ui(status_text)
+        status_updates.append("Verifying Playwright installation...")
         
         # First try to import
         try:
             from playwright.sync_api import sync_playwright
         except ImportError:
-            status_text = "Playwright not installed. Installing now..."
-            all_status_updates.append(status_text)
-            update_ui(status_text)
-            
+            status_updates.append("Playwright not installed. Installing now...")
             download_playwright_browsers()
-            
-            status_text = "Playwright installation completed."
-            all_status_updates.append(status_text)
-            update_ui(status_text)
+            status_updates.append("Playwright installation completed.")
 
         # Then verify browser binary exists
         if not verify_playwright_installation():
-            status_text = "Browser binary not found. Installing browsers..."
-            all_status_updates.append(status_text)
-            update_ui(status_text)
-            
+            status_updates.append("Browser binary not found. Installing browsers...")
             download_playwright_browsers()
             
             # Double check installation worked
             if not verify_playwright_installation():
-                status_text = "Failed to install browser binary. Please try running the script again."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                return "\n".join(all_status_updates), image_path, all_screenshots
+                status_updates.append("Failed to install browser binary. Please try running the script again.")
+                return "\n".join(status_updates), image_path
         
-        status_text = "Playwright installation verified."
-        all_status_updates.append(status_text)
-        update_ui(status_text)
+        status_updates.append("Playwright installation verified.")
             
         from playwright.sync_api import sync_playwright
         
-        status_text = "Launching Playwright browser..."
-        all_status_updates.append(status_text)
-        update_ui(status_text)
-        
+        status_updates.append("Launching Playwright browser...")
         with sync_playwright() as p:
             try:
                 # Launch chromium with specific arguments to ensure it works in containerized environments
@@ -178,36 +135,21 @@ def run_instagram_liker(username, password, max_likes):
                 page = context.new_page()
                 
                 # Test browser by visiting Google
-                status_text = "Testing browser connection..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                
+                status_updates.append("Testing browser connection...")
                 page.goto("https://www.google.com")
-                
-                status_text = f"Browser working. Title: {page.title()}"
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append(f"Browser working. Title: {page.title()}")
                 
                 # Take a screenshot
                 try:
                     test_screenshot = f"screenshots/test_pw_{int(time.time())}.png"
                     page.screenshot(path=test_screenshot)
                     image_path = test_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Browser screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Browser screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
                 # Navigate to Instagram
-                status_text = "Navigating to Instagram..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                
+                status_updates.append("Navigating to Instagram...")
                 page.goto("https://www.instagram.com/")
                 page.wait_for_load_state('networkidle')
                 
@@ -216,21 +158,12 @@ def run_instagram_liker(username, password, max_likes):
                     landing_screenshot = f"screenshots/landing_pw_{int(time.time())}.png"
                     page.screenshot(path=landing_screenshot)
                     image_path = landing_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Instagram page loaded, screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Instagram page loaded, screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
                 # Introduce delay to let the page fully load
-                status_text = "Waiting for page to fully load..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                
+                status_updates.append("Waiting for page to fully load...")
                 page.wait_for_timeout(5000)
                 
                 # Take another screenshot after waiting
@@ -238,26 +171,16 @@ def run_instagram_liker(username, password, max_likes):
                     loaded_screenshot = f"screenshots/fully_loaded_{int(time.time())}.png"
                     page.screenshot(path=loaded_screenshot)
                     image_path = loaded_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Page fully loaded, screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Page fully loaded, screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
                 # Try clicking outside any potential popups
                 try:
                     page.mouse.click(10, 10)
-                    status_text = "Clicked to dismiss any initial popups"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append("Clicked to dismiss any initial popups")
                 except Exception as e:
-                    status_text = f"Click error: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Click error: {str(e)}")
                 
                 # Handle cookie dialog if present
                 try:
@@ -273,38 +196,26 @@ def run_instagram_liker(username, password, max_likes):
                         try:
                             if page.query_selector(button_selector):
                                 page.click(button_selector)
-                                status_text = f"Clicked cookie consent button: {button_selector}"
-                                all_status_updates.append(status_text)
-                                update_ui(status_text)
+                                status_updates.append(f"Clicked cookie consent button: {button_selector}")
                                 page.wait_for_timeout(2000)
                                 break
                         except Exception as e:
                             logger.debug(f"Button {button_selector} not found: {str(e)}")
                             continue
                 except Exception as e:
-                    status_text = f"Cookie dialog handling: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Cookie dialog handling: {str(e)}")
                 
                 # Look for the login form
-                status_text = "Looking for login form..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append("Looking for login form...")
                 
                 # Take a screenshot to see what we're working with
                 try:
                     form_screenshot = f"screenshots/login_form_{int(time.time())}.png"
                     page.screenshot(path=form_screenshot)
                     image_path = form_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Login form screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Login form screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
                 # Try multiple selectors for username input
                 username_selectors = [
@@ -318,35 +229,23 @@ def run_instagram_liker(username, password, max_likes):
                 username_field = None
                 for selector in username_selectors:
                     try:
-                        status_text = f"Trying to find username field with selector: {selector}"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
-                        
+                        status_updates.append(f"Trying to find username field with selector: {selector}")
                         field = page.query_selector(selector)
                         if field:
                             username_field = field
-                            
-                            status_text = f"Found username field with selector: {selector}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append(f"Found username field with selector: {selector}")
                             break
                     except Exception as e:
                         logger.debug(f"Selector {selector} failed: {str(e)}")
                 
                 if not username_field:
-                    status_text = "Could not find username field. Instagram may have changed their interface."
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
-                    
+                    status_updates.append("Could not find username field. Instagram may have changed their interface.")
                     # Take final screenshot before closing
                     final_screenshot = f"screenshots/final_error_{int(time.time())}.png"
                     page.screenshot(path=final_screenshot)
                     image_path = final_screenshot
-                    all_screenshots.append(image_path)
-                    update_ui(None, image_path)
-                    
                     browser.close()
-                    return "\n".join(all_status_updates), image_path, all_screenshots
+                    return "\n".join(status_updates), image_path
                 
                 # Try multiple selectors for password input
                 password_selectors = [
@@ -359,62 +258,38 @@ def run_instagram_liker(username, password, max_likes):
                 password_field = None
                 for selector in password_selectors:
                     try:
-                        status_text = f"Trying to find password field with selector: {selector}"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
-                        
+                        status_updates.append(f"Trying to find password field with selector: {selector}")
                         field = page.query_selector(selector)
                         if field:
                             password_field = field
-                            
-                            status_text = f"Found password field with selector: {selector}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append(f"Found password field with selector: {selector}")
                             break
                     except Exception as e:
                         logger.debug(f"Selector {selector} failed: {str(e)}")
                 
                 if not password_field:
-                    status_text = "Could not find password field. Instagram may have changed their interface."
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
-                    
+                    status_updates.append("Could not find password field. Instagram may have changed their interface.")
                     # Take final screenshot before closing
                     final_screenshot = f"screenshots/final_error_{int(time.time())}.png"
                     page.screenshot(path=final_screenshot)
                     image_path = final_screenshot
-                    all_screenshots.append(image_path)
-                    update_ui(None, image_path)
-                    
                     browser.close()
-                    return "\n".join(all_status_updates), image_path, all_screenshots
+                    return "\n".join(status_updates), image_path
                 
                 # Enter credentials
-                status_text = f"Entering username: {username}"
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                
+                status_updates.append(f"Entering username: {username}")
                 username_field.fill(username)
                 password_field.fill(password)
-                
-                status_text = "Credentials entered"
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append("Credentials entered")
                 
                 # Take a screenshot of filled form
                 try:
                     creds_screenshot = f"screenshots/credentials_pw_{int(time.time())}.png"
                     page.screenshot(path=creds_screenshot)
                     image_path = creds_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Credentials screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Credentials screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
                 # Find login button
                 login_button_selectors = [
@@ -428,48 +303,30 @@ def run_instagram_liker(username, password, max_likes):
                 login_button = None
                 for selector in login_button_selectors:
                     try:
-                        status_text = f"Trying to find login button with selector: {selector}"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
-                        
+                        status_updates.append(f"Trying to find login button with selector: {selector}")
                         button = page.query_selector(selector)
                         if button:
                             login_button = button
-                            
-                            status_text = f"Found login button with selector: {selector}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append(f"Found login button with selector: {selector}")
                             break
                     except Exception as e:
                         logger.debug(f"Selector {selector} failed: {str(e)}")
                 
                 if not login_button:
-                    status_text = "Could not find login button. Instagram may have changed their interface."
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
-                    
+                    status_updates.append("Could not find login button. Instagram may have changed their interface.")
                     # Take final screenshot before closing
                     final_screenshot = f"screenshots/final_error_{int(time.time())}.png"
                     page.screenshot(path=final_screenshot)
                     image_path = final_screenshot
-                    all_screenshots.append(image_path)
-                    update_ui(None, image_path)
-                    
                     browser.close()
-                    return "\n".join(all_status_updates), image_path, all_screenshots
+                    return "\n".join(status_updates), image_path
                 
                 # Click login button
-                status_text = "Clicking login button..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                
+                status_updates.append("Clicking login button...")
                 login_button.click()
                 
                 # Wait for navigation to complete
-                status_text = "Waiting for login process..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                
+                status_updates.append("Waiting for login process...")
                 page.wait_for_timeout(5000)
                 
                 # Take post-login screenshot
@@ -477,15 +334,9 @@ def run_instagram_liker(username, password, max_likes):
                     post_login_screenshot = f"screenshots/post_login_pw_{int(time.time())}.png"
                     page.screenshot(path=post_login_screenshot)
                     image_path = post_login_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Post-login screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Post-login screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
                 # Check if login was successful
                 current_url = page.url
@@ -510,20 +361,14 @@ def run_instagram_liker(username, password, max_likes):
                             pass
                     
                     if error_message:
-                        status_text = f"Login failed: {error_message}"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
+                        status_updates.append(f"Login failed: {error_message}")
                     else:
-                        status_text = "Login failed: Reason unknown. Check your credentials."
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
+                        status_updates.append("Login failed: Reason unknown. Check your credentials.")
                     
                     browser.close()
-                    return "\n".join(all_status_updates), image_path, all_screenshots
+                    return "\n".join(status_updates), image_path
                 
-                status_text = "Login successful! Now handling post-login dialogs..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append("Login successful! Now handling post-login dialogs...")
                 
                 # Handle "Save Login Info" popup if it appears
                 try:
@@ -546,20 +391,10 @@ def run_instagram_liker(username, password, max_likes):
                     for selector in save_info_selectors:
                         if page.query_selector(selector):
                             dialog_found = True
-                            
-                            status_text = f"Save Login Info dialog found with: {selector}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append(f"Save Login Info dialog found with: {selector}")
                             break
                     
                     if dialog_found:
-                        # Take screenshot of dialog
-                        dialog_screenshot = f"screenshots/save_info_dialog_{int(time.time())}.png"
-                        page.screenshot(path=dialog_screenshot)
-                        image_path = dialog_screenshot
-                        all_screenshots.append(image_path)
-                        update_ui(None, image_path)
-                        
                         # Try to click "Not Now"
                         dismissed = False
                         for not_now in not_now_selectors:
@@ -567,11 +402,7 @@ def run_instagram_liker(username, password, max_likes):
                                 button = page.query_selector(not_now)
                                 if button:
                                     button.click()
-                                    
-                                    status_text = f"Dismissed 'Save Login Info' popup using: {not_now}"
-                                    all_status_updates.append(status_text)
-                                    update_ui(status_text)
-                                    
+                                    status_updates.append(f"Dismissed 'Save Login Info' popup using: {not_now}")
                                     page.wait_for_timeout(2000)
                                     dismissed = True
                                     break
@@ -580,32 +411,20 @@ def run_instagram_liker(username, password, max_likes):
                                 continue
                         
                         if not dismissed:
-                            status_text = "Found Save Login dialog but couldn't dismiss it"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append("Found Save Login dialog but couldn't dismiss it")
                     else:
-                        status_text = "No 'Save Login Info' popup detected"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
+                        status_updates.append("No 'Save Login Info' popup detected")
                 except Exception as e:
-                    status_text = f"Error handling Save Login dialog: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error handling Save Login dialog: {str(e)}")
                 
                 # Take a screenshot after handling first dialog
                 try:
                     after_save_screenshot = f"screenshots/after_save_dialog_{int(time.time())}.png"
                     page.screenshot(path=after_save_screenshot)
                     image_path = after_save_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Screenshot after Save Info dialog"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Screenshot after Save Info dialog")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
                 # Handle notifications popup if it appears
                 try:
@@ -628,20 +447,10 @@ def run_instagram_liker(username, password, max_likes):
                     for selector in notifications_selectors:
                         if page.query_selector(selector):
                             dialog_found = True
-                            
-                            status_text = f"Notifications dialog found with: {selector}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append(f"Notifications dialog found with: {selector}")
                             break
                     
                     if dialog_found:
-                        # Take screenshot of dialog
-                        notif_screenshot = f"screenshots/notifications_dialog_{int(time.time())}.png"
-                        page.screenshot(path=notif_screenshot)
-                        image_path = notif_screenshot
-                        all_screenshots.append(image_path)
-                        update_ui(None, image_path)
-                        
                         # Try to click "Not Now"
                         dismissed = False
                         for not_now in not_now_selectors:
@@ -649,11 +458,7 @@ def run_instagram_liker(username, password, max_likes):
                                 button = page.query_selector(not_now)
                                 if button:
                                     button.click()
-                                    
-                                    status_text = f"Dismissed notifications popup using: {not_now}"
-                                    all_status_updates.append(status_text)
-                                    update_ui(status_text)
-                                    
+                                    status_updates.append(f"Dismissed notifications popup using: {not_now}")
                                     page.wait_for_timeout(2000)
                                     dismissed = True
                                     break
@@ -662,47 +467,34 @@ def run_instagram_liker(username, password, max_likes):
                                 continue
                         
                         if not dismissed:
-                            status_text = "Found Notifications dialog but couldn't dismiss it"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append("Found Notifications dialog but couldn't dismiss it")
                     else:
-                        status_text = "No notifications popup detected"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
+                        status_updates.append("No notifications popup detected")
                 except Exception as e:
-                    status_text = f"Error handling Notifications dialog: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error handling Notifications dialog: {str(e)}")
                 
                 # Take feed screenshot
                 try:
                     feed_screenshot = f"screenshots/feed_pw_{int(time.time())}.png"
                     page.screenshot(path=feed_screenshot)
                     image_path = feed_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Feed screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Feed screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking screenshot: {str(e)}")
                 
-                status_text = "Successfully navigated to Instagram feed!"
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append("Successfully navigated to Instagram feed!")
                 
                 # Start liking posts
-                status_text = f"Starting to like posts (target: {max_likes})..."
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append(f"Starting to like posts (target: {max_likes})...")
                 
                 # Like posts
                 likes_count = 0
                 scroll_count = 0
                 max_scrolls = 30
                 
+                # Wait for the feed to load fully before looking for posts
+                page.wait_for_timeout(3000)
+                
                 # Try to find posts with multiple selectors
                 article_selectors = [
                     "article", 
@@ -717,299 +509,171 @@ def run_instagram_liker(username, password, max_likes):
                     try:
                         if page.query_selector(selector):
                             article_found = True
-                            
-                            status_text = f"Found posts using selector: {selector}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
+                            status_updates.append(f"Found posts using selector: {selector}")
                             break
                     except Exception as e:
                         logger.debug(f"Article selector {selector} failed: {str(e)}")
                 
                 if not article_found:
-                    status_text = "Could not find posts on feed. Instagram may have changed their interface."
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
-                    
+                    status_updates.append("Could not find posts on feed. Instagram may have changed their interface.")
                     browser.close()
-                    return "\n".join(all_status_updates), image_path, all_screenshots
+                    return "\n".join(status_updates), image_path
                 
-                # ============= FIXED LIKE BUTTON INTERACTION =============
+                # Like one post at a time with full scroll stabilization
                 while likes_count < max_likes and scroll_count < max_scrolls:
-                    # Take screenshot of current view
                     try:
-                        current_view = f"screenshots/scroll_{scroll_count}_{int(time.time())}.png"
-                        page.screenshot(path=current_view)
-                        image_path = current_view
-                        all_screenshots.append(image_path)
-                        update_ui(None, image_path)
-                    except Exception as e:
-                        status_text = f"Error taking screenshot: {str(e)}"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
-                    
-                    # Try different selectors for like buttons
-                    like_button_selectors = [
-                        "article svg[aria-label='Like']", # Main selector
-                        "section svg[aria-label='Like']",
-                        "span[role='button'] svg[aria-label='Like']",
-                        "div[role='button'] svg[aria-label='Like']"
-                    ]
-                    
-                    # Get all like buttons in the current view
-                    all_like_buttons = []
-                    used_selector = ""
-                    
-                    for selector in like_button_selectors:
-                        try:
-                            buttons = page.query_selector_all(selector)
-                            if buttons and len(buttons) > 0:
-                                all_like_buttons = buttons
-                                used_selector = selector
-                                
-                                status_text = f"Found {len(buttons)} like buttons with selector: {selector}"
-                                all_status_updates.append(status_text)
-                                update_ui(status_text)
-                                break
-                        except Exception as e:
-                            logger.debug(f"Like button selector {selector} failed: {str(e)}")
-                    
-                    status_text = f"Found {len(all_like_buttons)} like buttons on scroll {scroll_count}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
-                    
-                    if len(all_like_buttons) == 0 and scroll_count > 5:
-                        status_text = "No more like buttons found. Stopping."
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
-                        break
-                    
-                    # Process each like button - NEW IMPROVED METHOD
-                    for i, button in enumerate(all_like_buttons):
-                        if likes_count >= max_likes:
-                            break
+                        # Take a screenshot before each scroll to aid debugging
+                        if scroll_count % 5 == 0:
+                            try:
+                                scroll_screenshot = f"screenshots/scroll_{scroll_count}_{int(time.time())}.png"
+                                page.screenshot(path=scroll_screenshot)
+                                image_path = scroll_screenshot
+                            except Exception as e:
+                                status_updates.append(f"Error taking scroll screenshot: {str(e)}")
                         
-                        try:
-                            # FIRST - Take a screenshot BEFORE interacting
-                            pre_like_screenshot = f"screenshots/pre_like_{likes_count+1}_{int(time.time())}.png"
-                            page.screenshot(path=pre_like_screenshot)
-                            all_screenshots.append(pre_like_screenshot)
-                            
-                            status_text = f"Pre-like screenshot for post {i+1}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text, pre_like_screenshot)
+                        # Wait for the page to be stable after scrolling
+                        page.wait_for_timeout(2000)
+                        
+                        # IMPORTANT FIX: Evaluate the selector directly in the page context to get fresh elements
+                        # This addresses the "Element is not attached to the DOM" issue
+                        like_buttons = page.evaluate("""() => {
+                            // Try different selectors to find like buttons that haven't been clicked yet
+                            const selectors = [
+                                "article section svg[aria-label='Like']",
+                                "article svg[aria-label='Like']",
+                                "svg[aria-label='Like']",
+                                "span[class*='_aamw'] svg[aria-label='Like']",
+                                "article button[type='button'] svg:not([aria-label='Unlike'])"
+                            ];
                             
-                            # IMPORTANT: Use evaluate to find the closest article
-                            # This helps ensure we're working with the stable post container
-                            article = button.evaluate("""(node) => {
-                                // Find parent article or post container
-                                let current = node;
-                                while (current && current.tagName !== 'ARTICLE' && 
-                                       !current.getAttribute('role')?.includes('presentation')) {
-                                    current = current.parentElement;
-                                    // Safety check - don't go too far up
-                                    if (current.tagName === 'BODY') return null;
+                            for (const selector of selectors) {
+                                const buttons = Array.from(document.querySelectorAll(selector));
+                                if (buttons.length > 0) {
+                                    // We need to find the actual button elements (parents of the SVGs)
+                                    const buttonElements = buttons.map(svg => {
+                                        // Find closest button parent
+                                        return svg.closest('button');
+                                    }).filter(btn => btn !== null);
+                                    
+                                    if (buttonElements.length > 0) {
+                                        // Return info about the first valid button
+                                        const button = buttonElements[0];
+                                        const rect = button.getBoundingClientRect();
+                                        
+                                        return {
+                                            found: true,
+                                            count: buttonElements.length,
+                                            x: rect.x + rect.width / 2,
+                                            y: rect.y + rect.height / 2
+                                        };
+                                    }
                                 }
-                                return current;
-                            }""")
+                            }
                             
-                            if not article:
-                                status_text = f"Couldn't find parent article for button {i+1}, skipping"
-                                all_status_updates.append(status_text)
-                                update_ui(status_text)
-                                continue
-                            
-                            # Scroll the article into view - critical for stability
-                            page.evaluate("""(article) => {
-                                article.scrollIntoView({
-                                    behavior: 'smooth',
-                                    block: 'center',
-                                    inline: 'center'
-                                });
-                            }""", article)
-                            
-                            # Wait for scroll to complete
-                            page.wait_for_timeout(1000)
-                            
-                            # FIND THE LIKE BUTTON AGAIN after scrolling - very important
-                            # This ensures we're working with an attached element
-                            like_button = article.query_selector(used_selector)
+                            return { found: false, count: 0 };
+                        }""")
+                        
+                        if like_buttons['found']:
+                            status_updates.append(f"Found {like_buttons['count']} like buttons on scroll {scroll_count}")
                             
-                            if not like_button:
-                                status_text = f"Like button disappeared after scrolling for post {i+1}, trying alternatives"
-                                all_status_updates.append(status_text)
-                                update_ui(status_text)
+                            # Click the first like button directly by coordinates
+                            try:
+                                # Take pre-click screenshot
+                                try:
+                                    pre_like_screenshot = f"screenshots/pre_like_{likes_count}_{int(time.time())}.png"
+                                    page.screenshot(path=pre_like_screenshot)
+                                except Exception as e:
+                                    status_updates.append(f"Error taking pre-like screenshot: {str(e)}")
                                 
-                                # Try alternative selectors within this specific article
-                                for alt_selector in like_button_selectors:
-                                    like_button = article.query_selector(alt_selector)
-                                    if like_button:
-                                        status_text = f"Found alternative like button with {alt_selector}"
-                                        all_status_updates.append(status_text)
-                                        update_ui(status_text)
-                                        break
-                            
-                            if not like_button:
-                                status_text = f"Could not find like button for post {i+1} after scrolling, skipping"
-                                all_status_updates.append(status_text)
-                                update_ui(status_text)
-                                continue
-                            
-                            # Take one more screenshot right before clicking
-                            ready_screenshot = f"screenshots/ready_to_like_{likes_count+1}_{int(time.time())}.png"
-                            page.screenshot(path=ready_screenshot)
-                            all_screenshots.append(ready_screenshot)
-                            
-                            # IMPORTANT: Find the actual clickable button element
-                            # SVG itself is not clickable, need to find parent button
-                            clickable = like_button.evaluate("""(node) => {
-                                // If already a button, use it
-                                if (node.tagName === 'BUTTON') return node;
+                                # Click by coordinates rather than on the element
+                                page.mouse.click(like_buttons['x'], like_buttons['y'])
                                 
-                                // Otherwise find closest button parent
-                                let current = node;
-                                while (current && current.tagName !== 'BUTTON') {
-                                    current = current.parentElement;
-                                    // Safety check
-                                    if (!current || current.tagName === 'BODY') return null;
-                                }
-                                return current;
-                            }""")
-                            
-                            if not clickable:
-                                status_text = f"Couldn't find clickable button for post {i+1}, trying direct click"
-                                all_status_updates.append(status_text)
-                                update_ui(status_text)
+                                likes_count += 1
+                                status_updates.append(f"Liked post {likes_count}/{max_likes}")
                                 
-                                # Try clicking the SVG directly as fallback
-                                like_button.click(force=True)
-                            else:
-                                # Click the proper button
-                                clickable.click()
-                            
-                            # Wait for the like action to register
-                            page.wait_for_timeout(1000)
-                            
-                            # Take screenshot AFTER clicking like
-                            post_like_screenshot = f"screenshots/liked_{likes_count+1}_{int(time.time())}.png"
-                            page.screenshot(path=post_like_screenshot)
-                            all_screenshots.append(post_like_screenshot)
-                            
-                            likes_count += 1
-                            status_text = f"Liked post {likes_count}/{max_likes} ✓"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text, post_like_screenshot)
-                            
-                            # Randomize delay between likes to appear more natural
-                            wait_time = 2000 + (likes_count % 5) * 500  # Between 2-4.5 seconds
-                            page.wait_for_timeout(wait_time)
-                            
-                        except Exception as e:
-                            status_text = f"Error liking post {i+1}: {str(e)}"
-                            all_status_updates.append(status_text)
-                            update_ui(status_text)
-                            
-                            # Take error screenshot
-                            try:
-                                error_screenshot = f"screenshots/error_like_{int(time.time())}.png"
-                                page.screenshot(path=error_screenshot)
-                                all_screenshots.append(error_screenshot)
-                                update_ui(None, error_screenshot)
-                            except:
-                                pass
-                            
-                            continue
-                    
-                    # If we've reached our target, break out
-                    if likes_count >= max_likes:
-                        break
-                    
-                    # If we haven't found any like buttons or couldn't like any posts, scroll down
-                    status_text = "Scrolling down to load more posts..."
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
-                    
-                    # IMPROVED SCROLLING: Find the last post and scroll to it
-                    try:
-                        page.evaluate("""() => {
-                            // Scroll smoothly to improve content loading
-                            window.scrollBy({
-                                top: 800,
-                                behavior: 'smooth'
-                            });
-                        }""")
+                                # Take post-click screenshot
+                                try:
+                                    post_like_screenshot = f"screenshots/post_like_{likes_count}_{int(time.time())}.png"
+                                    page.screenshot(path=post_like_screenshot)
+                                    image_path = post_like_screenshot
+                                except Exception as e:
+                                    status_updates.append(f"Error taking post-like screenshot: {str(e)}")
+                                
+                                # Add a random delay between likes (2-4 seconds)
+                                delay = 2000 + random.randint(0, 2000)
+                                page.wait_for_timeout(delay)
+                                
+                            except Exception as e:
+                                status_updates.append(f"Error clicking like button: {str(e)}")
+                        else:
+                            status_updates.append(f"No like buttons found on scroll {scroll_count}")
+                        
+                        # Scroll down to load more
+                        # Use a smaller scroll distance to ensure we don't miss posts
+                        page.evaluate("window.scrollBy(0, 500);")
+                        status_updates.append("Scrolled down to load more posts")
+                        
+                        # Wait for new content to load
+                        page.wait_for_load_state('networkidle', timeout=5000)
+                        
+                        # Variable delay after scrolling (2-3 seconds)
+                        delay = 2000 + random.randint(0, 1000)
+                        page.wait_for_timeout(delay)
                         
-                        # Wait longer for content to load
-                        page.wait_for_timeout(3000)
+                        scroll_count += 1
                         
-                        status_text = f"Scrolled down to load more posts (scroll {scroll_count + 1})"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
                     except Exception as e:
-                        status_text = f"Error scrolling: {str(e)}"
-                        all_status_updates.append(status_text)
-                        update_ui(status_text)
-                    
-                    scroll_count += 1
+                        status_updates.append(f"Error during scroll/like cycle: {str(e)}")
+                        # Take error screenshot
+                        try:
+                            error_screenshot = f"screenshots/error_{int(time.time())}.png"
+                            page.screenshot(path=error_screenshot)
+                            image_path = error_screenshot
+                        except:
+                            pass
+                        
+                        # Continue to the next scroll despite errors
+                        scroll_count += 1
                 
-                # Final status message
+                # Final status
                 final_message = f"Finished! Liked {likes_count} posts."
-                all_status_updates.append(final_message)
-                update_ui(final_message)
+                status_updates.append(final_message)
                 
                 # Final screenshot
                 try:
                     final_screenshot = f"screenshots/final_{int(time.time())}.png"
                     page.screenshot(path=final_screenshot)
                     image_path = final_screenshot
-                    all_screenshots.append(image_path)
-                    
-                    status_text = "Final screenshot saved"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text, image_path)
+                    status_updates.append("Final screenshot saved")
                 except Exception as e:
-                    status_text = f"Error taking final screenshot: {str(e)}"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append(f"Error taking final screenshot: {str(e)}")
                 
                 # Close the browser
                 browser.close()
-                
-                status_text = "Browser closed"
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append("Browser closed")
                 
             except Exception as e:
-                status_text = f"Error during browser interaction: {str(e)}"
-                all_status_updates.append(status_text)
-                update_ui(status_text)
-                
+                status_updates.append(f"Error during browser interaction: {str(e)}")
                 traceback_msg = traceback.format_exc()
                 logger.error(traceback_msg)
-                
-                status_text = "See logs for detailed error information"
-                all_status_updates.append(status_text)
-                update_ui(status_text)
+                status_updates.append("See logs for detailed error information")
                 
                 # Try to close browser in case of error
                 try:
                     browser.close()
-                    status_text = "Browser closed after error"
-                    all_status_updates.append(status_text)
-                    update_ui(status_text)
+                    status_updates.append("Browser closed after error")
                 except:
                     pass
         
     except Exception as e:
         error_message = f"Error with Playwright: {str(e)}"
         logger.error(error_message)
-        all_status_updates.append(error_message)
-        update_ui(error_message)
-        
+        status_updates.append(error_message)
         logger.error(traceback.format_exc())
     
-    return "\n".join(all_status_updates), image_path, all_screenshots
+    return "\n".join(status_updates), image_path
 
-# Gradio Interface with real-time updates
+# Gradio Interface
 def create_interface():
     with gr.Blocks(title="Instagram Auto-Liker") as app:
         gr.Markdown("# Instagram Auto-Liker (Playwright)")
@@ -1029,85 +693,12 @@ def create_interface():
             
             with gr.Column(scale=2):
                 status_output = gr.Textbox(label="Status Log", lines=15)
-                
-                # Gallery view of all screenshots
-                with gr.Row():
-                    # Main current image
-                    image_output = gr.Image(label="Current Screenshot", type="filepath")
-                
-                # Add gallery for all screenshots
-                gallery = gr.Gallery(label="All Screenshots", show_label=True, elem_id="screenshot_gallery")
-                
-        # Function to handle real-time updates
-        def process_updates(username, password, max_likes):
-            # Clear status queue
-            while not status_queue.empty():
-                try:
-                    status_queue.get_nowait()
-                except:
-                    pass
-            
-            # Clear image queue
-            while not image_queue.empty():
-                try:
-                    image_queue.get_nowait()
-                except:
-                    pass
-            
-            # Start worker thread
-            thread = threading.Thread(
-                target=run_instagram_liker_thread,
-                args=(username, password, max_likes)
-            )
-            thread.daemon = True
-            thread.start()
-            
-            # Initial values
-            status_text = "Starting Instagram Auto-Liker..."
-            image_path = None
-            all_images = []
-            
-            # Function to update UI in real-time
-            def get_updates():
-                nonlocal status_text, image_path, all_images
-                
-                # Check for new status updates
-                try:
-                    while not status_queue.empty():
-                        new_status = status_queue.get_nowait()
-                        if new_status is None:  # End signal
-                            return None, image_path, all_images
-                        status_text += "\n" + new_status
-                except:
-                    pass
-                
-                # Check for new images
-                try:
-                    while not image_queue.empty():
-                        new_image = image_queue.get_nowait()
-                        if new_image is None:  # End signal
-                            return status_text, image_path, all_images
-                        image_path = new_image
-                        if new_image not in all_images:
-                            all_images.append(new_image)
-                except:
-                    pass
-                
-                return status_text, image_path, all_images
-            
-            return get_updates
+                image_output = gr.Image(label="Latest Screenshot", type="filepath")
         
-        # Connect the button to start processing
         submit_btn.click(
-            fn=process_updates,
+            fn=run_instagram_liker,
             inputs=[username, password, max_likes],
-            outputs=[status_output, image_output, gallery],
-            queue=False,
-        ).then(
-            lambda: gr.Textbox(interactive=False),
-            None,
-            [status_output],
-            queue=False,
+            outputs=[status_output, image_output]
         )
     
     return app