Final code synchronization and cleanup

bot.py

@@ -3,9 +3,10 @@ import sys
 import logging
 from telegram import Update
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
-from video_utils import process_video_clip
+# CORRECT IMPORT: Ensure this function name exactly matches the definition in video_utils.py
+from video_utils import process_youtube_clip
 
-# Configure logging
+# --- Logging Configuration ---
 logging.basicConfig(
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
     level=logging.INFO
@@ -13,20 +14,15 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 # --- Configuration ---
-# ⚠️ WARNING: Hardcoding the token is strongly discouraged for security reasons.
-# Use Hugging Face Secrets instead.
-# If you must hardcode it, replace the line below with the token you provided:
-# TOKEN = "8575159633:AAHt8KYNKLrWKID8FOyZipEcPAxZ_zdjgg4" 
-#
-# If you are using Hugging Face Secrets (RECOMMENDED):
+# 1. Fetch token securely from environment variable (Hugging Face Secret)
 TOKEN = os.getenv("BOT_TOKEN") 
 
-# Ensure the token is available
+# 2. Safety check for the token
 if not TOKEN:
     logger.error("FATAL: BOT_TOKEN is missing. Please set it as a Hugging Face Secret.")
     sys.exit(1)
 
-# Ensure necessary directories exist
+# 3. Define local directories (Crucial for Docker environment)
 DOWNLOAD_DIR = "downloads"
 CLIP_DIR = "clips"
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
@@ -49,9 +45,8 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
     user_message = update.message.text
     user_id = update.effective_user.id
     
-    # 1. Simple check for a link and time format
-    if "youtu" not in user_message and "0:" not in user_message and "1:" not in user_message:
-        logger.info(f"User {user_id} sent non-link message: {user_message[:20]}...")
+    # Simple check to filter out non-link/non-command messages
+    if "youtu" not in user_message or "-" not in user_message:
         return
         
     try:
@@ -60,46 +55,54 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
         url = parts[0]
         time_range = parts[1] if len(parts) > 1 else None
 
-        if not time_range:
+        if not time_range or len(parts) < 2:
             await update.message.reply_text(
                 "Please specify the clip range (e.g., `1:30-2:00`) after the link."
             )
             return
 
+        await update.message.reply_text(f"Processing your request for {time_range}. This might take a few minutes...")
         logger.info(f"User {user_id} requested clip: {url} from {time_range}")
-        await update.message.reply_text(f"Processing your request for: {time_range}...")
         
-        # 2. Call the core processing function
-        final_clip_path = await process_video_clip(
+        # 4. Call the core processing function (MUST MATCH THE IMPORT NAME)
+        final_clip_path, caption = await process_youtube_clip(
             url, 
             time_range, 
             DOWNLOAD_DIR, 
             CLIP_DIR, 
             user_id,
-            logger # Pass logger for better tracking
+            logger
         )
 
         if final_clip_path:
-            # 3. Send the final video back
+            # 5. Send the final video back
             logger.info(f"Sending final clip to user {user_id}: {final_clip_path}")
+            
+            # Create a caption that includes the transcription
+            full_caption = f"✅ Clip ({time_range}) from video.\n\n"
+            if caption:
+                full_caption += f"Transcription:\n{caption}"
+            
             await update.message.reply_video(
                 video=open(final_clip_path, 'rb'),
-                caption=f"✅ Your clip from {time_range} is ready!",
-                supports_streaming=True
+                caption=full_caption,
+                supports_streaming=True,
+                read_timeout=600, # Allow longer timeout for large video uploads
+                write_timeout=600,
+                pool_timeout=600
             )
             
         else:
             await update.message.reply_text(
-                "❌ Error processing your clip. Please check the URL and time format (e.g., 0:30-1:00) and ensure the video is available."
+                "❌ Error processing your clip. Check the URL/time format (e.g., 0:30-1:00) or ensure the video is public."
             )
 
     except Exception as e:
-        logger.error(f"An unexpected error occurred during processing for user {user_id}: {e}", exc_info=True)
-        await update.message.reply_text("An unexpected error occurred. Please check the format and try again.")
+        logger.error(f"An unexpected error occurred: {e}", exc_info=True)
+        await update.message.reply_text("An unexpected error occurred. Check the format and try again.")
         
     finally:
-        # 4. Clean up files after processing
-        # Ensure your video_utils handles cleanup of temporary files (Crucial for free tier)
+        # NOTE: Cleanup should primarily happen inside process_youtube_clip
         pass
 
 

requirements.txt

@@ -1,7 +1,9 @@
 python-telegram-bot
 yt-dlp
-moviepy==2.0.0.dev2
+moviepy
 openai-whisper
-torch
-python-dotenv
-nltk
+httpx
+Pillow
+tqdm
+numpy
+torch

video_utils.py

@@ -1,95 +1,119 @@
 import os
-import yt_dlp
-import whisper
-from moviepy.editor import VideoFileClip, TextClip, CompositeVideoClip
-from moviepy.video.tools.subtitles import SubtitlesClip
-import random
-import nltk
-from nltk.corpus import stopwords
+import re
+import gc
+from yt_dlp import YoutubeDL
+from moviepy.editor import VideoFileClip
+from whisper import load_model
 
-# Ensure NLTK data is downloaded for tags
-nltk.download('stopwords')
-nltk.download('punkt')
+# --- Helper Functions ---
 
-def download_video(url, output_path="downloads"):
-    """Downloads YouTube video using yt-dlp."""
-    if not os.path.exists(output_path):
-        os.makedirs(output_path)
-    
-    ydl_opts = {
-        'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/mp4',
-        'outtmpl': f'{output_path}/%(id)s.%(ext)s',
-        'quiet': True,
-    }
-    
-    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-        info = ydl.extract_info(url, download=True)
-        filename = ydl.prepare_filename(info)
-        return filename, info.get('title', 'Unknown'), info.get('duration', 0)
+def clean_filename(title: str) -> str:
+    """Sanitizes a string to be a safe filename."""
+    s = re.sub(r'[\\/:*?"<>|]+', '', title)
+    return s[:100].strip()
+
+def time_to_seconds(time_str: str) -> float:
+    """Converts a time string (m:s or h:m:s) to seconds."""
+    parts = list(map(float, time_str.split(':')))
+    if len(parts) == 1:
+        return parts[0]
+    elif len(parts) == 2:
+        return parts[0] * 60 + parts[1]
+    elif len(parts) == 3:
+        return parts[0] * 3600 + parts[1] * 60 + parts[2]
+    return 0.0
 
-def generate_tags(title):
-    """Generates hashtags based on the video title."""
-    stop_words = set(stopwords.words('english'))
-    words = nltk.word_tokenize(title.lower())
-    keywords = [word for word in words if word.isalnum() and word not in stop_words]
+# --- Core Processing Function ---
+
+async def process_youtube_clip(
+    url: str, 
+    time_range: str, 
+    download_dir: str, 
+    clip_dir: str, 
+    user_id: int, 
+    logger
+) -> tuple[str, str]:
+    """Downloads, clips, transcribes, and cleans up a YouTube video."""
     
-    base_tags = ["#shorts", "#fyp", "#trending", "#reels"]
-    content_tags = [f"#{word}" for word in keywords[:5]]
-    return " ".join(base_tags + content_tags)
+    downloaded_video_path = None
+    final_clip_path = None
+    caption_text = None
+
+    try:
+        # 1. Parse time range (e.g., "1:30-2:00")
+        start_str, end_str = time_range.split('-')
+        start_time = time_to_seconds(start_str)
+        end_time = time_to_seconds(end_str)
+        
+        if end_time <= start_time:
+            logger.error("End time must be greater than start time.")
+            return None, None
 
-def create_clips(video_path, num_clips, duration, output_folder="clips"):
-    """Splits video into random segments of specific duration."""
-    if not os.path.exists(output_folder):
-        os.makedirs(output_folder)
+        # 2. Download the video using yt-dlp
+        ydl_opts = {
+            'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
+            'outtmpl': os.path.join(download_dir, f'{user_id}_%(title)s.%(ext)s'),
+            'quiet': True,
+            'max_filesize': 500 * 1024 * 1024, # Max 500MB download
+            'download_ranges': lambda _, __: [{'start_time': start_time, 'end_time': end_time + 5}], # Download slightly more
+        }
         
-    video = VideoFileClip(video_path)
-    video_duration = video.duration
-    generated_clips = []
+        with YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(url, download=True)
+            original_title = info.get('title', 'clip')
+            downloaded_video_path = ydl.prepare_filename(info)
 
-    # Load Whisper model once (small is faster for CPU)
-    model = whisper.load_model("small") 
+        logger.info(f"Video downloaded to {downloaded_video_path}")
 
-    for i in range(num_clips):
-        # Ensure we don't pick a start time that exceeds video length
-        max_start = max(0, video_duration - duration)
-        start_time = random.uniform(0, max_start)
-        end_time = min(start_time + duration, video_duration)
+        # 3. Perform clipping with moviepy
+        output_filename = clean_filename(f"clip_{original_title}_{time_range}.mp4")
+        final_clip_path = os.path.join(clip_dir, output_filename)
         
-        # Cut the clip
-        clip = video.subclip(start_time, end_time)
-        clip_filename = f"{output_folder}/clip_{i}_{os.path.basename(video_path)}"
+        with VideoFileClip(downloaded_video_path) as video:
+            clipped_video = video.subclip(start_time, end_time)
+            
+            # Ensure output is Telegram-compatible (h264 codec)
+            clipped_video.write_videofile(
+                final_clip_path, 
+                codec='libx264', 
+                audio_codec='aac', 
+                temp_audiofile='temp-audio.m4a', 
+                remove_temp=True,
+                logger=None,  # Suppress moviepy logging
+                fps=24 # Ensure low FPS for smaller size
+            )
+
+        # 4. Transcribe audio with Whisper (using the clipped file)
+        logger.info("Starting Whisper transcription...")
         
-        # 1. Transcribe Audio
-        # We need to temporarily save audio to transcribe it
-        temp_audio = "temp_audio.wav"
-        clip.audio.write_audiofile(temp_audio, logger=None)
-        result = model.transcribe(temp_audio)
+        # Load small model for speed on free CPU tier
+        model = load_model("small") 
+        result = model.transcribe(final_clip_path, fp16=False)
+        caption_text = result["text"]
         
-        # 2. Create Captions (Subtitle Generator)
-        # This function creates a text clip for every segment found by Whisper
-        def generator(txt):
-            return TextClip(txt, font='Arial-Bold', fontsize=24, color='white', 
-                            stroke_color='black', stroke_width=2, method='caption', 
-                            size=(clip.w, None)).set_pos(('center', 'bottom'))
-
-        # Convert Whisper segments to MoviePy subtitles
-        subs = []
-        for segment in result['segments']:
-            start = segment['start']
-            end = segment['end']
-            text = segment['text']
-            subs.append(((start, end), text))
-
-        subtitles = SubtitlesClip(subs, generator)
-        final_clip = CompositeVideoClip([clip, subtitles])
+        logger.info("Transcription complete.")
         
-        # Write final file
-        final_clip.write_videofile(clip_filename, codec='libx264', audio_codec='aac', logger=None)
-        generated_clips.append(clip_filename)
+        # 5. Cleanup the Whisper model (crucial for memory management)
+        del model
+        gc.collect() 
         
-        # Cleanup temp audio
-        if os.path.exists(temp_audio):
-            os.remove(temp_audio)
+        return final_clip_path, caption_text
 
-    video.close()
-    return generated_clips
+    except Exception as e:
+        logger.error(f"Error during video processing: {e}", exc_info=True)
+        return None, None
+        
+    finally:
+        # 6. CRUCIAL CLEANUP: Remove large temporary files to prevent OOM errors
+        if downloaded_video_path and os.path.exists(downloaded_video_path):
+            os.remove(downloaded_video_path)
+            logger.info(f"Cleaned up source file: {downloaded_video_path}")
+        
+        # NOTE: We keep the final_clip_path until it's sent via Telegram, then it can be deleted
+        # Telegram handles deleting the local file after successful upload.
+        # However, for total safety, you might want to manually delete after sending:
+        # if final_clip_path and os.path.exists(final_clip_path):
+        #     os.remove(final_clip_path)
+        #     logger.info(f"Cleaned up final clip: {final_clip_path}")
+        
+        gc.collect()