| import os |
| import re |
| import shutil |
| import asyncio |
| import logging |
| import json |
|
|
| from pyrogram import Client, filters |
| from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, Message |
| from pyrogram.errors import MessageNotModified |
|
|
| logger = logging.getLogger(__name__) |
|
|
| |
|
|
| @Client.on_message(filters.command("trim")) |
| async def trim_command(client, message: Message): |
| """Must be a reply to a video/audio/document message.""" |
| if not message.reply_to_message: |
| return await message.reply_text( |
| "⚠️ **Reply to a video/audio file** with /trim to start.") |
|
|
| reply = message.reply_to_message |
| if not (reply.video or reply.audio or reply.document): |
| return await message.reply_text("⚠️ Replied message must contain a video or audio file.") |
|
|
| keyboard = InlineKeyboardMarkup([[ |
| InlineKeyboardButton("✂️ Split by Parts", callback_data=f"trim_parts_{reply.id}"), |
| InlineKeyboardButton("⏱ Trim by Time", callback_data=f"trim_time_{reply.id}"), |
| ]]) |
| await message.reply_text( |
| "🎬 **Trim / Split**\n\nChoose an operation:", |
| reply_markup=keyboard, quote=True) |
|
|
|
|
| |
|
|
| @Client.on_callback_query(filters.regex(r"^trim_parts_")) |
| async def cb_trim_parts(client, query): |
| m = re.match(r"^trim_parts_(\d+)$", query.data) |
| if not m: |
| return |
| orig_msg_id = int(m.group(1)) |
| user_id = query.from_user.id |
| await query.message.edit_text("🔢 **How many equal parts** do you want to split into?\n\n_Send a number (2–20):_") |
|
|
| try: |
| from pyromod.exceptions import ListenerTimeout |
| resp = await client.listen( |
| chat_id=query.message.chat.id, user_id=user_id, filters=filters.text, timeout=120) |
| n_text = resp.text.strip() |
| if not n_text.isdigit() or not (2 <= int(n_text) <= 20): |
| await resp.delete() |
| return await query.message.edit_text("❌ Please send a number between 2 and 20.") |
| n_parts = int(n_text) |
| await resp.delete() |
| except ListenerTimeout: |
| try: |
| return await query.message.edit_text("⏳ Timed out. Send /trim again.") |
| except MessageNotModified: |
| return |
|
|
| orig = await client.get_messages(query.message.chat.id, orig_msg_id) |
| await _do_split_parts(client, query.message, orig, n_parts) |
|
|
|
|
| |
|
|
| @Client.on_callback_query(filters.regex(r"^trim_time_")) |
| async def cb_trim_time(client, query): |
| m = re.match(r"^trim_time_(\d+)$", query.data) |
| if not m: |
| return |
| orig_msg_id = int(m.group(1)) |
| user_id = query.from_user.id |
| await query.message.edit_text( |
| "⏱ **Enter Start and End timestamps**\n\nFormat: `HH:MM:SS - HH:MM:SS`\nExample: `00:01:30 - 00:05:00`") |
|
|
| try: |
| from pyromod.exceptions import ListenerTimeout |
| resp = await client.listen( |
| chat_id=query.message.chat.id, user_id=user_id, filters=filters.text, timeout=120) |
| ts_text = resp.text.strip() |
| await resp.delete() |
| except ListenerTimeout: |
| try: |
| return await query.message.edit_text("⏳ Timed out. Send /trim again.") |
| except MessageNotModified: |
| return |
|
|
| |
| ts_text = ts_text.replace(" to ", " - ") |
| sep_match = re.split(r'\s*-\s*', ts_text, maxsplit=1) |
| if len(sep_match) != 2: |
| return await query.message.edit_text( |
| "❌ Invalid format. Use: `HH:MM:SS - HH:MM:SS`") |
|
|
| start_ts, end_ts = sep_match[0].strip(), sep_match[1].strip() |
| orig = await client.get_messages(query.message.chat.id, orig_msg_id) |
| await _do_trim_time(client, query.message, orig, start_ts, end_ts) |
|
|
|
|
| |
|
|
| async def _get_duration(file_path: str) -> float: |
| """Return duration in seconds via ffprobe.""" |
| ffprobe = shutil.which('ffprobe') |
| if not ffprobe: |
| return 0.0 |
| cmd = [ffprobe, '-v', 'quiet', '-print_format', 'json', |
| '-show_format', file_path] |
| proc = await asyncio.create_subprocess_exec( |
| *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) |
| stdout, _ = await proc.communicate() |
| try: |
| import json |
| data = json.loads(stdout.decode()) |
| return float(data.get('format', {}).get('duration', 0)) |
| except Exception: |
| return 0.0 |
|
|
|
|
| async def _download_media_message(client, message, status_msg): |
| """Download media from a message and return the local path.""" |
| if message.video: |
| ext = ".mp4" |
| elif message.audio: |
| ext = f".{message.audio.mime_type.split('/')[-1]}" if message.audio.mime_type else ".mp3" |
| elif message.document: |
| name = message.document.file_name or "file" |
| ext = os.path.splitext(name)[1] or ".mkv" |
| else: |
| ext = ".mp4" |
|
|
| path = f"downloads/trim_{message.id}{ext}" |
| os.makedirs("downloads", exist_ok=True) |
| try: |
| await status_msg.edit("**Downloading for processing...**") |
| except MessageNotModified: |
| pass |
| file_path = await client.download_media(message, file_name=path) |
| return file_path |
|
|
|
|
| async def _do_split_parts(client, status_msg, orig_msg, n_parts: int): |
| ffmpeg = shutil.which('ffmpeg') |
| if not ffmpeg: |
| try: |
| return await status_msg.edit("❌ FFmpeg not found on this server.") |
| except MessageNotModified: |
| return |
|
|
| file_path = await _download_media_message(client, orig_msg, status_msg) |
| if not file_path: |
| try: |
| return await status_msg.edit("❌ Could not download the file.") |
| except MessageNotModified: |
| return |
|
|
| try: |
| duration = await _get_duration(file_path) |
| if duration <= 0: |
| try: |
| return await status_msg.edit("❌ Could not determine file duration.") |
| except MessageNotModified: |
| return |
|
|
| part_duration = duration / n_parts |
| base, ext = os.path.splitext(file_path) |
| output_paths = [] |
|
|
| try: |
| await status_msg.edit(f"✂️ Splitting into **{n_parts} parts**...") |
| except MessageNotModified: |
| pass |
|
|
| for i in range(n_parts): |
| start = i * part_duration |
| out_path = f"{base}_part{i+1}{ext}" |
| cmd = [ |
| ffmpeg, '-y', |
| '-ss', str(start), |
| '-i', file_path, |
| '-t', str(part_duration), |
| '-c', 'copy', |
| '-loglevel', 'error', |
| out_path |
| ] |
| proc = await asyncio.create_subprocess_exec( |
| *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) |
| _, stderr = await proc.communicate() |
| if proc.returncode != 0: |
| logger.error(f"ffmpeg split error part {i+1}: {stderr.decode()}") |
| await status_msg.edit(f"❌ FFmpeg error on part {i+1}: {stderr.decode()[:200]}") |
| return |
| output_paths.append(out_path) |
|
|
| await status_msg.edit(f"📤 Uploading **{n_parts} parts**...") |
| for i, out_path in enumerate(output_paths): |
| part_name = f"Part {i+1} of {n_parts}{ext}" |
| await client.send_document( |
| chat_id=status_msg.chat.id, |
| document=out_path, |
| file_name=part_name, |
| caption=f"✂️ Part {i+1}/{n_parts}" |
| ) |
| os.remove(out_path) |
|
|
| await status_msg.edit("✅ All parts uploaded!") |
| finally: |
| if os.path.exists(file_path): |
| os.remove(file_path) |
|
|
|
|
| async def _do_trim_time(client, status_msg, orig_msg, start_ts: str, end_ts: str): |
| ffmpeg = shutil.which('ffmpeg') |
| if not ffmpeg: |
| try: |
| return await status_msg.edit("❌ FFmpeg not found on this server.") |
| except MessageNotModified: |
| return |
|
|
| file_path = await _download_media_message(client, orig_msg, status_msg) |
| if not file_path: |
| try: |
| return await status_msg.edit("❌ Could not download the file.") |
| except MessageNotModified: |
| return |
|
|
| try: |
| base, ext = os.path.splitext(file_path) |
| out_path = f"{base}_trimmed{ext}" |
|
|
| try: |
| await status_msg.edit(f"✂️ Trimming `{start_ts}` → `{end_ts}`...") |
| except MessageNotModified: |
| pass |
|
|
| cmd = [ |
| ffmpeg, '-y', |
| '-ss', start_ts, |
| '-to', end_ts, |
| '-i', file_path, |
| '-c', 'copy', |
| '-loglevel', 'error', |
| out_path |
| ] |
| proc = await asyncio.create_subprocess_exec( |
| *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE) |
| _, stderr = await proc.communicate() |
| if proc.returncode != 0: |
| return await status_msg.edit(f"❌ FFmpeg error: {stderr.decode()[:300]}") |
|
|
| await status_msg.edit("📤 Uploading trimmed file...") |
|
|
| trimmed_name = f"Trimmed_{start_ts.replace(':','-')}_{end_ts.replace(':','-')}{ext}" |
| if orig_msg.video: |
| await client.send_video( |
| chat_id=status_msg.chat.id, |
| video=out_path, |
| file_name=trimmed_name, |
| caption=f"✂️ Trimmed: `{start_ts}` → `{end_ts}`" |
| ) |
| else: |
| await client.send_document( |
| chat_id=status_msg.chat.id, |
| document=out_path, |
| file_name=trimmed_name, |
| caption=f"✂️ Trimmed: `{start_ts}` → `{end_ts}`" |
| ) |
|
|
| if os.path.exists(out_path): |
| os.remove(out_path) |
|
|
| await status_msg.edit("✅ Trimmed file uploaded!") |
| finally: |
| if os.path.exists(file_path): |
| os.remove(file_path) |
|
|
