Update app.py

app.py

@@ -4,13 +4,13 @@ import threading
 import time
 import random
 from datetime import datetime
-
+from concurrent.futures import ThreadPoolExecutor, as_completed
 # ==============================================================================
 # ⚙️ CONFIGURATION
 # ==============================================================================
-TARGET_COUNT = 10         # We want exactly 10 working proxies
+TARGET_COUNT = 80         # We want exactly 10 working proxies
 TIMEOUT_SEC = 5           # Reject if slower than 5 seconds
-CHECK_INTERVAL = 300      # Re-check every 5 minutes (300 seconds)
+CHECK_INTERVAL = 120      # Re-check every 5 minutes (300 seconds)
 
 # Shared Memory (The "Live File")
 proxy_storage = {
@@ -22,33 +22,38 @@ proxy_storage = {
 # 🕵️‍♂️ PROXY WORKER (Background Thread)
 # ==============================================================================
 def check_proxy(ip):
-    """Returns True if proxy connects to YouTube in < 5 seconds."""
+    """Returns the IP if valid, else None."""
     proxies = {"http": f"http://{ip}", "https": f"http://{ip}"}
     try:
-        # We test against YouTube specifically because that's our target
         r = requests.get("https://www.youtube.com", proxies=proxies, timeout=TIMEOUT_SEC)
         if r.status_code == 200:
-            return True
+            return ip
     except:
-        return False
-    return False
+        pass
+    return None
 
 def worker_loop():
     while True:
-        print(f"\n[{datetime.now().strftime('%H:%M')}] ♻️ Starting Validation Cycle...")
+        print(f"\n[{datetime.now().strftime('%H:%M:%S')}] ♻️ Starting High-Speed Validation...")
         
-        # 1. RE-VALIDATE EXISTING (Keep the good ones)
+        # 1. RE-VALIDATE EXISTING (In Parallel)
         current_list = proxy_storage["valid_proxies"]
         still_good = []
-        for ip in current_list:
-            if check_proxy(ip):
-                still_good.append(ip)
-            else:
-                print(f"   ❌ Dropped dead proxy: {ip}")
-        
-        proxy_storage["valid_proxies"] = still_good
         
-        # 2. FILL THE POOL (If we have less than 10)
+        if current_list:
+            print(f"   🔎 Re-checking {len(current_list)} active proxies...")
+            with ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
+                # Submit all checks at once
+                future_to_ip = {executor.submit(check_proxy, ip): ip for ip in current_list}
+                for future in as_completed(future_to_ip):
+                    result = future.result()
+                    if result:
+                        still_good.append(result)
+            
+            print(f"   ✅ Retained {len(still_good)} working proxies.")
+            proxy_storage["valid_proxies"] = still_good
+
+        # 2. FILL THE POOL (If low)
         if len(proxy_storage["valid_proxies"]) < TARGET_COUNT:
             needed = TARGET_COUNT - len(proxy_storage["valid_proxies"])
             print(f"   📉 Pool low. Need {needed} more. Fetching fresh list...")
@@ -63,28 +68,42 @@ def worker_loop():
             for s in sources:
                 try:
                     r = requests.get(s, timeout=10)
-                    raw_proxies += r.text.strip().split("\n")
+                    if r.status_code == 200:
+                        raw_proxies += r.text.strip().split("\n")
                 except: pass
             
-            # Shuffle to get random ones
+            # Shuffle and Clean
+            raw_proxies = list(set(raw_proxies)) # Remove duplicates
             random.shuffle(raw_proxies)
-            
-            # Test until we hit 10
-            for ip in raw_proxies:
-                ip = ip.strip()
-                if not ip or ip in proxy_storage["valid_proxies"]: continue
-                
-                # Stop if we hit our target
-                if len(proxy_storage["valid_proxies"]) >= TARGET_COUNT:
-                    break
+            print(f"   ⚡ Loaded {len(raw_proxies)} raw candidates. Checking in parallel...")
+
+            # Mass Check in Batches
+            with ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
+                # Submit a large batch to the executor
+                futures = []
+                for ip in raw_proxies:
+                    ip = ip.strip()
+                    if not ip or ip in proxy_storage["valid_proxies"]: continue
+                    
+                    futures.append(executor.submit(check_proxy, ip))
                     
-                print(f"   Testing {ip}...", end="\r")
-                if check_proxy(ip):
-                    print(f"   ✅ FOUND NEW: {ip}")
-                    proxy_storage["valid_proxies"].append(ip)
+                    # Optimization: Don't queue 10,000 tasks. Queue enough to fill workers + buffer
+                    if len(futures) >= needed * 5: 
+                        break
 
+                # Process results as they finish (Real-time filling)
+                for future in as_completed(futures):
+                    # Stop early if we hit the target while checking
+                    if len(proxy_storage["valid_proxies"]) >= TARGET_COUNT:
+                        break
+                    
+                    result = future.result()
+                    if result:
+                        print(f"   ✅ FOUND NEW: {result}")
+                        proxy_storage["valid_proxies"].append(result)
+            
         proxy_storage["last_updated"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        print(f"   💤 Sleeping for {CHECK_INTERVAL/60} mins. Current Pool: {len(proxy_storage['valid_proxies'])}")
+        print(f"   💤 Sleeping for {CHECK_INTERVAL}s. Current Pool: {len(proxy_storage['valid_proxies'])}")
         
         # 3. SLEEP
         time.sleep(CHECK_INTERVAL)