Update bot.py

bot.py

@@ -3,18 +3,19 @@ import re
 import time
 import io
 import asyncio
+import aiohttp
 from telethon import events, Button
 import db
 import scraper
+from curl_cffi.requests import AsyncSession
 
 # --- AUTHENTICATION ---
-def get_admins():
-    return {int(x) for x in os.environ.get("ADMIN_IDS", "").split(",") if x}
+ADMIN_IDS = {int(x) for x in os.environ.get("ADMIN_IDS", "").split(",") if x}
 
 def is_admin(event):
-    return event.sender_id in get_admins()
+    return event.sender_id in ADMIN_IDS
 
-# --- PROFESSIONAL NAVIGATION ---
+# --- MENUS & DASHBOARD ---
 def get_main_menu():
     return [
         [Button.inline("▶️ Start Scan", b"start_scan"), Button.inline("⏸ Pause", b"pause_scan"), Button.inline("⏹ Stop", b"stop_scan")],
@@ -24,18 +25,17 @@ def get_main_menu():
 
 def get_settings_menu():
     return [
-        [Button.inline("💾 Load Database", b"load_words")],
-        [Button.inline("⚡ Set Speed", b"set_speed"), Button.inline("📏 Set Length", b"set_min_length")],
-        [Button.inline("🔴 Wipe Database", b"reset_confirm")],
+        [Button.inline("💾 Load Words", b"load_words"), Button.inline("📏 Set Length", b"set_min_length")],
+        [Button.inline("⚡ Set Speed", b"set_speed"), Button.inline("🔴 Wipe DB", b"reset_confirm")],
         [Button.inline("« Back to Main Menu", b"back_main")]
     ]
 
-# --- SYSTEM DASHBOARD ---
 async def generate_status_msg():
     state = await db.get_state()
     counts = await db.get_counts()
     concurrency = await db.get_concurrency()
     qlen = await db.queue_size()
+    proxy_count = await db.get_proxy_count()
     
     total = int(state.get("total", 0))
     processed = int(state.get("processed", 0))
@@ -56,6 +56,7 @@ async def generate_status_msg():
         f"**Queue:** `{qlen:,}` waiting\n"
         f"**Speed:** `{concurrency}` workers\n"
         f"**Filter:** `Min {min_len} letters`\n"
+        f"**Proxies:** `{proxy_count}` Active\n"
         f"**Progress:** `{pct:.2f}%`\n"
         f"`[{bar}]`\n"
         f"`{processed:,} / {total:,}`\n\n"
@@ -65,21 +66,23 @@ async def generate_status_msg():
         f"🚫 Unavail    : `{counts.get('unavailable', 0):,}`\n"
         f"💰 For Sale   : `{counts.get('forsale', 0):,}`\n"
         f"🔨 Auction    : `{counts.get('auction', 0):,}`\n"
+        f"✅ Available  : `{counts.get('available', 0):,}`\n"
         f"🛒 Sold       : `{counts.get('sold', 0):,}`\n"
     )
 
-# --- BACKGROUND HELPERS ---
-def read_file_sync():
-    with open("words.txt", "r", encoding="utf-8") as f: 
-        return [line.strip().lower() for line in f if line.strip()]
-
-def write_file_sync(lines):
-    with open("words.txt", "w", encoding="utf-8") as f: 
-        f.write("\n".join(lines))
-
-def filter_words_sync(chunk, min_length):
-    pattern = re.compile(rf'^[a-z0-9_]{{{min_length},32}}$')
-    return {w for w in chunk if pattern.match(w)}
+# --- PROXY TESTER ---
+async def test_proxy(proxy_url):
+    proxies = {"http": proxy_url, "https": proxy_url}
+    start = time.time()
+    try:
+        async with AsyncSession(impersonate="chrome120", proxies=proxies) as session:
+            resp = await session.get("https://fragment.com/", timeout=10)
+            if resp.status_code == 200:
+                latency = round((time.time() - start) * 1000)
+                return proxy_url, latency
+    except Exception:
+        pass
+    return proxy_url, None
 
 # --- HANDLER SETUP ---
 def setup_handlers(client):
@@ -89,7 +92,62 @@ def setup_handlers(client):
         if is_admin(event): 
             await event.respond("**Fragment Control System**", buttons=get_main_menu())
 
