chore: update

Dockerfile

@@ -1,24 +1,24 @@
-# Use a Python 3.10 base image
-FROM python:3.10-slim
-
-# Set working directory
-WORKDIR ./
-
-# 1. First install dependencies as root
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# 2. Create non-root user and data directories
-RUN useradd -m -u 1000 appuser && \
-    mkdir -p /data/processed/text /data/processed/voice \
-             /data/pending/text /data/pending/voice && \
-    chown -R appuser:appuser /data
-
-# 3. Switch to non-root user
-USER appuser
-
-# 4. Copy app files (now owned by appuser)
-COPY --chown=appuser . .
-
-# Change the command to use main.py instead of app.py
+# Use a Python 3.10 base image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR ./
+
+# 1. First install dependencies as root
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 2. Create non-root user and data directories
+RUN useradd -m -u 1000 appuser && \
+    mkdir -p /data/processed/text /data/processed/voice \
+             /data/pending/text /data/pending/voice && \
+    chown -R appuser:appuser /data
+
+# 3. Switch to non-root user
+USER appuser
+
+# 4. Copy app files (now owned by appuser)
+COPY --chown=appuser . .
+
+# Change the command to use main.py instead of app.py
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -40,17 +40,21 @@ PROCESSED_VOICE_DIR = os.path.join(PROCESSED_DIR, 'voice')
 PROCESSED_TEXT_DIR = os.path.join(PROCESSED_DIR, 'text')
 
 # Ensure directories exist with proper permissions
+
+
 def ensure_directory_with_permissions(directory):
     """Create directory if it doesn't exist and set permissions."""
     try:
         if not os.path.exists(directory):
             os.makedirs(directory, exist_ok=True)
         # Set permissions: read/write/execute for everyone
-        os.chmod(directory, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)  # 0777 permissions
+        os.chmod(directory, stat.S_IRWXU | stat.S_IRWXG |
+                 stat.S_IRWXO)  # 0777 permissions
         logger.info(f"Directory ensured with permissions: {directory}")
     except Exception as e:
         logger.error(f"Error setting permissions for {directory}: {str(e)}")
 
+
 # Initialize directories with proper permissions
 ensure_directory_with_permissions(PENDING_VOICE_DIR)
 ensure_directory_with_permissions(PENDING_TEXT_DIR)
@@ -60,6 +64,7 @@ ensure_directory_with_permissions(PROCESSED_TEXT_DIR)
 # Global application variable
 application = None
 
+
 def extract_sequence_number(filename: str) -> Optional[int]:
     """Extract sequence number from filename, e.g., 'Sound 100.wav' -> 100."""
     match = re.search(r'(\d+)', filename)
@@ -67,11 +72,12 @@ def extract_sequence_number(filename: str) -> Optional[int]:
         return int(match.group(1))
     return None
 
+
 def get_files_by_sequence_number():
     """Create dictionaries mapping sequence numbers to filenames."""
     voice_files = {}
     text_files = {}
-    
+
     # Map voice files to sequence numbers
     if os.path.exists(PENDING_VOICE_DIR):
         for filename in os.listdir(PENDING_VOICE_DIR):
@@ -79,7 +85,7 @@ def get_files_by_sequence_number():
                 seq_num = extract_sequence_number(filename)
                 if seq_num is not None:
                     voice_files[seq_num] = filename
-    
+
     # Map text files to sequence numbers
     if os.path.exists(PENDING_TEXT_DIR):
         for filename in os.listdir(PENDING_TEXT_DIR):
@@ -87,9 +93,10 @@ def get_files_by_sequence_number():
                 seq_num = extract_sequence_number(filename)
                 if seq_num is not None:
                     text_files[seq_num] = filename
-    
+
     return voice_files, text_files
 
