Update app.py

app.py

@@ -1,235 +1,165 @@
-"""
-Telegram File Method Converter Bot
-===================================
-Send any file → bot stores the file_id
-Use /as <method> to resend it using a different Telegram method.
+import logging
+from fastapi import FastAPI, Request
 
-Supported methods:
-  photo, video, audio, document, voice, video_note,
-  animation, sticker
-
-Usage:
-  1. Send any file/media to the bot.
-  2. Then send:  /as video
-     The bot will forward the same file using send_video()
-"""
-
-import telebot
-import os
-
-# BOT_TOKEN = os.environ.get("BOT_TOKEN", "YOUR_BOT_TOKEN_HERE")
-
-# bot = telebot.TeleBot(BOT_TOKEN)
+app = FastAPI()
+logging.basicConfig(level=logging.INFO)
 
-# ── per-user state ────────────────────────────────────────────────────────────
+# ── per-user storage ─────────────────────────────────────────────
 # { user_id: {"file_id": str, "original_method": str, "file_name": str} }
-user_files: dict[int, dict] = {}
+user_files = {}
 
-# ── method → (send_func_name, extra_kwargs) ──────────────────────────────────
+# ── method map ───────────────────────────────────────────────────
 METHOD_MAP = {
-    "photo":      ("send_photo",      {}),
-    "video":      ("send_video",      {}),
-    "audio":      ("send_audio",      {}),
-    "document":   ("send_document",   {}),
-    "voice":      ("send_voice",      {}),
-    "video_note": ("send_video_note", {}),
-    "animation":  ("send_animation",  {}),
-    "sticker":    ("send_sticker",    {}),
+    "photo":      ("sendPhoto", "photo"),
+    "video":      ("sendVideo", "video"),
+    "audio":      ("sendAudio", "audio"),
+    "document":   ("sendDocument", "document"),
+    "voice":      ("sendVoice", "voice"),
+    "video_note": ("sendVideoNote", "video_note"),
+    "animation":  ("sendAnimation", "animation"),
+    "sticker":    ("sendSticker", "sticker"),
 }
 
-# Compatibility warnings (source → target)
+# ── warnings ─────────────────────────────────────────────────────
 WARNINGS = {
-    ("photo",  "video"):      "⚠️ Photo→Video: Telegram may reject this; a photo is not a video stream.",
-    ("video",  "photo"):      "⚠️ Video→Photo: Telegram may reject this; a video is not a static image.",
-    ("audio",  "video"):      "⚠️ Audio→Video: No visual stream — Telegram will likely reject this.",
-    ("audio",  "voice"):      "⚠️ Audio→Voice: Must be OGG/Opus; other formats may fail.",
-    ("voice",  "audio"):      "⚠️ Voice→Audio: Should work but voice notes are OGG-encoded.",
-    ("video",  "video_note"): "⚠️ Video→VideoNote: Must be a square MP4 ≤1 min; may fail otherwise.",
-    ("document","photo"):     "⚠️ Document→Photo: Only works if the file is an actual image.",
-    ("document","video"):     "⚠️ Document→Video: Only works if the file is an actual video.",
-    ("document","audio"):     "⚠️ Document→Audio: Only works if the file is an actual audio file.",
-    ("document","sticker"):   "⚠️ Document→Sticker: Must be a valid WebP/TGS sticker file.",
+    ("photo", "video"): "⚠️ Photo→Video may fail.",
+    ("video", "photo"): "⚠️ Video→Photo may fail.",
+    ("audio", "video"): "⚠️ Audio→Video likely rejected.",
+    ("audio", "voice"): "⚠️ Audio→Voice must be OGG/Opus.",
+    ("voice", "audio"): "⚠️ Voice→Audio usually works.",
+    ("video", "video_note"): "⚠️ Video→VideoNote must be square MP4 ≤1 min.",
+    ("document", "photo"): "⚠️ Document→Photo works only if image.",
+    ("document", "video"): "⚠️ Document→Video works only if real video.",
+    ("document", "audio"): "⚠️ Document→Audio works only if audio.",
+    ("document", "sticker"): "⚠️ Must be valid sticker file.",
 }
 
 
