Create main.py

main.py

@@ -0,0 +1,164 @@
+import os
+import re
+import json
+import asyncio
+import uvicorn
+import aiohttp
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from telethon import TelegramClient, events
+from contextlib import asynccontextmanager
+
+# --- CONFIG ---
+API_ID = 21934109
+API_HASH = 'e7e8c554b9ff88d180983996c33bdf27'
+BOT_USERNAME = '@TruecallerInfoLookupBot'
+
+PORT = int(os.environ.get("PORT", 7860))
+SERVER_URL = f"http://127.0.0.1:{PORT}"
+
+# Global coordination states
+pending_phone_trigger = None
+current_response_future = None
+
+def parse_to_json(text: str) -> dict:
+    """Parses the bot text into a structured dictionary."""
+    e_match = re.search(r'Eyecon.*?Name:\s*`?(.*?)`?(?:\n|$)', text, re.IGNORECASE | re.DOTALL)
+    c_match = re.search(r'CALLAPP.*?Name:\s*`?(.*?)`?(?:\n|$)', text, re.IGNORECASE | re.DOTALL)
+    
+    name1 = e_match.group(1).strip() if e_match else None
+    name2 = c_match.group(1).strip() if c_match else None
+
+    data = {}
+    if name1:
+        data["name1"] = name1
+    if name2:
+        data["name2"] = name2
+
+    if not name1 and not name2:
+        fallback = re.search(r'Name:\s*`?(.*?)`?(?:\n|$)', text, re.IGNORECASE)
+        if fallback:
+            data["name1"] = fallback.group(1).strip()
+
+    carrier_match = re.search(r'Carrier:\s*`?(.*?)`?(?:\n|$)', text, re.IGNORECASE)
+    location_match = re.search(r'Location:\s*`?(.*?)`?(?:\n|$)', text, re.IGNORECASE)
+    
+    data["carrier"] = carrier_match.group(1).strip() if carrier_match else "N/A"
+    data["location"] = location_match.group(1).strip() if location_match else "N/A"
+    data["full_text"] = text
+    
+    return data
+
+# --- NATIVE FASTAPI ASYNC LIFECYCLE ---
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    session_path = "/code/lookup_session.session"
+    print(f"[STARTUP] Looking for session file at: {session_path}")
+    
+    if not os.path.exists(session_path):
+        print(f"[CRITICAL ERROR] '{session_path}' IS MISSING!")
+        print("Please upload your authenticated 'lookup_session.session' file to your Space root.")
+        # We allow startup so you can see the log error instead of a crash-loop
+    else:
+        print("[STARTUP] Session file verified. Initializing Telegram Client...")
+        asyncio.create_task(run_telegram_worker())
+        
+    yield
+    print("[SHUTDOWN] Cleaning up resources...")
+
+app = FastAPI(lifespan=lifespan)
+
+# --- CORS MIDDLEWARE ---
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://crm.gudmed.in"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- INTERNAL INTER-TASK ROUTING ---
+@app.get("/get-trigger")
+async def get_trigger():
+    global pending_phone_trigger
+    if pending_phone_trigger:
+        phone = pending_phone_trigger
+        pending_phone_trigger = None
+        return {"phone": phone}
+    return {"phone": None}
+
+@app.post("/webhook-receive")
+async def webhook_receive(payload: dict):
+    global current_response_future
+    if current_response_future and not current_response_future.done():
+        current_response_future.set_result(payload)
+    return {"status": "ok"}
+
+# --- PUBLIC ENDPOINT ---
+@app.get("/lookup")
+async def lookup(phone: str):
+    global current_response_future, pending_phone_trigger
+    clean_phone = str(phone)[-10:].strip()
+    
+    loop = asyncio.get_running_loop()
+    current_response_future = loop.create_future()
+    pending_phone_trigger = clean_phone
+    
+    try:
+        # Await responses asynchronously without manual interval polling
+        result_data = await asyncio.wait_for(current_response_future, timeout=20.0)
+        return {
+            "status": "success",
+            "phone": clean_phone,
+            "data": result_data
+        }
+    except asyncio.TimeoutError:
+        raise HTTPException(status_code=504, detail="Timeout: Bot did not respond in time.")
+    finally:
+        current_response_future = None
+
+# --- TELETHON WORKER ---
+async def poll_server_for_outbound(client):
+    while True:
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(f"{SERVER_URL}/get-trigger") as resp:
+                    if resp.status == 200:
+                        data = await resp.json()
+                        phone = data.get("phone")
+                        if phone:
+                            print(f"[WORKER] Sending target: +91{phone}")
+                            await client.send_message(BOT_USERNAME, f'+91{phone}')
+        except Exception as e:
+            print(f"[WORKER ERROR] Outbound connection glitch: {e}")
+        await asyncio.sleep(0.1)
+
+async def run_telegram_worker():
+    client = TelegramClient('/code/lookup_session', API_ID, API_HASH)
+    
+    @client.on(events.NewMessage(chats=BOT_USERNAME))
+    async def handle_bot_reply(event):
+        text = event.text or ""
+        # Filter out status indicators
+        if any(x in text for x in ["Searching", "Please wait", "Typing"]):
+            return
+            
+        print("[INBOUND] Message received from bot. Parsing...")
+        parsed_data = parse_to_json(text)
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                await session.post(f"{SERVER_URL}/webhook-receive", json=parsed_data)
+        except Exception as e:
+            print(f"[INBOUND ERROR] Could not forward data: {e}")
+
+    await client.start()
+    print("[BACKGROUND] Telegram Client Authorized and Active!")
+    
+    await asyncio.gather(
+        client.run_until_disconnected(),
+        poll_server_for_outbound(client)
+    )
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=PORT)