Filetolink12 / bot.py
saske560's picture
Upload 5 files
98cd0cd verified
Raw History Blame Contribute Delete
13.4 kB
import asyncio
import html
import logging
import mimetypes
import os
import re
import time
import uuid
from pathlib import Path
from typing import Optional, Tuple
from urllib.parse import unquote, urlparse, quote
from email.message import Message as EmailMessage
from aiohttp import ClientSession, ClientTimeout
from dotenv import load_dotenv
from pyrogram import Client, filters
from pyrogram.types import Message
load_dotenv()
logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(name)s | %(message)s")
log = logging.getLogger("file2link")
API_ID = int(os.getenv("API_ID", "0"))
API_HASH = os.getenv("API_HASH", "")
BOT_TOKEN = os.getenv("BOT_TOKEN", "")
BASE_URL = os.getenv("BASE_URL", "").rstrip("/")
SPACE_HOST = os.getenv("SPACE_HOST", "").strip()
if not BASE_URL and SPACE_HOST:
BASE_URL = f"https://{SPACE_HOST}".rstrip("/")
DOWNLOAD_DIR = Path(os.getenv("DOWNLOAD_DIR", "/app/downloads"))
MAX_FILE_MB = int(os.getenv("MAX_FILE_MB", "1900"))
KEEP_HOURS = int(os.getenv("KEEP_HOURS", "24"))
DOWNLOAD_DIR.mkdir(parents=True, exist_ok=True)
if not API_ID or not API_HASH or not BOT_TOKEN:
raise RuntimeError("Faltan API_ID, API_HASH o BOT_TOKEN en variables de entorno.")
bot = Client(
"file2link_bot",
api_id=API_ID,
api_hash=API_HASH,
bot_token=BOT_TOKEN,
workdir="/app/session",
in_memory=False,
)
SAFE_NAME_RE = re.compile(r"[^a-zA-Z0-9._() \-áéíóúÁÉÍÓÚñÑüÜ]+")
MEDIAFIRE_RE = re.compile(r"https?://(?:www\.)?mediafire\.com/\S+", re.I)
def human_size(num: int) -> str:
units = ["B", "KB", "MB", "GB", "TB"]
size = float(num or 0)
for unit in units:
if size < 1024 or unit == units[-1]:
return f"{size:.2f} {unit}" if unit != "B" else f"{int(size)} B"
size /= 1024
return f"{num} B"
def clean_name(name: str) -> str:
name = unquote(name or "file")
name = name.replace("/", "_").replace("\\", "_").replace("\x00", "")
name = SAFE_NAME_RE.sub("_", name).strip(" ._")
return name[:180] or "file"
def extension_from_mime(mime_type: Optional[str], default: str = "") -> str:
if not mime_type:
return default
overrides = {
"image/jpeg": ".jpg", "audio/ogg": ".ogg", "video/mp4": ".mp4",
"image/webp": ".webp", "application/x-tgsticker": ".tgs",
"video/webm": ".webm", "application/gzip": ".gz",
}
return overrides.get(mime_type.lower()) or mimetypes.guess_extension(mime_type) or default
def ensure_extension(name: str, mime_type: Optional[str] = None, default_ext: str = "") -> str:
name = clean_name(name)
if Path(name).suffix:
return name
ext = extension_from_mime(mime_type, default_ext)
if ext and not ext.startswith("."):
ext = "." + ext
return clean_name(name + (ext or ""))
def public_link(token: str, original_name: str) -> str:
safe_name = quote(clean_name(original_name), safe="._-()")
return f"{BASE_URL}/file/{token}/{safe_name}" if BASE_URL else f"/file/{token}/{safe_name}"
def get_media_info(message: Message) -> Tuple[Optional[object], Optional[str], int]:
media = message.document or message.video or message.audio or message.voice or message.video_note or message.photo or message.animation or message.sticker
if not media:
return None, None, 0
file_name = getattr(media, "file_name", None)
file_size = getattr(media, "file_size", 0) or 0
mime_type = getattr(media, "mime_type", None)
if message.photo:
file_name = ensure_extension(file_name or f"photo_{message.id}", "image/jpeg", ".jpg")
elif message.voice:
file_name = ensure_extension(file_name or f"voice_{message.id}", mime_type or "audio/ogg", ".ogg")
elif message.video_note:
file_name = ensure_extension(file_name or f"video_note_{message.id}", mime_type or "video/mp4", ".mp4")
elif message.sticker:
if not file_name:
if getattr(media, "is_animated", False):
file_name = f"sticker_{message.id}.tgs"
elif getattr(media, "is_video", False):
file_name = f"sticker_{message.id}.webm"
else:
file_name = f"sticker_{message.id}.webp"
file_name = ensure_extension(file_name, mime_type, Path(file_name).suffix or ".webp")
elif message.video:
file_name = ensure_extension(file_name or f"video_{message.id}", mime_type or "video/mp4", ".mp4")
elif message.animation:
file_name = ensure_extension(file_name or f"animation_{message.id}", mime_type or "video/mp4", ".mp4")
elif message.audio:
file_name = ensure_extension(file_name or f"audio_{message.id}", mime_type or "audio/mpeg", ".mp3")
elif message.document:
file_name = ensure_extension(file_name or f"file_{message.id}", mime_type, "")
return media, clean_name(file_name or f"file_{message.id}"), file_size
async def progress(current: int, total: int, status: Message, started: float, state: dict, label: str):
now = time.time()
if now - state.get("last", 0) < 3 and current != total:
return
state["last"] = now
percent = current / total * 100 if total else 0
speed = current / max(now - started, 1)
try:
await status.edit_text(f"{label}\n{percent:.1f}% — {human_size(current)} / {human_size(total)}\nVelocidad: {human_size(int(speed))}/s")
except Exception:
pass
@bot.on_message(filters.private, group=-1000)
async def debug_incoming(_, message: Message):
log.info("📩 Mensaje recibido chat=%s id=%s text=%r media=%s", message.chat.id if message.chat else None, message.id, message.text, bool(message.media))
@bot.on_message(filters.private & (filters.command(["start", "help"], prefixes=["/", "!", "."]) | filters.regex(r"^(?:/|!|\.)?(start|help)(?:@\w+)?$")), group=-10)
async def start_cmd(_, message: Message):
await message.reply_text(
"👋 Estoy activo.\n\n"
"Envíame archivo, video, foto, audio, sticker, GIF o nota y te doy un link directo del Hugging Face Space.\n\n"
"También puedes enviarme un link de MediaFire: lo descargo, conservo el nombre original, te doy link y trato de reenviártelo."
)
@bot.on_message(filters.private & filters.text & filters.regex(MEDIAFIRE_RE), group=0)
async def mediafire_handler(_, message: Message):
url = MEDIAFIRE_RE.search(message.text or "").group(0).rstrip(").,;")
status = await message.reply_text("⏳ Analizando link de MediaFire...")
try:
path, original_name, size = await download_mediafire(url, status)
except Exception as exc:
log.exception("Error descargando MediaFire")
await status.edit_text(f"❌ No pude descargar ese MediaFire:\n`{exc}`")
return
token = path.name.split("_", 1)[0]
link = public_link(token, original_name)
caption = f"✅ MediaFire descargado\n📦 {original_name}\n📏 {human_size(size)}\n🔗 {link}"
try:
await status.edit_text("⬆️ Subiendo a Telegram...")
await bot.send_document(message.chat.id, str(path), file_name=original_name, caption=caption[:1024], progress=progress, progress_args=(status, time.time(), {"last": 0}, "⬆️ Subiendo a Telegram..."))
await status.delete()
except Exception as exc:
await status.edit_text(f"✅ Descargado, pero Telegram no me dejó reenviarlo.\n\n📦 `{original_name}`\n📏 {human_size(size)}\n🔗 {link}\n\nError: `{exc}`")
@bot.on_message(filters.private & (filters.document | filters.video | filters.audio | filters.voice | filters.photo | filters.animation | filters.sticker | filters.video_note), group=1)
async def media_handler(_, message: Message):
media, original_name, file_size = get_media_info(message)
if not media:
await message.reply_text("❌ No pude detectar ese archivo.")
return
if file_size and file_size > MAX_FILE_MB * 1024 * 1024:
await message.reply_text(f"❌ Archivo muy grande. Límite: {MAX_FILE_MB} MB.")
return
status = await message.reply_text("⏳ Descargando desde Telegram al servidor...")
token = uuid.uuid4().hex
path = DOWNLOAD_DIR / f"{token}_{original_name}"
try:
saved = await bot.download_media(message, file_name=str(path), progress=progress, progress_args=(status, time.time(), {"last": 0}, "⬇️ Descargando al servidor..."))
if saved and Path(saved) != path:
path = Path(saved)
except Exception as exc:
log.exception("Error descargando Telegram")
await status.edit_text(f"❌ Error descargando:\n`{exc}`")
return
if not path.exists():
await status.edit_text("❌ La descarga falló o no se guardó.")
return
size = path.stat().st_size
link = public_link(token, original_name)
await status.edit_text(f"✅ Archivo listo.\n\n📦 Nombre: `{original_name}`\n📏 Tamaño: `{human_size(size)}`\n🔗 Link directo:\n{link}\n\n✅ Soporta reanudar descarga con ADM/1DM/IDM.")
@bot.on_message(filters.private & filters.text, group=100)
async def text_fallback(_, message: Message):
await message.reply_text("✅ El bot está leyendo mensajes. Envíame un archivo/media o un link de MediaFire.")
@bot.on_message(filters.private, group=101)
async def any_fallback(_, message: Message):
if not message.text and not message.media:
await message.reply_text("✅ Te leí, pero ese tipo de mensaje no lo puedo convertir.")
def filename_from_headers_or_url(headers, url: str, fallback: str = "mediafire_file") -> str:
cd = headers.get("Content-Disposition", "") if headers else ""
content_type = headers.get("Content-Type", "").split(";", 1)[0].strip() if headers else ""
if cd:
msg = EmailMessage(); msg["content-disposition"] = cd
filename = msg.get_filename()
if filename:
return ensure_extension(filename, content_type)
name = Path(unquote(urlparse(str(url)).path)).name
if not name or name.lower() in {"download", "file"}:
name = fallback
return ensure_extension(name, content_type)
async def get_mediafire_direct_url(session: ClientSession, mediafire_url: str) -> str:
async with session.get(mediafire_url, allow_redirects=True) as resp:
text = await resp.text(errors="ignore")
if resp.status >= 400:
raise RuntimeError(f"MediaFire respondió HTTP {resp.status}")
patterns = [
r'id=["\']downloadButton["\'][^>]+href=["\']([^"\']+)',
r'href=["\'](https?://download[^"\']+mediafire[^"\']+)["\']',
r'href=["\'](https?://[^"\']*mediafire\.com/[^"\']*/[^"\']+)["\']',
]
for pat in patterns:
m = re.search(pat, text, flags=re.I | re.S)
if m:
return html.unescape(m.group(1))
raise RuntimeError("No encontré el botón de descarga. Puede ser carpeta, privado o protegido.")
async def download_mediafire(url: str, status: Message) -> Tuple[Path, str, int]:
timeout = ClientTimeout(total=None, connect=45, sock_read=180)
max_bytes = MAX_FILE_MB * 1024 * 1024
async with ClientSession(timeout=timeout, headers={"User-Agent": "Mozilla/5.0"}) as session:
direct = await get_mediafire_direct_url(session, url)
async with session.get(direct, allow_redirects=True) as resp:
if resp.status >= 400:
raise RuntimeError(f"HTTP {resp.status}")
total = int(resp.headers.get("Content-Length", "0") or 0)
if total and total > max_bytes:
raise RuntimeError(f"Archivo demasiado grande. Límite: {MAX_FILE_MB} MB")
original_name = filename_from_headers_or_url(resp.headers, str(resp.url), "mediafire_file")
token = uuid.uuid4().hex
path = DOWNLOAD_DIR / f"{token}_{original_name}"
downloaded = 0; started = time.time(); state = {"last": 0}
with path.open("wb") as f:
async for chunk in resp.content.iter_chunked(1024 * 1024):
if not chunk:
continue
downloaded += len(chunk)
if downloaded > max_bytes:
path.unlink(missing_ok=True)
raise RuntimeError(f"Archivo demasiado grande. Límite: {MAX_FILE_MB} MB")
f.write(chunk)
await progress(downloaded, total, status, started, state, "⬇️ Descargando desde MediaFire...")
return path, original_name, path.stat().st_size
async def cleanup_loop():
while True:
try:
cutoff = time.time() - KEEP_HOURS * 3600
for p in DOWNLOAD_DIR.glob("*"):
if p.is_file() and p.stat().st_mtime < cutoff:
p.unlink(missing_ok=True)
except Exception:
log.exception("Error limpiando archivos")
await asyncio.sleep(1800)
_cleanup_task = None
async def start_bot():
global _cleanup_task
me = await bot.get_me() if bot.is_connected else None
await bot.start()
me = await bot.get_me()
log.info("✅ Bot iniciado como @%s id=%s", me.username, me.id)
_cleanup_task = asyncio.create_task(cleanup_loop())
async def stop_bot():
global _cleanup_task
if _cleanup_task:
_cleanup_task.cancel()
if bot.is_connected:
await bot.stop()
log.info("Bot detenido")