-def detect_method(message: telebot.types.Message) -> tuple[str, str]:
-    """Return (method_name, file_id) for whatever was sent."""
-    if message.photo:
-        return "photo", message.photo[-1].file_id
-    if message.video:
-        return "video", message.video.file_id
-    if message.audio:
-        return "audio", message.audio.file_id
-    if message.voice:
-        return "voice", message.voice.file_id
-    if message.video_note:
-        return "video_note", message.video_note.file_id
-    if message.animation:
-        return "animation", message.animation.file_id
-    if message.sticker:
-        return "sticker", message.sticker.file_id
-    if message.document:
-        return "document", message.document.file_id
-    return None, None
-
-
-def send_as(chat_id: int, file_id: str, method: str, caption: str = None):
-    """Call the appropriate send_* method with the given file_id."""
-    func_name, extra = METHOD_MAP[method]
-    func = getattr(bot, func_name)
-
-    # Build kwargs
-    kwargs = {**extra}
-
-    # The second positional argument name varies per method
-    FILE_ARG = {
-        "send_photo":      "photo",
-        "send_video":      "video",
-        "send_audio":      "audio",
-        "send_document":   "document",
-        "send_voice":      "voice",
-        "send_video_note": "video_note",
-        "send_animation":  "animation",
-        "send_sticker":    "sticker",
-    }
-    file_arg = FILE_ARG[func_name]
-    kwargs[file_arg] = file_id
-
-    # Only some methods support caption
-    if caption and method not in ("sticker", "video_note"):
-        kwargs["caption"] = caption
-
-    func(chat_id, **kwargs)
-
-
-# ── handlers ──────────────────────────────────────────────────────────────────
-
-@bot.message_handler(commands=["start", "help"])
-def cmd_start(message: telebot.types.Message):
-    bot.reply_to(message, (
-        "👋 *File Method Converter Bot*\n\n"
-        "Send me *any file or media* and I'll remember it.\n"
-        "Then use:\n"
-        "  `/as <method>` — resend it with a different Telegram method\n\n"
-        "*Available methods:*\n"
-        "`photo` · `video` · `audio` · `document`\n"
-        "`voice` · `video_note` · `animation` · `sticker`\n\n"
-        "Example: after sending a video file as a document, type\n"
-        "`/as video`\n\n"
-        "⚠️ The bot will warn you about potentially incompatible conversions "
-        "but will *always try anyway*."
-    ), parse_mode="Markdown")
-
-
-@bot.message_handler(content_types=[
-    "photo", "video", "audio", "voice", "video_note",
-    "animation", "sticker", "document"
-])
-def receive_file(message: telebot.types.Message):
-    method, file_id = detect_method(message)
-    if not file_id:
-        bot.reply_to(message, "❌ Could not extract a file_id from this message.")
-        return
-
-    # Get a friendly name if available
-    file_name = ""
-    if message.document and message.document.file_name:
-        file_name = f" (`{message.document.file_name}`)"
-
-    user_files[message.from_user.id] = {
-        "file_id": file_id,
-        "original_method": method,
-        "file_name": file_name,
+# ── helper response builders ─────────────────────────────────────
+def send_message(chat_id, text, parse_mode="Markdown"):
+    return {
+        "method": "sendMessage",
+        "chat_id": chat_id,
+        "text": text,
+        "parse_mode": parse_mode
     }
 
-    bot.reply_to(message, (
-        f"✅ Got your *{method}*{file_name}!\n\n"
-        f"Now send `/as <method>` to resend it using a different method.\n"
-        f"Available: `photo`, `video`, `audio`, `document`, `voice`, "
-        f"`video_note`, `animation`, `sticker`"
-    ), parse_mode="Markdown")
 
+def send_media(chat_id, method_name, field_name, file_id, caption=None):
+    response = {
+        "method": method_name,
+        "chat_id": chat_id,
+        field_name: file_id,
+    }
+    if caption and field_name not in ("sticker", "video_note"):
+        response["caption"] = caption
+        response["parse_mode"] = "Markdown"
+    return response
+
+
+# ── detect incoming file ─────────────────────────────────────────
+def detect_method(message):
+    if "photo" in message:
+        return "photo", message["photo"][-1]["file_id"], ""
+    if "video" in message:
+        return "video", message["video"]["file_id"], ""
+    if "audio" in message:
+        return "audio", message["audio"]["file_id"], ""
+    if "voice" in message:
+        return "voice", message["voice"]["file_id"], ""
+    if "video_note" in message:
+        return "video_note", message["video_note"]["file_id"], ""
+    if "animation" in message:
+        return "animation", message["animation"]["file_id"], ""
+    if "sticker" in message:
+        return "sticker", message["sticker"]["file_id"], ""
+    if "document" in message:
+        name = message["document"].get("file_name", "")
+        return "document", message["document"]["file_id"], f" (`{name}`)"
+    return None, None, ""
+
+
+# ── webhook endpoint ─────────────────────────────────────────────
+@app.post("/webhook")
+async def telegram_webhook(request: Request):
+    update = await request.json()
+    logging.info(f"Update: {update}")
+
+    if "message" not in update:
+        return {"status": "ok"}
+
+    message = update["message"]
+    chat_id = message["chat"]["id"]
+    user_id = message["from"]["id"]
+    text = message.get("text", "")
+
+    # ── Commands ────────────────────���──────────────────────────
+    if text.startswith("/start") or text.startswith("/help"):
+        return send_message(chat_id,
+            "👋 *File Method Converter Bot*\n\n"
+            "Send any file.\n"
+            "Then use `/as <method>`.\n\n"
+            "*Methods:*\n"
+            "`photo` `video` `audio` `document`\n"
+            "`voice` `video_note` `animation` `sticker`\n\n"
+            "⚠️ No real conversion occurs."
+        )
 
-@bot.message_handler(commands=["as"])
-def cmd_as(message: telebot.types.Message):
-    uid = message.from_user.id
+    if text.startswith("/methods"):
+        methods = "\n".join(f"• `{m}`" for m in METHOD_MAP)
+        return send_message(chat_id, f"*Supported methods:*\n{methods}")
 
-    if uid not in user_files:
-        bot.reply_to(message, "❌ Send me a file first, then use /as <method>.")
-        return
+    if text.startswith("/clear"):
+        user_files.pop(user_id, None)
+        return send_message(chat_id, "🗑️ Cleared. Send a new file.")
 
-    parts = message.text.strip().split()
-    if len(parts) < 2:
-        bot.reply_to(message, "Usage: `/as <method>`\nExample: `/as video`", parse_mode="Markdown")
-        return
+    # ── /as command ────────────────────────────────────────────
+    if text.startswith("/as"):
+        if user_id not in user_files:
+            return send_message(chat_id, "❌ Send a file first.")
 
-    target_method = parts[1].lower()
+        parts = text.split()
+        if len(parts) < 2:
+            return send_message(chat_id, "Usage: `/as <method>`")
 
-    if target_method not in METHOD_MAP:
-        bot.reply_to(
-            message,
-            f"❌ Unknown method `{target_method}`.\n"
-            f"Choose from: `" + "`, `".join(METHOD_MAP.keys()) + "`",
-            parse_mode="Markdown"
-        )
-        return
-
-    info = user_files[uid]
-    file_id = info["file_id"]
-    original_method = info["original_method"]
-    file_name = info.get("file_name", "")
-
-    # Check for warning
-    warning = WARNINGS.get((original_method, target_method), "")
-    if original_method == target_method:
-        warning = "ℹ️ Source and target method are the same — forwarding anyway."
-
-    # Send warning first (if any)
-    if warning:
-        bot.reply_to(message, warning)
-
-    # Try sending
-    try:
-        caption = f"📎 Re-sent as `{target_method}`{file_name} (was `{original_method}`)"
-        send_as(message.chat.id, file_id, target_method, caption)
-    except Exception as e:
-        bot.reply_to(
-            message,
-            f"❌ *Telegram rejected this conversion.*\n\n"
-            f"`{original_method}` → `{target_method}` failed:\n`{e}`\n\n"
-            f"Try a different method or send the file in its native format.",
-            parse_mode="Markdown"
-        )
+        target = parts[1].lower()
 
+        if target not in METHOD_MAP:
+            return send_message(chat_id,
+                "❌ Unknown method.\nChoose from:\n" +
+                ", ".join(f"`{m}`" for m in METHOD_MAP)
+            )
 
-@bot.message_handler(commands=["clear"])
-def cmd_clear(message: telebot.types.Message):
-    user_files.pop(message.from_user.id, None)
-    bot.reply_to(message, "🗑️ Cleared! Send a new file whenever you're ready.")
+        info = user_files[user_id]
+        original = info["original_method"]
+        file_id = info["file_id"]
+        file_name = info["file_name"]
 
+        warning = WARNINGS.get((original, target), "")
+        if original == target:
+            warning = "ℹ️ Source and target are same."
 
-@bot.message_handler(commands=["methods"])
-def cmd_methods(message: telebot.types.Message):
-    methods_list = "\n".join(f"  • `{m}`" for m in METHOD_MAP)
-    bot.reply_to(
-        message,
-        f"*Supported methods:*\n{methods_list}",
-        parse_mode="Markdown"
-    )
+        if warning:
+            return send_message(chat_id, warning)
 
+        method_name, field_name = METHOD_MAP[target]
 
-# ── entry point ───────────────────────────────────────────────────────────────
-# if __name__ == "__main__":
-#     print("Bot is running...")
-#     bot.infinity_polling()
+        caption = f"📎 Re-sent as `{target}`{file_name} (was `{original}`)"
+        return send_media(chat_id, method_name, field_name, file_id, caption)
 
-app = FastAPI()
+    # ── File reception ──────────────────────────────────────────
+    method, file_id, file_name = detect_method(message)
+
+    if file_id:
+        user_files[user_id] = {
+            "file_id": file_id,
+            "original_method": method,
+            "file_name": file_name,
+        }
 
-@app.get("/")
-def root():                       # ② health‑check hits this → must return 200 quickly
-    return {"status": "ok"}
+        return send_message(chat_id,
+            f"✅ Got your *{method}*{file_name}\n\n"
+            "Now send `/as <method>`."
+        )
 
-@app.on_event("startup")
-def startup():
-    # Launch the bot *after* Uvicorn has started
-    threading.Thread(target=bot.infinity_polling, daemon=True).start()
+    return {"status": "ok"}