+
 async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Send a welcome message when the /start command is issued."""
     logger.info(f"Start command received from user {update.effective_user.id}")
@@ -103,205 +110,206 @@ async def start(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     except Exception as e:
         logger.error(f"Error sending start message: {e}")
 
+
 async def get_next_available_chunk() -> Tuple[Optional[str], Optional[str], Optional[int]]:
     """Find the next available audio chunk that isn't being processed.
     Returns (voice_filename, text_filename, sequence_number) or (None, None, None)"""
     voice_files, text_files = get_files_by_sequence_number()
-    
+
     # Find sequence numbers that exist in both voice and text files
-    common_seq_nums = set(voice_files.keys()).intersection(set(text_files.keys()))
-    
+    common_seq_nums = set(voice_files.keys()).intersection(
+        set(text_files.keys()))
+
     # Filter out sequence numbers that are already being processed
-    available_seq_nums = [seq_num for seq_num in common_seq_nums if seq_num not in chunks_in_process]
-    
+    available_seq_nums = [
+        seq_num for seq_num in common_seq_nums if seq_num not in chunks_in_process]
+
     logger.debug(f"Available sequence numbers: {available_seq_nums}")
-    
+
     if available_seq_nums:
         # Get the first available sequence number
         seq_num = min(available_seq_nums)
         return voice_files[seq_num], text_files[seq_num], seq_num
-    
+
     logger.debug("No available chunks found")
     return None, None, None
 
+
 async def correct(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
     """Start the correction process."""
-    logger.info(f"Correct command received from user {update.effective_user.id}")
+    logger.info(
+        f"Correct command received from user {update.effective_user.id}")
     user_id = update.effective_user.id
-    
+
     # Check if user already has an active task
     if user_id in user_tasks:
         await update.message.reply_text("You already have an active correction task. Please finish it or use /cancel.")
         return AWAITING_CORRECTION
-    
+
     # Ensure directory paths exist with proper permissions
     ensure_directory_with_permissions(PENDING_VOICE_DIR)
     ensure_directory_with_permissions(PENDING_TEXT_DIR)
-    
+
     # Log directory contents for debugging
-    logger.debug(f"PENDING_VOICE_DIR contents: {os.listdir(PENDING_VOICE_DIR)}")
+    logger.debug(
+        f"PENDING_VOICE_DIR contents: {os.listdir(PENDING_VOICE_DIR)}")
     logger.debug(f"PENDING_TEXT_DIR contents: {os.listdir(PENDING_TEXT_DIR)}")
-    
+
     # Get next available chunk
     voice_filename, text_filename, seq_num = await get_next_available_chunk()
-    
+
     if not voice_filename or not text_filename:
         await update.message.reply_text("No pending transcriptions available at the moment. Please try again later.")
         return ConversationHandler.END
-    
+
     # Mark chunk as being processed
     chunks_in_process.add(seq_num)
     user_tasks[user_id] = (voice_filename, text_filename, seq_num)
-    
+
     # Send audio file
     audio_path = os.path.join(PENDING_VOICE_DIR, voice_filename)
-    
+
     # Check if audio file exists
     if not os.path.exists(audio_path):
         logger.error(f"Audio file not found: {audio_path}")
         await update.message.reply_text("Error: Audio file not found. Please try again.")
-        
+
         # Clean up
         chunks_in_process.remove(seq_num)
         del user_tasks[user_id]
         return ConversationHandler.END
-    
+
     # Read the original transcription to send as reference
     text_path = os.path.join(PENDING_TEXT_DIR, text_filename)
     if not os.path.exists(text_path):
         logger.error(f"Text file not found: {text_path}")
         await update.message.reply_text("Error: Text file not found. Please try again.")
-        
+
         # Clean up
         chunks_in_process.remove(seq_num)
         del user_tasks[user_id]
         return ConversationHandler.END
-    
+
     try:
         with open(text_path, 'r', encoding='utf-8') as f:
             original_text = f.read().strip()
     except Exception as e:
         logger.error(f"Error reading text file: {e}")
         await update.message.reply_text(f"Error reading transcription file. Please try again.")
-        
+
         # Clean up
         chunks_in_process.remove(seq_num)
         del user_tasks[user_id]
         return ConversationHandler.END
-    
+
     # Send audio and original text
     try:
         with open(audio_path, 'rb') as audio_file:
             await update.message.reply_voice(voice=audio_file)
-        
+
         await update.message.reply_text(
             f"Please listen to the audio and correct the transcription.\n\n"
             f"Original transcription:\n{original_text}\n\n"
             f"Please send your corrected version."
         )
-        
+
         logger.info(f"Successfully sent audio and text to user {user_id}")
         return AWAITING_CORRECTION
     except Exception as e:
         logger.error(f"Error sending audio or text: {e}")
         await update.message.reply_text("Error sending audio. Please try again.")
-        
+
         # Clean up
         chunks_in_process.remove(seq_num)
         del user_tasks[user_id]
         return ConversationHandler.END
 
+
 async def save_correction(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
-    """Save the user's correction."""
+    """Save the user's correction - TEXT ONLY VERSION."""
     user_id = update.effective_user.id
-    
+
     if user_id not in user_tasks:
         await update.message.reply_text("You don't have an active correction task. Use /correct to start one.")
         return ConversationHandler.END
-    
+
     voice_filename, text_filename, seq_num = user_tasks[user_id]
     corrected_text = update.message.text
