Update app.py

app.py

@@ -1,61 +1,163 @@
-from fastapi import FastAPI, HTTPException, Query
-import duckdb
+from fastapi import FastAPI, HTTPException, Request, BackgroundTasks
+import telebot
+from telebot import apihelper
+import httpx
+import os
+import time
 from contextlib import asynccontextmanager
 
-# Global connection object
-con = duckdb.connect()
+# ⚡ PRODUCTION TIMEOUTS: Safe values proxy networks ke liye
+apihelper.CONNECT_TIMEOUT = 30
+apihelper.READ_TIMEOUT = 30
+
+BOT_TOKEN = os.environ.get("BOT_TOKEN")
+API_URL = os.environ.get("API_URL", "https://tfqdeadlo-1-78bapi.hf.space/search")
+BOT_SPACE_URL = "https://tfqdeadlo-tgbotc.hf.space"
+
+# threaded=False zaroori hai jab hum FastAPI background tasks use karte hain
+bot = telebot.TeleBot(BOT_TOKEN, threaded=False)
 
-# Lifespan use karke app start hote hi heavy initialization ek baar karenge
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    print("DuckDB extensions load ho rahi hain aur View ban raha hai...")
-    con.execute("INSTALL httpfs; LOAD httpfs;")
-    
-    # Parquet file ka correct URL
-    PARQUET_URL = "https://huggingface.co/datasets/tfqdeadlo/Inddatainonefile/resolve/main/users_data.parquet"
+    if not BOT_TOKEN:
+        print("❌ ERROR: BOT_TOKEN Missing!")
+        yield
+        return
     
-    # Startup par hi Ek baar View bana kar metadata cache kar lete hain
-    # Isse har API request par network par load nahi padega
-    con.execute(f"CREATE OR REPLACE VIEW users_view AS SELECT * FROM read_parquet('{PARQUET_URL}')")
-    print("View taiyar hai! API requests ke liye taiyar hai.")
+    # Webhook set karne ke liye retry mechanism
+    for attempt in range(3):
+        try:
+            webhook_url = f"{BOT_SPACE_URL}/telegram-webhook"
+            bot.remove_webhook()
+            bot.set_webhook(url=webhook_url, timeout=30)
+            print("✅ Webhook successfully set ho gaya startup par!")
+            break
+        except Exception as e:
+            print(f"⚠️ Webhook attempt {attempt+1} fail hua: {e}")
+            time.sleep(2)
     yield
-    con.close()
 
-app = FastAPI(title="Super Fast Search API", lifespan=lifespan)
+app = FastAPI(title="Lakhs-Users Production Bot", lifespan=lifespan)
 
 @app.get("/")
 def home():
-    return {"message": "Fast API online hai! Use /search?mobile=YOUR_NUMBER"}
+    return {"status": "running", "message": "Master-Handler Production Bot Active!"}
 
-@app.get("/search")
-async def search_mobile(mobile: str = Query(..., description="Enter mobile number to search")):
+# --- BACKGROUND WORKER ---
+def process_telegram_update(json_string: dict):
     try:
