Refactor bot.py for robustness and better logging

bot.py

@@ -1,125 +1,128 @@
 import os
-import shutil
-from dotenv import load_dotenv
-from telegram import Update, ReplyKeyboardMarkup, ReplyKeyboardRemove
-from telegram.ext import Application, CommandHandler, MessageHandler, ConversationHandler, ContextTypes, filters
-from video_utils import download_video, create_clips, generate_tags
+import sys
+import logging
+from telegram import Update
+from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
+from video_utils import process_video_clip
 
-# Load env variables
-load_dotenv()
-TOKEN = os.getenv("BOT_TOKEN")
+# Configure logging
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
 
-# States for Conversation
-URL, NUM_CLIPS, DURATION, PROCESSING = range(4)
+# --- 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):
+TOKEN = os.getenv("BOT_TOKEN") 
 
-async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+# Ensure the token is available
+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
+DOWNLOAD_DIR = "downloads"
+CLIP_DIR = "clips"
+os.makedirs(DOWNLOAD_DIR, exist_ok=True)
+os.makedirs(CLIP_DIR, exist_ok=True)
+
+# --- Command Handlers ---
+
+async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Sends a welcome message when the /start command is issued."""
+    logger.info(f"Received /start command from user {update.effective_user.id}")
     await update.message.reply_text(
-        "👋 **Welcome to the AI Clipper Bot!**\n\n"
-        "I can download YouTube videos, create clips, add captions, and generate tags.\n"
-        "Send /cancel at any time to stop.\n\n"
-        "Please send me the **YouTube URL** to get started."
+        '👋 Welcome to the AI Telegram Video Clipper Bot!\n\n'
+        'Send me a YouTube video link and specify the start and end times '
+        '(e.g., `https://youtu.be/example 0:30-1:00`).\n\n'
+        'I will generate the clip, transcribe the audio, and send the final video back!'
     )
-    return URL
 
-async def receive_url(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    url = update.message.text
-    if "youtube.com" not in url and "youtu.be" not in url:
-        await update.message.reply_text("❌ That doesn't look like a valid YouTube URL. Please try again.")
-        return URL
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+    """Handles messages containing a potential YouTube link."""
+    user_message = update.message.text
+    user_id = update.effective_user.id
     
-    context.user_data['url'] = url
-    await update.message.reply_text("✅ URL received!\n\nHow many clips would you like to generate? (e.g., 3)")
-    return NUM_CLIPS
-
-async def receive_num_clips(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    try:
-        count = int(update.message.text)
-        if count > 10:
-            await update.message.reply_text("⚠️ Let's keep it under 10 clips for performance. Try again.")
-            return NUM_CLIPS
+    # 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]}...")
+        return
         
-        context.user_data['num_clips'] = count
-        await update.message.reply_text("Got it. How long should each clip be (in seconds)? (e.g., 30)")
-        return DURATION
-    except ValueError:
-        await update.message.reply_text("❌ Please enter a valid number.")
-        return NUM_CLIPS
-
-async def receive_duration(update: Update, context: ContextTypes.DEFAULT_TYPE):
     try:
-        duration = int(update.message.text)
-        context.user_data['duration'] = duration
+        # Separate link and time frame
+        parts = user_message.split()
+        url = parts[0]
+        time_range = parts[1] if len(parts) > 1 else None
+
+        if not time_range:
+            await update.message.reply_text(
+                "Please specify the clip range (e.g., `1:30-2:00`) after the link."
+            )
+            return
+
+        logger.info(f"User {user_id} requested clip: {url} from {time_range}")
+        await update.message.reply_text(f"Processing your request for: {time_range}...")
         
-        await update.message.reply_text(
-            f"🎬 **Processing Started!**\n"
-            f"Video: {context.user_data['url']}\n"
-            f"Clips: {context.user_data['num_clips']}\n"
-            f"Duration: {duration}s\n\n"
-            "This will take a few minutes depending on your PC speed. I'll send the clips when ready!"
+        # 2. Call the core processing function
+        final_clip_path = await process_video_clip(
+            url, 
+            time_range, 
+            DOWNLOAD_DIR, 
+            CLIP_DIR, 
+            user_id,
+            logger # Pass logger for better tracking
         )
-        
-        # Trigger the processing function asynchronously
-        # We use create_task so the bot doesn't freeze
-        context.application.create_task(process_video(update, context))
-        
-        return ConversationHandler.END
-    except ValueError:
-        await update.message.reply_text("❌ Please enter a valid number for seconds.")
-        return DURATION
 
-async def process_video(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    user_id = update.effective_user.id
-    data = context.user_data
-    
-    try:
-        # 1. Download
-        video_path, title, _ = download_video(data['url'])
-        
-        # 2. Generate Tags
-        tags = generate_tags(title)
-        
-        # 3. Process Clips
-        clips = create_clips(video_path, data['num_clips'], data['duration'])
-        
-        # 4. Send Clips
-        for clip_path in clips:
-            await context.bot.send_video(
-                chat_id=user_id,
-                video=open(clip_path, 'rb'),
-                caption=f"🎥 **{title}**\n\n{tags}",
-                read_timeout=60
+        if final_clip_path:
+            # 3. Send the final video back
+            logger.info(f"Sending final clip to user {user_id}: {final_clip_path}")
+            await update.message.reply_video(
+                video=open(final_clip_path, 'rb'),
+                caption=f"✅ Your clip from {time_range} is ready!",
+                supports_streaming=True
+            )
+            
+        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."
             )
-            # Clean up individual clip after sending
-            os.remove(clip_path)
 
-        # Cleanup original video
-        os.remove(video_path)
-        
-        await context.bot.send_message(chat_id=user_id, text="✅ All clips sent! Send /start to process another.")
-        
     except Exception as e:
-        await context.bot.send_message(chat_id=user_id, text=f"❌ An error occurred: {str(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.")
+        
+    finally:
+        # 4. Clean up files after processing
+        # Ensure your video_utils handles cleanup of temporary files (Crucial for free tier)
+        pass
 
-async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    await update.message.reply_text("🚫 Operation cancelled. Send /start to begin again.", reply_markup=ReplyKeyboardRemove())
-    return ConversationHandler.END
 
-def main():
+# --- Main Application Runner ---
+
+def main() -> None:
+    """Start the bot."""
+    logger.info("Starting Telegram Application...")
+    
+    # 1. Build the application
     application = Application.builder().token(TOKEN).build()
 
-    conv_handler = ConversationHandler(
-        entry_points=[CommandHandler("start", start)],
-        states={
-            URL: [MessageHandler(filters.TEXT & ~filters.COMMAND, receive_url)],
-            NUM_CLIPS: [MessageHandler(filters.TEXT & ~filters.COMMAND, receive_num_clips)],
-            DURATION: [MessageHandler(filters.TEXT & ~filters.COMMAND, receive_duration)],
-        },
-        fallbacks=[CommandHandler("cancel", cancel)],
-    )
+    # 2. Register handlers
+    application.add_handler(CommandHandler("start", start_command))
+    application.add_handler(MessageHandler(
+        filters.TEXT & ~filters.COMMAND, 
+        handle_message
+    ))
 
-    application.add_handler(conv_handler)
-    print("Bot is running...")
-    application.run_polling()
+    # 3. Start polling
+    logger.info("Bot is ready. Starting polling...")
+    application.run_polling(allowed_updates=Update.ALL_TYPES)
+    logger.info("Bot polling stopped.")
 
 if __name__ == "__main__":
     main()