-    
+
     # Get original file paths
     original_txt_path = os.path.join(PENDING_TEXT_DIR, text_filename)
     original_wav_path = os.path.join(PENDING_VOICE_DIR, voice_filename)
-    
-    # Create user-specific directories in processed folders with proper permissions
-    user_processed_voice_dir = os.path.join(PROCESSED_VOICE_DIR, f"user_{user_id}")
-    user_processed_text_dir = os.path.join(PROCESSED_TEXT_DIR, f"user_{user_id}")
-    
-    # Log the directory paths for debugging
-    logger.debug(f"Creating directories: {user_processed_voice_dir}, {user_processed_text_dir}")
-    
+
+    # Create user-specific directory in processed TEXT folder only
+    user_processed_text_dir = os.path.join(
+        PROCESSED_TEXT_DIR, f"user_{user_id}")
+
+    # Log the directory path for debugging
+    logger.debug(f"Creating text directory: {user_processed_text_dir}")
+
     try:
-        # Ensure directories with proper permissions
-        ensure_directory_with_permissions(user_processed_voice_dir)
+        # Ensure text directory with proper permissions
         ensure_directory_with_permissions(user_processed_text_dir)
-        
-        # Move files to processed directory with corrected text
-        processed_txt_path = os.path.join(user_processed_text_dir, text_filename)
-        processed_wav_path = os.path.join(user_processed_voice_dir, voice_filename)
-        
+
+        # Save corrected text to processed directory
+        processed_txt_path = os.path.join(
+            user_processed_text_dir, text_filename)
+
         # Log file paths for debugging
-        logger.debug(f"Original text path: {original_txt_path}, exists: {os.path.exists(original_txt_path)}")
-        logger.debug(f"Original wav path: {original_wav_path}, exists: {os.path.exists(original_wav_path)}")
+        logger.debug(
+            f"Original text path: {original_txt_path}, exists: {os.path.exists(original_txt_path)}")
+        logger.debug(
+            f"Original wav path: {original_wav_path}, exists: {os.path.exists(original_wav_path)}")
         logger.debug(f"Processed text path: {processed_txt_path}")
-        logger.debug(f"Processed wav path: {processed_wav_path}")
-        
-        # Save corrected text first
+
+        # Save corrected text
         logger.debug(f"Saving corrected text to {processed_txt_path}")
         with open(processed_txt_path, 'w', encoding='utf-8') as f:
             f.write(corrected_text)
         # Set file permissions
-        os.chmod(processed_txt_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH | stat.S_IWOTH)
-        
-        # Copy wav file - verify it exists first
-        if os.path.exists(original_wav_path):
-            logger.debug(f"Copying wav file from {original_wav_path} to {processed_wav_path}")
-            shutil.copy2(original_wav_path, processed_wav_path)
-            # Set file permissions
-            os.chmod(processed_wav_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH | stat.S_IWOTH)
-        else:
-            logger.error(f"Original wav file does not exist at {original_wav_path}")
-            await update.message.reply_text("Error: Original audio file not found. Please try again.")
-            return AWAITING_CORRECTION
-        
-        # Verify processed files exist
-        logger.debug(f"Verifying processed files: text exists: {os.path.exists(processed_txt_path)}, wav exists: {os.path.exists(processed_wav_path)}")
-        
-        # Remove from pending directory - be careful to check if they exist first
+        os.chmod(processed_txt_path, stat.S_IRUSR | stat.S_IWUSR |
+                 stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH | stat.S_IWOTH)
+
+        # Verify processed text file exists
+        logger.debug(
+            f"Verifying processed text file exists: {os.path.exists(processed_txt_path)}")
+
+        # Remove both files from pending directory (text and voice)
         if os.path.exists(original_txt_path):
             logger.debug(f"Removing original text file at {original_txt_path}")
             os.remove(original_txt_path)
         else:
-            logger.warning(f"Could not remove original text file as it doesn't exist at {original_txt_path}")
-            
+            logger.warning(
+                f"Could not remove original text file as it doesn't exist at {original_txt_path}")
+
         if os.path.exists(original_wav_path):
             logger.debug(f"Removing original wav file at {original_wav_path}")
             os.remove(original_wav_path)
         else:
-            logger.warning(f"Could not remove original wav file as it doesn't exist at {original_wav_path}")
-        
+            logger.warning(
+                f"Could not remove original wav file as it doesn't exist at {original_wav_path}")
+
         # Remove from active tasks
         logger.debug(f"Removing seq_num {seq_num} from chunks_in_process")
         chunks_in_process.remove(seq_num)
-        
+
         logger.debug(f"Removing user {user_id} from user_tasks")
         del user_tasks[user_id]
