Update app.py

app.py

@@ -1,83 +1,235 @@
-import os
-import threading
+"""
+Telegram File Method Converter Bot
+===================================
+Send any file → bot stores the file_id
+Use /as <method> to resend it using a different Telegram method.
+
+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
-from fastapi import FastAPI
+import os
 
-TOKEN = "8749818258:AAFls-Y46BXW-b94E8-HQTDCMosYfeEmB8E"
-bot = telebot.TeleBot(TOKEN)
+# BOT_TOKEN = os.environ.get("BOT_TOKEN", "YOUR_BOT_TOKEN_HERE")
 
-app = FastAPI()
+# bot = telebot.TeleBot(BOT_TOKEN)
 
-user_files = {}
+# ── per-user state ────────────────────────────────────────────────────────────
+# { user_id: {"file_id": str, "original_method": str, "file_name": str} }
+user_files: dict[int, dict] = {}
 
-# Health endpoint (HF requirement)
-@app.get("/")
-def root():
-    return {"status": "ok"}
+# ── method → (send_func_name, extra_kwargs) ──────────────────────────────────
+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",    {}),
+}
+
+# Compatibility warnings (source → target)
+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.",
+}
+
+
+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")
 
-# Start polling in background
-@app.on_event("startup")
-def startup():
-    threading.Thread(target=bot.infinity_polling, daemon=True).start()
 
-# Store file
 @bot.message_handler(content_types=[
-    'document','video','audio','photo','voice','animation'
+    "photo", "video", "audio", "voice", "video_note",
+    "animation", "sticker", "document"
 ])
-def handle_file(message):
-    user_files[message.from_user.id] = message
+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,
+    }
+
+    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")
+
+
+@bot.message_handler(commands=["as"])
+def cmd_as(message: telebot.types.Message):
+    uid = message.from_user.id
+
+    if uid not in user_files:
+        bot.reply_to(message, "❌ Send me a file first, then use /as <method>.")
+        return
+
+    parts = message.text.strip().split()
+    if len(parts) < 2:
+        bot.reply_to(message, "Usage: `/as <method>`\nExample: `/as video`", parse_mode="Markdown")
+        return
+
+    target_method = parts[1].lower()
+
+    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"
+        )
+
+
+@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.")
+
+
+@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,
-        "File received.\nReply with:\n"
-        "document / video / audio / photo / voice / animation"
+        f"*Supported methods:*\n{methods_list}",
+        parse_mode="Markdown"
     )
 
-# Convert by downloading via TeleBot internal system
-@bot.message_handler(func=lambda m: True)
-def convert(message):
-    desired = message.text.lower().strip()
 
-    if message.from_user.id not in user_files:
-        bot.reply_to(message, "Send a file first.")
-        return
+# ── entry point ───────────────────────────────────────────────────────────────
+# if __name__ == "__main__":
+#     print("Bot is running...")
+#     bot.infinity_polling()
 
-    original = user_files[message.from_user.id]
-
-    # Extract file_id safely
-    file_id = None
-    if original.document:
-        file_id = original.document.file_id
-    elif original.video:
-        file_id = original.video.file_id
-    elif original.audio:
-        file_id = original.audio.file_id
-    elif original.photo:
-        file_id = original.photo[-1].file_id
-    elif original.voice:
-        file_id = original.voice.file_id
-    elif original.animation:
-        file_id = original.animation.file_id
+app = FastAPI()
 
-    if not file_id:
-        bot.reply_to(message, "Unsupported type.")
-        return
+@app.get("/")
+def root():                       # ② health‑check hits this → must return 200 quickly
+    return {"status": "ok"}
 
-    # 🔥 This is key:
-    # TeleBot handles token internally.
-    file_info = bot.get_file(file_id)
-    file_bytes = bot.download_file(file_info.file_path)
-
-    if desired == "video":
-        bot.send_video(message.chat.id, file_bytes)
-    elif desired == "audio":
-        bot.send_audio(message.chat.id, file_bytes)
-    elif desired == "document":
-        bot.send_document(message.chat.id, file_bytes)
-    elif desired == "photo":
-        bot.send_photo(message.chat.id, file_bytes)
-    elif desired == "voice":
-        bot.send_voice(message.chat.id, file_bytes)
-    elif desired == "animation":
-        bot.send_animation(message.chat.id, file_bytes)
-    else:
-        bot.reply_to(message, "Unknown format.")
+@app.on_event("startup")
+def startup():
+    # Launch the bot *after* Uvicorn has started
+    threading.Thread(target=bot.infinity_polling, daemon=True).start()