Update app.py

app.py

@@ -30,7 +30,7 @@ file_lock = threading.Lock()
 traffic_log_lock = threading.Lock()
 
 # =====================================================
-# TRAFFIC BOT LOGIC (Script B Adapted)
+# TRAFFIC BOT LOGIC (Fixed)
 # =====================================================
 
 def log_traffic(msg):
@@ -54,6 +54,10 @@ def save_proxy_as_used(proxy):
             f.write(f"{proxy}\n")
 
 def get_fresh_proxies(needed_count):
+    """
+    Fetches proxies and handles various API return formats 
+    (Strings, Lists, or Nested Lists) to prevent 'unhashable type' errors.
+    """
     # 1. Load History
     used_proxies = set()
     if os.path.exists(HISTORY_FILE):
@@ -65,31 +69,46 @@ def get_fresh_proxies(needed_count):
         client = Client(TRAFFIC_PROXY_SOURCE)
         result = client.predict(api_name="/get_proxies_api")
         
-        if isinstance(result, str):
+        all_proxies = []
+
+        # --- FIX START: ROBUST PARSING ---
+        # Handle case where result is a nested list like [['p1', 'p2']]
+        if isinstance(result, (list, tuple)) and len(result) > 0 and isinstance(result[0], list):
+            all_proxies = result[0]
+        # Handle case where result is a string representation
+        elif isinstance(result, str):
             all_proxies = eval(result) if "[" in result else result.splitlines()
-        else:
+        # Handle case where result is a simple list
+        elif isinstance(result, list):
             all_proxies = result
+        # --- FIX END ---
             
-        fresh_proxies = [p for p in all_proxies if p not in used_proxies]
+        # 3. Filter (Ensure p is a string before checking set membership)
+        fresh_proxies = []
+        for p in all_proxies:
+            if isinstance(p, str) and p not in used_proxies:
+                fresh_proxies.append(p)
         
         if len(fresh_proxies) < needed_count:
-            log_traffic(f"⚠️ Only found {len(fresh_proxies)} fresh proxies.")
+            # Only log if significantly low to avoid spamming "0 fresh"
+            if len(fresh_proxies) == 0:
+                log_traffic(f"⚠️ No fresh proxies found (History: {len(used_proxies)})")
             return fresh_proxies 
             
         return fresh_proxies[:needed_count]
+
     except Exception as e:
-        log_traffic(f"❌ Proxy API Error: {e}")
+        log_traffic(f"❌ Proxy API Error: {str(e)[:50]}")
         return []
 
 def visitor_bot(proxy, target_url, dwell_time, thread_id):
     proxies = {"http": proxy, "https": proxy}
     try:
         # STEP 1: ARRIVAL
-        # log_traffic(f"➡️ [T{thread_id}] Arriving...") # Reduced logging to avoid spam
+        # log_traffic(f"➡️ [T{thread_id}] Arriving...") 
         r1 = requests.get(target_url, proxies=proxies, timeout=15)
         
         if r1.status_code != 200:
-            # log_traffic(f"❌ [T{thread_id}] Blocked ({r1.status_code})")
             save_proxy_as_used(proxy)
             return
 
@@ -106,7 +125,6 @@ def visitor_bot(proxy, target_url, dwell_time, thread_id):
 
     except Exception:
         pass # Silently fail to keep logs clean
-        # save_proxy_as_used(proxy)
 
 def traffic_manager(target_url, duration_mins, concurrency):
     global traffic_active
@@ -123,25 +141,25 @@ def traffic_manager(target_url, duration_mins, concurrency):
 
     while time.time() < end_time and traffic_active:
         remaining = int((end_time - time.time()) / 60)
-        log_traffic(f"🔄 Cycle Start (Time left: ~{remaining}m)")
+        # log_traffic(f"🔄 Cycle Start (Time left: ~{remaining}m)")
         
         proxies = get_fresh_proxies(concurrency)
         
         if not proxies:
-            log_traffic("❌ No proxies. Retrying in 10s...")
+            log_traffic("⏳ Waiting for fresh proxies (10s)...")
             time.sleep(10)
             continue
 
+        log_traffic(f"⚡ Launching {len(proxies)} bots...")
         threads = []
         for i, proxy in enumerate(proxies):
-            if not traffic_active: break # Stop mid-launch if cancelled
+            if not traffic_active: break 
             t = threading.Thread(target=visitor_bot, args=(proxy, target_url, dwell_time, i+1))
             threads.append(t)
             t.start()
             time.sleep(0.1) 
 
-        # Wait for this batch to finish before starting next batch
-        # This prevents exploding thread counts
+        # Wait for this batch to finish
         for t in threads:
             t.join()
             
@@ -150,6 +168,8 @@ def traffic_manager(target_url, duration_mins, concurrency):
     return "Stopped"
 
 def start_traffic_thread(url, mins, conc):
+    if traffic_active:
+        return "⚠️ Already Running"
     threading.Thread(target=traffic_manager, args=(url, mins, conc)).start()
     return "✅ Traffic Started (Check Logs)"
 
@@ -164,7 +184,7 @@ def stop_traffic():
 def get_proxy_batch():
     try:
         client = Client(PROXY_SPACE_URL)
-        result = client.predict(api_name="/get_proxies_api")
+        result = client.predict(api_name="/get_proxies")
         proxies = result[0]
         if proxies:
             random.shuffle(proxies)
@@ -176,7 +196,7 @@ def get_proxy_batch():
 def get_best_proxy():
     try:
         client = Client(PROXY_SPACE_URL)
-        result = client.predict(api_name="/get_proxies_api")
+        result = client.predict(api_name="/get_proxies")
         proxies = result[0]
         if proxies:
             return f"http://{random.choice(proxies)}"