-        
-        logger.info(f"Successfully saved correction for user {user_id}")
+
+        logger.info(
+            f"Successfully saved correction for user {user_id} (text only)")
         await update.message.reply_text(
             "Thank you! Your correction has been saved.\n"
             "Use /correct to receive another transcription task."
         )
-        
+
         return ConversationHandler.END
     except Exception as e:
         # Enhanced error logging with stack trace
         error_msg = f"Error saving correction: {str(e)}"
         logger.error(error_msg)
         logger.error(traceback.format_exc())
-        
+
         # Try to provide more specific error messages
         if "Permission denied" in str(e):
             await update.message.reply_text("Error: Permission denied while saving files. Please contact the administrator.")
@@ -309,74 +317,75 @@ async def save_correction(update: Update, context: ContextTypes.DEFAULT_TYPE) ->
             await update.message.reply_text("Error: File not found. The system couldn't find one of the files.")
         else:
             await update.message.reply_text(f"Error saving your correction: {str(e)}. Please try again.")
-        
+
         return AWAITING_CORRECTION
 
+
 async def cancel(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
     """Cancel the current correction task."""
     user_id = update.effective_user.id
-    
+
     if user_id in user_tasks:
         _, _, seq_num = user_tasks[user_id]
         chunks_in_process.remove(seq_num)
         del user_tasks[user_id]
-        
+
         await update.message.reply_text("Task cancelled. Use /correct to start a new one.")
     else:
         await update.message.reply_text("You don't have an active task to cancel.")
-    
+
     return ConversationHandler.END
 
+
 async def status(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Show status of pending and processed chunks."""
-    logger.info(f"Status command received from user {update.effective_user.id}")
-    
+    logger.info(
+        f"Status command received from user {update.effective_user.id}")
+
     # Count pending files
-    pending_voice_count = len([f for f in os.listdir(PENDING_VOICE_DIR) if f.endswith('.wav')])
-    pending_text_count = len([f for f in os.listdir(PENDING_TEXT_DIR) if f.endswith('.txt')])
-    
+    pending_voice_count = len(
+        [f for f in os.listdir(PENDING_VOICE_DIR) if f.endswith('.wav')])
+    pending_text_count = len(
+        [f for f in os.listdir(PENDING_TEXT_DIR) if f.endswith('.txt')])
+
     # Get sequence numbers
     voice_files, text_files = get_files_by_sequence_number()
-    matching_pairs = len(set(voice_files.keys()).intersection(set(text_files.keys())))
-    
-    # Count processed files
-    processed_voice_count = 0
+    matching_pairs = len(
+        set(voice_files.keys()).intersection(set(text_files.keys())))
+
+    # Count processed files (only text files now)
     processed_text_count = 0
-    
-    # Count voice files
-    for root, dirs, files in os.walk(PROCESSED_VOICE_DIR):
-        processed_voice_count += len([f for f in files if f.endswith('.wav')])
-    
+
     # Count text files
     for root, dirs, files in os.walk(PROCESSED_TEXT_DIR):
         processed_text_count += len([f for f in files if f.endswith('.txt')])
-    
+
     active_tasks = len(user_tasks)
-    
+
     # Check file permissions
     permissions_info = ""
     try:
-        # Check if we can write to the processed directories
-        can_write_voice = os.access(PROCESSED_VOICE_DIR, os.W_OK)
+        # Check if we can write to the processed text directory
         can_write_text = os.access(PROCESSED_TEXT_DIR, os.W_OK)
-        permissions_info = f"\n• Write permissions: Voice: {can_write_voice}, Text: {can_write_text}"
+        permissions_info = f"\n• Write permissions: Text: {can_write_text}"
     except Exception as e:
         permissions_info = f"\n• Error checking permissions: {str(e)}"
-    
+
     await update.message.reply_text(
         f"📊 Transcription Status:\n"
         f"• Pending voice files: {pending_voice_count}\n"
         f"• Pending text files: {pending_text_count}\n"
         f"• Matching pending pairs: {matching_pairs}\n"
-        f"• Processed voice files: {processed_voice_count}\n"
         f"• Processed text files: {processed_text_count}\n"
-        f"• Active tasks: {active_tasks}{permissions_info}"
+        f"• Active tasks: {active_tasks}{permissions_info}\n"
+        f"• Note: Only corrected text files are saved, voice files are not copied to processed folder"
     )
 
+
 async def debug_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Command to show debug information about directories and permissions."""
     user_id = update.effective_user.id
-    
+
     # Check directory structure
     debug_info = [
         "📁 Directory Check:",
@@ -385,23 +394,21 @@ async def debug_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None
         f"• PENDING_VOICE_DIR: {PENDING_VOICE_DIR}, exists: {os.path.exists(PENDING_VOICE_DIR)}",
         f"• PENDING_TEXT_DIR: {PENDING_TEXT_DIR}, exists: {os.path.exists(PENDING_TEXT_DIR)}",
         f"• PROCESSED_DIR: {PROCESSED_DIR}, exists: {os.path.exists(PROCESSED_DIR)}",
-        f"• PROCESSED_VOICE_DIR: {PROCESSED_VOICE_DIR}, exists: {os.path.exists(PROCESSED_VOICE_DIR)}",
         f"• PROCESSED_TEXT_DIR: {PROCESSED_TEXT_DIR}, exists: {os.path.exists(PROCESSED_TEXT_DIR)}",
     ]
-    
+
     # Check permissions
     try:
         permission_info = [
             "🔑 Permission Check:",
             f"• PENDING_VOICE_DIR writable: {os.access(PENDING_VOICE_DIR, os.W_OK)}",
             f"• PENDING_TEXT_DIR writable: {os.access(PENDING_TEXT_DIR, os.W_OK)}",
-            f"• PROCESSED_VOICE_DIR writable: {os.access(PROCESSED_VOICE_DIR, os.W_OK)}",
             f"• PROCESSED_TEXT_DIR writable: {os.access(PROCESSED_TEXT_DIR, os.W_OK)}",
         ]
         debug_info.extend(permission_info)
     except Exception as e:
         debug_info.append(f"Error checking permissions: {str(e)}")
-    
+
     # Check active tasks
     task_info = [
         "📋 Active Tasks:",
@@ -409,88 +416,93 @@ async def debug_info(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None
         f"• Active chunks: {len(chunks_in_process)}",
     ]
     debug_info.extend(task_info)
-    
+
     await update.message.reply_text("\n".join(debug_info))
 
+
 async def test_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
     """Test handler to verify bot is receiving messages."""
     logger.info(f"Test command received from user {update.effective_user.id}")
     await update.message.reply_text("Bot is working! ✅")
 
+
 async def setup_application():
     """Setup the Application with all handlers."""
     global application
-    
+
     # Get the token from environment variable
     token = os.environ.get("TELEGRAM_TOKEN")
     if not token:
         logger.error("TELEGRAM_TOKEN environment variable not set!")
         return None
-    
+
     logger.info(f"Setting up bot with token: {token[:10]}...")
-    
+
     # Create the Application with additional debugging
     application = Application.builder().token(token).build()
-    
+
     # Add a test handler first
     application.add_handler(CommandHandler("test", test_handler))
-    
+
     # Add conversation handler for correction workflow
     conv_handler = ConversationHandler(
         entry_points=[CommandHandler("correct", correct)],
         states={
             AWAITING_CORRECTION: [
-                MessageHandler(filters.TEXT & ~filters.COMMAND, save_correction),
+                MessageHandler(filters.TEXT & ~filters.COMMAND,
+                               save_correction),
             ],
         },
         fallbacks=[CommandHandler("cancel", cancel)],
         name="correction_conversation",
     )
-    
+
     application.add_handler(conv_handler)
-    
+
     # Add command handlers
     application.add_handler(CommandHandler("start", start))
     application.add_handler(CommandHandler("status", status))
     application.add_handler(CommandHandler("cancel", cancel))
-    application.add_handler(CommandHandler("debug", debug_info))  # New debug command
-    
+    application.add_handler(CommandHandler(
+        "debug", debug_info))  # New debug command
+
     logger.info("All handlers added successfully")
     return application
 
+
 async def start_bot():
     """Start the bot with proper signal handling."""
     global application
-    
+
     logger.info("Starting bot setup...")
-    
+
     # Create and configure the bot
     app = await setup_application()
     if not app:
         logger.error("Failed to create application")
         return
-    
+
     logger.info("Application created successfully")
-    
+
     # Start the Bot
     try:
         await app.initialize()
         logger.info("Application initialized")
-        
+
         await app.start()
         logger.info("Application started")
-        
+
         # Start polling for updates
         await app.updater.start_polling(drop_pending_updates=False)
         logger.info("Started polling for updates")
-        
+
     except Exception as e:
         logger.error(f"Error starting bot: {e}")
         return
-    
+
     # Setup signal handlers for graceful shutdown
     loop = asyncio.get_event_loop()
-    
+
     for signal_name in ('SIGINT', 'SIGTERM'):
         try:
             loop.add_signal_handler(
@@ -501,7 +513,7 @@ async def start_bot():
             # Windows doesn't support this
             logger.info("Signal handlers not supported on this platform")
             pass
-    
+
     try:
         # Just run forever until interrupted
         logger.info("Bot is now running and waiting for messages...")
@@ -510,31 +522,33 @@ async def start_bot():
         # Ensure the bot is properly shut down
         await shutdown("Manual")
 
+
 async def shutdown(signal_type):
     """Cleanup tasks tied to the service's shutdown."""
     global application
-    
+
     logger.info(f"Received exit signal {signal_type}...")
-    
+
     # Stop the bot
     if application:
         logger.info("Stopping application...")
         await application.updater.stop()
         await application.stop()
         await application.shutdown()
-    
+
     # Cancel all running tasks
     tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
     for task in tasks:
         task.cancel()
-    
+
     # Wait for all tasks to be cancelled
     if tasks:
         logger.info(f"Waiting for {len(tasks)} tasks to complete...")
         await asyncio.gather(*tasks, return_exceptions=True)
-    
+
     logger.info("Application shutdown complete")
 
+
 async def main():
     """Main function to setup and run the bot."""
     # Setup and start the bot
@@ -542,4 +556,4 @@ async def main():
 
 # This is the entry point when run as the main process
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

main.py

@@ -50,23 +50,23 @@ except Exception as e:
         """Create dictionaries mapping sequence numbers to filenames."""
         voice_files = {}
         text_files = {}
-        
+
         # Map voice files to sequence numbers
         for filename in os.listdir(PENDING_VOICE_DIR):
             if filename.endswith('.wav'):
                 seq_num = extract_sequence_number(filename)
                 if seq_num is not None:
                     voice_files[seq_num] = filename
-        
+
         # Map text files to sequence numbers
         for filename in os.listdir(PENDING_TEXT_DIR):
             if filename.endswith('.txt'):
                 seq_num = extract_sequence_number(filename)
                 if seq_num is not None:
                     text_files[seq_num] = filename
-        
+
         return voice_files, text_files
-    
+
     logging.error(f"Error importing from app.py: {str(e)}")
 
 # Enable logging
@@ -87,6 +87,8 @@ bot_running = False
 bot_start_time = None
 
 # Function to start the bot in a separate process instead of a thread
+
+
 def start_bot_process():
     from multiprocessing import Process
     global bot_process, bot_running
@@ -98,20 +100,21 @@ def start_bot_process():
     bot_running = True
     return bot_process.pid
 
+
 def run_bot_process():
     """Function that runs in a separate process to start the bot"""
     import sys
     import os
     import asyncio
-    
+
     try:
         # Import and run the main function from app.py
         from app import main
-        
+
         # Create a new event loop for this process
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-        
+
         # Run the bot
         loop.run_until_complete(main())
         loop.run_forever()
@@ -119,21 +122,23 @@ def run_bot_process():
         sys.stderr.write(f"Error in bot process: {str(e)}\n")
         sys.exit(1)
 
+
 @app.get("/", response_class=HTMLResponse)
 async def get_root(request: Request):
     return templates.TemplateResponse("index.html", {"request": request, "bot_running": bot_running})
 
+
 @app.post("/start-bot")
 async def start_bot_endpoint(background_tasks: BackgroundTasks):
     global bot_running, bot_start_time
-    
+
     if bot_running:
         return {"status": "error", "message": "Bot is already running"}
-    
+
     # Check if TELEGRAM_TOKEN is set
     if not os.environ.get("TELEGRAM_TOKEN"):
         return {"status": "error", "message": "TELEGRAM_TOKEN environment variable is not set. Please configure it in Hugging Face Space settings."}
-    
+
     try:
         # Start bot in a separate process
         pid = start_bot_process()
@@ -143,23 +148,24 @@ async def start_bot_endpoint(background_tasks: BackgroundTasks):
         logger.error(f"Error starting bot: {str(e)}")
         return {"status": "error", "message": f"Failed to start bot: {str(e)}"}
 
+
 @app.post("/stop-bot")
 async def stop_bot_endpoint():
     global bot_process, bot_running, bot_start_time
-    
+
     if not bot_running or bot_process is None:
         return {"status": "error", "message": "Bot is not running"}
-    
+
     try:
         # Terminate the process
         bot_process.terminate()
         bot_process.join(timeout=5)  # Wait for process to terminate
-        
+
         # If process didn't terminate, force kill it
         if bot_process.is_alive():
             bot_process.kill()
             bot_process.join()
-        
+
         bot_running = False
         bot_start_time = None
         return {"status": "success", "message": "Bot stopped successfully"}
@@ -167,58 +173,50 @@ async def stop_bot_endpoint():
         logger.error(f"Error stopping bot: {str(e)}")
         return {"status": "error", "message": f"Failed to stop bot: {str(e)}"}
 
+
 @app.get("/status")
 async def get_status():
     # Check if directories exist and create if needed
     os.makedirs(PENDING_VOICE_DIR, exist_ok=True)
     os.makedirs(PENDING_TEXT_DIR, exist_ok=True)
-    os.makedirs(PROCESSED_VOICE_DIR, exist_ok=True) 
+    os.makedirs(PROCESSED_VOICE_DIR, exist_ok=True)
     os.makedirs(PROCESSED_TEXT_DIR, exist_ok=True)
 
     # Count pending files
-    pending_voice_count = len([f for f in os.listdir(PENDING_VOICE_DIR) if f.endswith('.wav')])
-    pending_text_count = len([f for f in os.listdir(PENDING_TEXT_DIR) if f.endswith('.txt')])
-    
+    pending_voice_count = len(
+        [f for f in os.listdir(PENDING_VOICE_DIR) if f.endswith('.wav')])
+    pending_text_count = len(
+        [f for f in os.listdir(PENDING_TEXT_DIR) if f.endswith('.txt')])
+
     # Get sequence numbers
     voice_files, text_files = get_files_by_sequence_number()
-    matching_pairs = len(set(voice_files.keys()).intersection(set(text_files.keys())))
-    
-    # Count processed files
-    processed_voice_count = 0
+    matching_pairs = len(
+        set(voice_files.keys()).intersection(set(text_files.keys())))
+
+    # Count processed files - Only count text files now as voice files are no longer saved to processed
+    processed_voice_count = 0  # Set to 0 since we no longer save voice files
     processed_text_count = 0
-    
+
     # Count processed files by user
     user_stats = {}
-    
-    # Process voice files
-    for root, dirs, files in os.walk(PROCESSED_VOICE_DIR):
-        wav_files = [f for f in files if f.endswith('.wav')]
-        processed_voice_count += len(wav_files)
-        
-        # Get user ID from directory path
-        if os.path.basename(root).startswith("user_"):
-            user_id = os.path.basename(root)
-            if user_id not in user_stats:
-                user_stats[user_id] = {"voice": 0, "text": 0}
-            user_stats[user_id]["voice"] += len(wav_files)
-    
-    # Process text files
+
+    # Process text files only (voice files are no longer saved to processed directory)
     for root, dirs, files in os.walk(PROCESSED_TEXT_DIR):
         txt_files = [f for f in files if f.endswith('.txt')]
         processed_text_count += len(txt_files)
-        
+
         # Get user ID from directory path
         if os.path.basename(root).startswith("user_"):
             user_id = os.path.basename(root)
             if user_id not in user_stats:
                 user_stats[user_id] = {"voice": 0, "text": 0}
             user_stats[user_id]["text"] += len(txt_files)
-    
+
     # Calculate uptime if bot is running
     uptime = None
     if bot_running and bot_start_time:
         uptime = int(time.time() - bot_start_time)
-        
+
     return {
         "bot_running": bot_running,
         "uptime_seconds": uptime,
@@ -231,38 +229,35 @@ async def get_status():
         "is_huggingface": True
     }
 
+
 @app.get("/list-users")
 async def list_users():
     users = set()
-    
-    # Get users from voice directories
-    for item in os.listdir(PROCESSED_VOICE_DIR):
-        if item.startswith("user_"):
-            users.add(item)
-    
-    # Get users from text directories
+
+    # Get users from text directories only (since voice files are no longer saved)
     for item in os.listdir(PROCESSED_TEXT_DIR):
         if item.startswith("user_"):
             users.add(item)
-    
+
     return {"users": sorted(list(users))}
 
+
 @app.get("/download/{user_id}")
 async def download_processed_data(user_id: str):
     if not user_id.startswith("user_"):
         raise HTTPException(status_code=400, detail="Invalid user ID format")
-    
-    # Check if user exists
-    voice_dir = os.path.join(PROCESSED_VOICE_DIR, user_id)
+
+    # Check if user exists - only check text directory now
     text_dir = os.path.join(PROCESSED_TEXT_DIR, user_id)
-    
-    if not os.path.exists(voice_dir) and not os.path.exists(text_dir):
-        raise HTTPException(status_code=404, detail=f"No data found for user {user_id}")
-    
+
+    if not os.path.exists(text_dir):
+        raise HTTPException(
+            status_code=404, detail=f"No data found for user {user_id}")
+
     # Create a zip file in memory
     zip_buffer = BytesIO()
     with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-        # Add text files
+        # Add text files only
         if os.path.exists(text_dir):
             for file_name in os.listdir(text_dir):
                 file_path = os.path.join(text_dir, file_name)
@@ -270,19 +265,10 @@ async def download_processed_data(user_id: str):
                     # Read the file and add it to the zip
                     with open(file_path, 'rb') as f:
                         zip_file.writestr(f"text/{file_name}", f.read())
-        
-        # Add voice files
-        if os.path.exists(voice_dir):
-            for file_name in os.listdir(voice_dir):
-                file_path = os.path.join(voice_dir, file_name)
-                if os.path.isfile(file_path) and file_name.endswith('.wav'):
-                    # Read the file and add it to the zip
-                    with open(file_path, 'rb') as f:
-                        zip_file.writestr(f"voice/{file_name}", f.read())
-    
+
     # Reset buffer position
     zip_buffer.seek(0)
-    
+
     # Return the zip file as a response
     return StreamingResponse(
         zip_buffer,
@@ -292,12 +278,13 @@ async def download_processed_data(user_id: str):
         }
     )
 
+
 @app.get("/download-all")
 async def download_all_processed_data():
     # Create a zip file in memory
     zip_buffer = BytesIO()
     with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-        # Add all processed text files
+        # Add all processed text files only
         for root, dirs, files in os.walk(PROCESSED_TEXT_DIR):
             for file_name in files:
                 if file_name.endswith('.txt'):
@@ -307,21 +294,10 @@ async def download_all_processed_data():
                     # Read the file and add it to the zip
                     with open(file_path, 'rb') as f:
                         zip_file.writestr(f"text/{rel_path}", f.read())
-        
-        # Add all processed voice files
-        for root, dirs, files in os.walk(PROCESSED_VOICE_DIR):
-            for file_name in files:
-                if file_name.endswith('.wav'):
-                    file_path = os.path.join(root, file_name)
-                    # Get the relative path from the PROCESSED_VOICE_DIR
-                    rel_path = os.path.relpath(file_path, PROCESSED_VOICE_DIR)
-                    # Read the file and add it to the zip
-                    with open(file_path, 'rb') as f:
-                        zip_file.writestr(f"voice/{rel_path}", f.read())
-    
+
     # Reset buffer position
     zip_buffer.seek(0)
-    
+
     # Return the zip file as a response
     return StreamingResponse(
         zip_buffer,
@@ -331,11 +307,12 @@ async def download_all_processed_data():
         }
     )
 
+
 @app.on_event("startup")
 async def setup_app():
     # Ensure templates directory exists
     os.makedirs("templates", exist_ok=True)
-    
+
     # Only create index.html if it doesn't exist
     if not os.path.exists("templates/index.html"):
         # Create a simple default template if needed
@@ -402,6 +379,13 @@ async def setup_app():
             padding: 8px;
             border-bottom: 1px solid #eee;
         }
+        .note {
+            background-color: #f0f8ff;
+            border-left: 4px solid #1e90ff;
+            padding: 10px;
+            margin: 10px 0;
+            font-style: italic;
+        }
     </style>
 </head>
 <body>
@@ -417,6 +401,9 @@ async def setup_app():
     
     <div class="container">
         <h2>Status</h2>
+        <div class="note">
+            Note: Only corrected text files are saved to the processed directory. Voice files are removed after processing to save storage space.
+        </div>
         <div id="statusInfo" class="status">Loading status...</div>
     </div>
     
@@ -427,8 +414,8 @@ async def setup_app():
     
     <div class="container">
         <h2>Data Download</h2>
-        <p>Download all processed data or data for specific users.</p>
-        <button onclick="downloadAll()">Download All Data</button>
+        <p>Download all processed corrected text files or data for specific users.</p>
+        <button onclick="downloadAll()">Download All Text Data</button>
     </div>
 
     <script>
@@ -486,10 +473,6 @@ async def setup_app():
                                 <td>Matching Pending Pairs</td>
                                 <td>${data.matching_pairs}</td>
                             </tr>
-                            <tr>
-                                <td>Processed Voice Files</td>
-                                <td>${data.processed_voice_count}</td>
-                            </tr>
                             <tr>
                                 <td>Processed Text Files</td>
                                 <td>${data.processed_text_count}</td>
@@ -522,7 +505,7 @@ async def setup_app():
                         usersHtml += `
                             <div class="user-item">
                                 <span>${user}</span>
-                                <button onclick="downloadUser('${user}')">Download Data</button>
+                                <button onclick="downloadUser('${user}')">Download Text Data</button>
                             </div>
                         `;
                     });
@@ -583,4 +566,4 @@ async def setup_app():
 
 # Entrypoint for running the server
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860)