-    # --- REAL HTML SCREENSHOT COMMAND ---
+    # --- NEW: PROXY UPLOADER & CHECKER ---
+    @client.on(events.NewMessage(pattern='/proxies'))
+    async def proxy_cmd(event):
+        if not is_admin(event): return
+        if not event.is_reply:
+            return await event.respond("⚠️ Reply to a `proxies.txt` file with `/proxies`.")
+            
+        reply = await event.get_reply_message()
+        if not reply.document:
+            return await event.respond("⚠️ Attached message is not a document.")
+            
+        msg = await event.respond("⏳ Downloading proxies...")
+        file_path = await reply.download_media(file="temp_proxies.txt")
+        
+        with open(file_path, "r", encoding="utf-8") as f:
+            raw_proxies = [line.strip() for line in f if line.strip()]
+            
+        os.remove(file_path)
+        
+        if not raw_proxies:
+            return await msg.edit("⚠️ No proxies found in file.")
+            
+        await msg.edit(f"🔍 Testing **{len(raw_proxies)}** proxies concurrently...")
+        
+        # Test all proxies concurrently
+        tasks = [test_proxy(p) for p in raw_proxies]
+        results = await asyncio.gather(*tasks)
+        
+        working_proxies = []
+        latency_board = []
+        
+        for p_url, latency in results:
+            if latency is not None:
+                working_proxies.append(p_url)
+                latency_board.append((p_url, latency))
+                
+        # Sort by fastest latency
+        latency_board.sort(key=lambda x: x[1])
+        
+        # Save working proxies to Redis
+        await db.save_working_proxies(working_proxies)
+        
+        # Format Top 10 Report
+        top_str = "\n".join([f"⏱ `{lat}ms` | {url.split('@')[-1] if '@' in url else url}" for url, lat in latency_board[:10]])
+        
+        report = (
+            f"✅ **Proxy Test Complete**\n"
+            f"━━━━━━━━━━━━━━━━\n"
+            f"**Total Tested:** `{len(raw_proxies)}`\n"
+            f"**Working & Saved:** `{len(working_proxies)}`\n\n"
+            f"🏆 **Top Fastest Proxies:**\n{top_str if top_str else 'None'}"
+        )
+        await msg.edit(report, buttons=get_main_menu())
+
+
+    # --- LIVE HTML SCREENSHOT COMMAND ---
     @client.on(events.NewMessage(pattern=r'/check\s+([a-zA-Z0-9_]+)'))
     async def check_cmd(event):
         if not is_admin(event): return
@@ -97,37 +155,34 @@ def setup_handlers(client):
         msg = await event.respond(f"📸 Taking live screenshot of `@{target}` on Fragment...")
         
         url = f"https://fragment.com/username/{target}"
+        img_filename = None
         
         try:
-            # Run the browser screenshot in a separate thread so it doesn't freeze the bot
             def take_screenshot():
                 from html2image import Html2Image
-                # --no-sandbox is critical for Linux servers
                 hti = Html2Image(
                     browser_executable='/usr/bin/chromium',
                     custom_flags=['--no-sandbox', '--disable-gpu', '--hide-scrollbars', '--disable-dev-shm-usage']
                 ) 
                 hti.size = (1000, 750) 
-                img_name = f"{target}_fragment.png"
-                # Chrome navigates to the URL and renders the exact CSS/HTML
-                hti.screenshot(url=url, save_as=img_name)
-                return img_name
+                name = f"{target}_fragment.png"
+                hti.screenshot(url=url, save_as=name)
+                return name
 
             img_filename = await asyncio.to_thread(take_screenshot)
             
             await client.send_file(event.chat_id, file=img_filename, caption=f"**Live Web Snapshot:** `@{target}`")
             await msg.delete()
-            
-            if os.path.exists(img_filename):
-                os.remove(img_filename)
                 
         except Exception as e:
-            try:
-                await msg.edit(f"❌ **Screenshot Error:**\n*(Make sure packages.txt has chromium)*\n`{str(e)}`")
-            except:
-                pass
+            try: await msg.edit(f"❌ **Screenshot Error:**\n`{str(e)}`")
+            except: pass
+        finally:
+            if img_filename and os.path.exists(img_filename):
+                os.remove(img_filename)
+
 
-    # --- UPGRADED HTML DEBUG COMMAND (Immune to Shadow Bans) ---
+    # --- HTML DEBUG COMMAND (With Redirect Tracking) ---
     @client.on(events.NewMessage(pattern=r'/html\s+([a-zA-Z0-9_]+)'))
     async def html_cmd(event):
         if not is_admin(event): return
@@ -137,9 +192,6 @@ def setup_handlers(client):
         url = f"https://fragment.com/username/{target}"
         
         try:
-            from curl_cffi.requests import AsyncSession
-            
-            # Using Chrome impersonation to stop Fragment from faking the redirect
             async with AsyncSession(impersonate="chrome120") as session:
                 resp = await session.get(url, timeout=15, allow_redirects=True)
                 html_text = resp.text
@@ -161,11 +213,10 @@ def setup_handlers(client):
             await msg.delete() 
             
         except Exception as e:
-            try:
-                await msg.edit(f"❌ **Error fetching HTML:** `{str(e)}`")
-            except:
-                await event.respond(f"❌ **Error fetching HTML:** `{str(e)}`")
+            try: await msg.edit(f"❌ **Error fetching HTML:** `{str(e)}`")
+            except: pass
 
+    # --- WORDS UPLOAD COMMAND ---
     @client.on(events.NewMessage(pattern='/upload'))
     async def upload_cmd(event):
         if not is_admin(event): return
