Update app.py

app.py

@@ -1,152 +1,99 @@
-#!/usr/bin/env python3
+from fastapi import FastAPI, UploadFile, File, Query, HTTPException
+import shutil
+from fastapi.middleware.cors import CORSMiddleware
+import tempfile
 import os
-import asyncio
-import re
-from telethon import TelegramClient, events
-from telethon.sessions import StringSession
-from aiohttp import web
-
-# ================= CONFIG =================
-API_ID = int(os.environ["API_ID"])
-API_HASH = os.environ["API_HASH"]
-STRING_SESSION = os.environ["STRING_SESSION"]     # <-- YOUR STRING SESSION (USER)
-
-BYPASS_BOT = "Nick_Bypass_Bot"    # without @
-
-API_HOST = "0.0.0.0"              # REQUIRED for Hugging Face
-API_PORT = 7860                   # REQUIRED for Hugging Face
-API_ROUTE = "/bypass"
-
-LINK_RE = re.compile(r"https?://\S+")
-ORIGINAL_RE = re.compile(r"Original Link.*?(https?://\S+)", re.S)
-BYPASSED_RE = re.compile(r"Bypassed Link.*?(https?://\S+)", re.S)
-# =========================================
-
-TG_PENDING = {}   # user_id -> (original_link, event)
-API_PENDING = {}  # api_link -> future
-
-
-# ---------- TELEGRAM USERBOT ----------
-async def start_userbot(client):
-
-    @client.on(events.NewMessage(incoming=True))
-    async def on_user_message(event):
-        if not event.is_private:
-            return
-
-        text = event.raw_text or ""
-        m = LINK_RE.search(text)
-        if not m:
-            return
-
-        uid = event.sender_id
-        link = m.group(0)
-
-        if uid in TG_PENDING:
-            return
-
-        TG_PENDING[uid] = (link, event)
-        await client.send_message(BYPASS_BOT, link)
-
-    @client.on(events.NewMessage(from_users=BYPASS_BOT))
-    async def on_bypass_reply(event):
-        text = event.raw_text or ""
-
-        m_byp = BYPASSED_RE.search(text)
-        if not m_byp:
-            return
-
-        bypassed_link = m_byp.group(1)
-        m_org = ORIGINAL_RE.search(text)
-        original_link = m_org.group(1) if m_org else None
-
-        # Telegram replies
-        for uid, (olink, user_event) in list(TG_PENDING.items()):
-            if original_link and olink != original_link:
-                continue
-
-            reply = (
-                "╭─ 🔓 **Link Unlocked**\n"
-                "│\n"
-                "│ 🔗 **Original**\n"
-                f"│ ┖ {olink}\n"
-                "│\n"
-                "│ 🚀 **Bypassed**\n"
-                f"│ ┖ {bypassed_link}\n"
-                "╰───────────────"
-            )
-
-            await user_event.reply(reply)
-            TG_PENDING.pop(uid, None)
-            break
-
-        # API replies
-        for link, fut in list(API_PENDING.items()):
-            if original_link and link != original_link:
-                continue
-            if not fut.done():
-                fut.set_result(bypassed_link)
-                API_PENDING.pop(link, None)
-                break
-
-    print("🤫 Telegram userbot running (StringSession)")
-
-
-# ---------- API ----------
-async def api_bypass(request):
-    link = request.query.get("link")
-    if not link:
-        return web.json_response({"error": "link parameter missing"})
-
-    loop = asyncio.get_event_loop()
-    future = loop.create_future()
-    API_PENDING[link] = future
 
-    await request.app["client"].send_message(BYPASS_BOT, link)
+from utils import (
+    check_image_nsfw,
+    check_video_nsfw,
+    download_file
+)
 
-    try:
-        bypassed = await asyncio.wait_for(future, timeout=40)
-    except asyncio.TimeoutError:
-        API_PENDING.pop(link, None)
-        return web.json_response({"status": "timeout"})
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 🔥 allow all (change later if needed)
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+MAX_SIZE_MB = 25
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "api": "live", "creator": "JerryCoder"}
+
+
+def save_upload(file: UploadFile):
+    tmp = tempfile.NamedTemporaryFile(delete=False)
+
+    size = 0
+    with open(tmp.name, "wb") as buffer:
+        while chunk := file.file.read(1024 * 1024):
+            size += len(chunk)
+            if size > MAX_SIZE_MB * 1024 * 1024:
+                buffer.close()
+                os.remove(tmp.name)
+                raise HTTPException(status_code=413, detail="File too large (max 25MB)")
+            buffer.write(chunk)
 
-    return web.json_response({
-        "status": "success",
-        "original": link,
-        "bypassed": bypassed
-    })
+    return tmp.name
 
 
-async def start_api(client):
-    app = web.Application()
-    app["client"] = client
-    app.router.add_get(API_ROUTE, api_bypass)
+def is_video(filename):
+    return filename.lower().endswith((".mp4", ".mov", ".avi", ".mkv", ".webm"))
 
-    runner = web.AppRunner(app)
-    await runner.setup()
-    site = web.TCPSite(runner, API_HOST, API_PORT)
-    await site.start()
 
-    print(f"🌐 API RUNNING → https://<your-space>.hf.space{API_ROUTE}?link=")
+def is_image(filename):
+    return filename.lower().endswith((".jpg", ".jpeg", ".png", ".webp"))
 
 
-# ---------- MAIN ----------
-async def main():
-    client = TelegramClient(
-        StringSession(STRING_SESSION),
-        API_ID,
-        API_HASH
-    )
+@app.post("/detect")
+async def detect(file: UploadFile = File(...)):
+    path = save_upload(file)
 
-    await client.connect()
-    if not await client.is_user_authorized():
-        raise RuntimeError("❌ String session is invalid or expired")
+    try:
+        if is_image(file.filename):
+            nsfw = check_image_nsfw(path)
+            return {"type": "image", "nsfw": nsfw}
+
+        elif is_video(file.filename):
+            nsfw = check_video_nsfw(path)
+            return {"type": "video", "nsfw": nsfw}
+
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported file type")
+
+    finally:
+        if os.path.exists(path):
+            os.remove(path)
+
+
+@app.get("/detect")
+async def detect_url(url: str = Query(...)):
+    path = download_file(url)
+
+    try:
+        size_mb = os.path.getsize(path) / (1024 * 1024)
+        if size_mb > MAX_SIZE_MB:
+            os.remove(path)
+            raise HTTPException(status_code=413, detail="File too large (max 25MB)")
 
-    await start_api(client)
-    await start_userbot(client)
+        if is_image(url):
+            nsfw = check_image_nsfw(path)
+            return {"type": "image", "nsfw": nsfw}
 
-    await client.run_until_disconnected()
+        elif is_video(url):
+            nsfw = check_video_nsfw(path)
+            return {"type": "video", "nsfw": nsfw}
 
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported file type")
 
-if __name__ == "__main__":
-    asyncio.run(main())
+    finally:
+        if os.path.exists(path):
+            os.remove(path)