-        # Ab hum direct cache kiye hue 'users_view' se data nikalenge
-        query = """
-            SELECT mobile, name, fname, address, alt, circle, id, email 
-            FROM users_view 
-            WHERE mobile = ? 
-            LIMIT 1
-        """
+        update = telebot.types.Update.de_json(json_string)
+        bot.process_new_updates([update])
+    except Exception as e:
+        print(f"❌ Processing me error: {e}")
+
+# --- TELEGRAM WEBHOOK ENDPOINT ---
+@app.post("/telegram-webhook")
+async def telegram_webhook(request: Request, background_tasks: BackgroundTasks):
+    if request.headers.get("content-type") == "application/json":
+        json_string = await request.json()
+        # Telegram ko turant 200 OK dekar free karo, taaki request line me na fase
+        background_tasks.add_task(process_telegram_update, json_string)
+        return {"status": "ok"}
+    else:
+        raise HTTPException(status_code=403, detail="Bad Request")
+
+# --- HELPER: RETRY DRIVEN SEND MESSAGE ---
+def send_message_with_retry(chat_id, text, parse_mode=None):
+    """Network failure se bachne ke liye automatic 3-times retry system"""
+    for attempt in range(3):
+        try:
+            return bot.send_message(chat_id, text, parse_mode=parse_mode)
+        except Exception as e:
+            print(f"⚠️ Message send attempt {attempt+1} fail hua: {e}")
+            if attempt < 2:
+                time.sleep(1)
+            else:
+                print("❌ Saare attempts fail ho gaye.")
+
+# --- 🎯 MASTER HANDLER (Unbreakable Routing) ---
+@bot.message_handler(func=lambda message: True)
+def handle_all_messages(message):
+    if not message.text:
+        return
+        
+    raw_input = message.text.strip()
+    chat_id = message.chat.id
+    
+    # ⭐ 1. Check if it is a command (/start or /help)
+    if raw_input.startswith('/start') or raw_input.startswith('/help'):
+        print(f"⚙️ [COMMAND] /start received for Chat ID: {chat_id}")
+        welcome_text = (
+            "👋 **Welcome to Search Bot!**\n\n"
+            "Mujhe koi bhi mobile number bhejiye, mai backend se data nikal kar dunga.\n"
+            "⚡ *Safe, Secure & Fast*"
+        )
+        send_message_with_retry(chat_id, welcome_text, parse_mode="Markdown")
+        print(f"➡️ [COMMAND] /start reply successfully sent to Chat ID: {chat_id}")
+        return  # Yahin se process khatam, aage mobile search par nahi jayega
+
+    # ⭐ 2. If it's NOT a command, process it as a Mobile Number Search
+    print(f"📥 [SEARCH] Mobile search request: '{raw_input}' | Chat ID: {chat_id}")
+    
+    if len(raw_input) > 20:
+        send_message_with_retry(chat_id, "❌ Input bohot lamba hai! Kripya sirf ek valid mobile number bhejein.")
+        return
+
+    cleaned_mobile = "".join(c for c in raw_input if c.isdigit())
+    
+    if len(cleaned_mobile) == 12 and cleaned_mobile.startswith("91"):
+        mobile = cleaned_mobile[-10:]
+    elif len(cleaned_mobile) == 10:
+        mobile = cleaned_mobile
+    else:
+        mobile = cleaned_mobile
+
+    if not mobile or len(mobile) < 10 or len(mobile) > 11:
+        send_message_with_retry(chat_id, "❌ Kripya ek sahi 10-digit ka mobile number bhejein.")
+        return
         
-        result = con.execute(query, [str(mobile)]).fetchall()
+    try:
+        bot.send_chat_action(chat_id, 'typing')
+    except Exception:
+        pass
+
+    send_message_with_retry(chat_id, f"🔍 Searching for `{mobile}`... Please wait...")
+    
+    try:
+        # Backend API hit karna
+        response = httpx.get(f"{API_URL}?mobile={mobile}", timeout=15.0)
         
-        if not result:
-            return {
-                "status": "error", 
-                "message": f"Mobile number {mobile} nahi mila."
-            }
+        if response.status_code != 200:
+            send_message_with_retry(chat_id, "⚠️ Main API se sampark nahi ho paya. Kripya thodi der baad try karein.")
+            return
+            
+        res_data = response.json()
         
-        # Data mapping
-        columns = [desc[0] for desc in con.description]
-        row_dict = dict(zip(columns, result[0]))
+        if res_data.get("status") == "error":
+            send_message_with_retry(chat_id, f"❌ {res_data.get('message', 'Mobile number nahi mila.')}")
+            return
+            
+        row_dict = res_data.get("data", {})
         
-        return {
-            "status": "success",
-            "data": row_dict
-        }
+        if not row_dict or not isinstance(row_dict, dict):
+            send_message_with_retry(chat_id, f"❌ Mobile number `{mobile}` ka koi valid record nahi mila.")
+            return
+            
+        response_msg = f"✅ **Record Found for {mobile}!**\n\n"
+        for key, value in row_dict.items():
+            display_value = value if value else "N/A"
+            response_msg += f"🔹 **{key.upper()}**: `{display_value}`\n"
+            
+        send_message_with_retry(chat_id, response_msg, parse_mode="Markdown")
+        print(f"➡️ Success: Data reply successfully sent for {mobile}")
         
+    except (httpx.ConnectTimeout, httpx.ReadTimeout):
+        send_message_with_retry(
+            chat_id, 
+            "⏳ **Main Data API sleep mode se jaag rahi hai.**\n\n"
+            "Kripya 5 seconds baad wapas se wahi number bhejein, data aa jayega!"
+        )
     except Exception as e:
-        # Internal error ko secure rakhne ke liye mask kiya hai
-        raise HTTPException(status_code=500, detail="Query timeout ya process nahi ho payi.")
+        print(f"❌ Main logic crash prevented: {e}")
+        send_message_with_retry(chat_id, "⚠️ Kuch temporary dikkat aayi hai. Baad me try karein.")