@@ -179,6 +230,7 @@ def setup_handlers(client):
         await reply.download_media(file="words.txt")
         await wait.edit("✅ Uploaded. Go to Settings -> Load Database.", buttons=get_main_menu())
 
+    # --- SESSION GENERATOR ---
     @client.on(events.NewMessage(pattern='/getstring'))
     async def pyrogram_string_cmd(event):
         if not is_admin(event): return
@@ -186,16 +238,13 @@ def setup_handlers(client):
         async with client.conversation(event.chat_id, timeout=300) as conv:
             try:
                 await conv.send_message("🛠 **Pyrogram String Session Generator**\n\nEnter your `API_ID`:")
-                api_id_msg = await conv.get_response()
-                api_id = int(api_id_msg.text.strip())
+                api_id = int((await conv.get_response()).text.strip())
 
                 await conv.send_message("Enter your `API_HASH`:")
-                api_hash_msg = await conv.get_response()
-                api_hash = api_hash_msg.text.strip()
+                api_hash = (await conv.get_response()).text.strip()
 
                 await conv.send_message("Enter the **Phone Number** (e.g., +1234567890):")
-                phone_msg = await conv.get_response()
-                phone = phone_msg.text.replace(" ", "").strip()
+                phone = (await conv.get_response()).text.replace(" ", "").strip()
 
                 await conv.send_message("⏳ Requesting OTP from Telegram...")
                 
@@ -208,21 +257,19 @@ def setup_handlers(client):
                 sent_code = await app.send_code(phone)
                 
                 await conv.send_message("📥 **Code Sent!**\n\n⚠️ **CRITICAL:** You MUST enter the code with spaces between numbers.\nExample: `1 2 3 4 5`")
-                code_msg = await conv.get_response()
-                otp_code = code_msg.text.replace(" ", "").strip()
+                otp_code = (await conv.get_response()).text.replace(" ", "").strip()
                 
                 try:
                     await app.sign_in(phone, sent_code.phone_code_hash, otp_code)
                 except SessionPasswordNeeded:
                     await conv.send_message("🔐 **2FA Password Required.**\nEnter your Cloud Password:")
-                    pwd_msg = await conv.get_response()
-                    await app.check_password(pwd_msg.text.strip())
+                    pwd = (await conv.get_response()).text.strip()
+                    await app.check_password(pwd)
                 
                 string_session = await app.export_session_string()
-                
                 await conv.send_message(f"✅ **String Session Generated!**\n\n`{string_session}`\n\n⚠️ Keep this secret.")
             except asyncio.TimeoutError:
-                await conv.send_message("❌ **Timeout.** You took too long. Run `/getstring` again.")
+                await conv.send_message("❌ **Timeout.** Run `/getstring` again.")
             except Exception as e:
                 await conv.send_message(f"❌ **Error:** `{str(e)}`")
             finally:
@@ -230,9 +277,11 @@ def setup_handlers(client):
                     try: await app.disconnect()
                     except: pass
 
-    async def _load_words(event, is_callback=True):
+    # --- DASHBOARD CALLBACKS ---
+    async def _load_words(event):
         try:
-            all_lines = await asyncio.to_thread(read_file_sync)
+            with open("words.txt", "r", encoding="utf-8") as f: 
+                all_lines = [line.strip().lower() for line in f if line.strip()]
         except Exception:
             return await event.edit("❌ `words.txt` not found. Upload it first.")
             
@@ -246,7 +295,9 @@ def setup_handlers(client):
         current = all_lines[:CHUNK]
         remaining = all_lines[CHUNK:]
         
-        valid = await asyncio.to_thread(filter_words_sync, current, min_length)
+        pattern = re.compile(rf'^[a-z0-9_]{{{min_length},32}}$')
+        valid = {w for w in current if pattern.match(w)}
+        
         r = await db.get_redis()
         done = await r.smembers("frag:done")
         to_q = list(valid - done)
@@ -257,7 +308,9 @@ def setup_handlers(client):
                 pipe.lpush("frag:queue", *to_q[i:i+1000])
             await pipe.execute()
             
-        await asyncio.to_thread(write_file_sync, remaining)
+        with open("words.txt", "w", encoding="utf-8") as f: 
+            f.write("\n".join(remaining))
+            
         await db.set_state(total=len(valid))
         await event.edit(f"✅ Loaded {len(to_q):,} words (Min length: {min_length}).", buttons=get_main_menu())
 
@@ -327,7 +380,8 @@ def setup_handlers(client):
             await event.edit("⏳ Generating text files...")
             exported_count = 0
             
-            for s in ["taken", "unavailable", "sold", "forsale", "auction"]:
+            # Export all tracking sets including the new 'available' one
+            for s in ["taken", "unavailable", "sold", "forsale", "auction", "available"]:
                 lst = sorted(list(await (getattr(db, f"get_all_{s}")())))
                 if lst:
                     f = io.BytesIO("\n".join(lst).encode('utf-8'))