Delete helper_func/mux.py

helper_func/mux.py

@@ -1,539 +0,0 @@
-from config import Config
-import time
-import re
-import asyncio
-import os
-import logging
-from pyrogram import Client
-from datetime import datetime, timedelta
-
-
-progress_pattern = re.compile(
-    r'(frame|fps|size|time|bitrate|speed)\s*\=\s*(\S+)'
-)
-
-def parse_progress(line):
-    items = {
-        key: value for key, value in progress_pattern.findall(line)
-    }
-    if not items:
-        return None
-    return items
-
-async def readlines(stream):
-    pattern = re.compile(br'[\r\n]+')
-
-    data = bytearray()
-    while not stream.at_eof():
-        lines = pattern.split(data)
-        data[:] = lines.pop(-1)
-
-        for line in lines:
-            yield line
-
-        data.extend(await stream.read(1024))
-
-# Add a dictionary to store encoding progress data for each user
-encoding_progress = {}
-
-# Add at the top with other global variables
-active_processes = {}  # To track active downloads and encodings per user
-
-async def read_stderr(start, msg, process):
-    # Get chat_id from the message to track progress per user
-    chat_id = msg.chat.id
-    
-    # Initialize progress tracking for this user
-    if chat_id not in encoding_progress:
-        encoding_progress[chat_id] = {
-            'last_update_time': time.time(),
-            'total_duration': None,
-            'speed_samples': [],
-            'max_samples': 10
-        }
-    
-    user_progress = encoding_progress[chat_id]
-    duration_pattern = re.compile(r'Duration: (\d+):(\d+):(\d+\.\d+)')
-    
-    async for line in readlines(process.stderr):
-        line = line.decode('utf-8')
-        
-        # Try to extract duration if we don't have it yet
-        if user_progress['total_duration'] is None:
-            duration_match = duration_pattern.search(line)
-            if duration_match:
-                h, m, s = duration_match.groups()
-                user_progress['total_duration'] = float(h) * 3600 + float(m) * 60 + float(s)
-        
-        progress = parse_progress(line)
-        if progress:
-            now = time.time()
-            elapsed = now - start
-            
-            # Build basic progress message
-            text = '🎬 <b>Encoding in Progress</b>\n\n'
-            text += '📊 Size: {}\n'.format(format_size(progress['size']))
-            text += '⏱️ Time: {}\n'.format(progress['time'])
-            text += '⚡ Speed: {}\n'.format(progress['speed'])
-            
-            # Add estimated time remaining if we can calculate it
-            if 'time' in progress and user_progress['total_duration'] is not None:
-                # Parse the current timestamp
-                time_parts = progress['time'].split(':')
-                if len(time_parts) == 3:
-                    h, m, s = time_parts
-                    current_time = float(h) * 3600 + float(m) * 60 + float(s)
-                    
-                    # Calculate progress percentage
-                    percent_done = min(99.9, (current_time / user_progress['total_duration']) * 100)
-                    text += '📈 Progress: {:.1f}%\n'.format(percent_done)
-                    
-                    # Extract speed for better estimation
-                    if 'speed' in progress:
-                        speed_match = re.search(r'(\d+\.?\d*)x', progress['speed'])
-                        if speed_match:
-                            speed = float(speed_match.group(1))
-                            
-                            # Add to our speed samples
-                            user_progress['speed_samples'].append((now, speed, current_time))
-                            
-                            # Keep only recent samples
-                            if len(user_progress['speed_samples']) > user_progress['max_samples']:
-                                user_progress['speed_samples'].pop(0)
-                            
-                            # Calculate weighted average speed (more recent samples have higher weight)
-                            if len(user_progress['speed_samples']) >= 3:
-                                total_weight = 0
-                                weighted_speed = 0
-                                
-                                for i, (sample_time, sample_speed, _) in enumerate(user_progress['speed_samples']):
-                                    weight = (i + 1) ** 2
-                                    weighted_speed += sample_speed * weight
-                                    total_weight += weight
-                                
-                                avg_speed = weighted_speed / total_weight if total_weight > 0 else speed
-                                
-                                # Calculate remaining time
-                                remaining_time = (user_progress['total_duration'] - current_time) / avg_speed
-                                text += '⏳ ETA: {}\n'.format(format_time_duration(remaining_time))
-                    else:
-                        # Fallback method if speed isn't available
-                        if percent_done > 0:
-                            estimated_total = elapsed / (percent_done / 100)
-                            remaining = estimated_total - elapsed
-                            
-                            # Apply a safety factor
-                            remaining *= 2.5  # Multiply the estimate to be safe
-                            
-                            if remaining > 0:
-                                text += 'Estimated time remaining: {} (rough estimate)\n'.format(format_time_duration(remaining))
-            
-            # Update message at regular intervals
-            if round(now - user_progress['last_update_time']) >= 5:
-                try:
-                    await msg.edit(text)
-                    user_progress['last_update_time'] = now
-                except:
-                    pass
-    
-    # Clean up when encoding is done
-    if chat_id in encoding_progress:
-        del encoding_progress[chat_id]
-
-def format_time_duration(seconds):
-    """Format seconds into human readable time (e.g., 2h 30m 5s)"""
-    hours = seconds // 3600
-    minutes = (seconds % 3600) // 60
-    seconds = seconds % 60
-    
-    parts = []
-    if hours > 0:
-        parts.append(f"{int(hours)}h")
-    if minutes > 0:
-        parts.append(f"{int(minutes)}m")
-    if seconds > 0 or not parts:  # include seconds if it's the only non-zero value
-        parts.append(f"{int(seconds)}s")
-    
-    return " ".join(parts)
-
-def format_size(size_str):
-    """Convert size string to human readable format"""
-    try:
-        # Remove 'kB' or any other suffix and convert to bytes
-        size = float(size_str.replace('kB', '')) * 1024  # Convert kB to bytes
-        
-        for unit in ['B', 'KB', 'MB', 'GB']:
-            if size < 1024.0:
-                return "{:.2f} {}".format(size, unit)
-            size /= 1024.0
-        return "{:.2f} TB".format(size)
-    except:
-        return size_str  # Return original string if conversion fails
-
-async def softmux_vid(vid_filename, sub_filename, msg):
-    chat_id = msg.chat.id
-    
-    # Set active process
-    active_processes[chat_id] = 'encoding'
-    start = time.time()
-    out_location = None  # Define outside try block for cleanup
-    
-    try:
-        vid = Config.DOWNLOAD_DIR+'/'+vid_filename
-        sub = Config.DOWNLOAD_DIR+'/'+sub_filename
-
-        out_file = '.'.join(vid_filename.split('.')[:-1])
-        output = out_file+'1.mkv'
-        out_location = Config.DOWNLOAD_DIR+'/'+output
-        sub_ext = sub_filename.split('.')[-1].lower()
-        
-        # Set the appropriate subtitle codec based on file extension
-        if sub_ext == 'vtt':
-            subtitle_codec = 'webvtt'
-        else:
-            subtitle_codec = sub_ext
-        
-        command = [
-            'ffmpeg', '-hide_banner',
-            '-fflags', '+genpts',
-            '-i',vid,
-            '-i',sub,
-            '-map','1:0','-map','0',
-            '-disposition:s:0','default',
-            '-c:v','copy',
-            '-c:a','copy',
-            '-c:s',subtitle_codec,
-            '-y',out_location
-        ]
-
-        process = await asyncio.create_subprocess_exec(
-            *command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-
-        await asyncio.wait([
-            asyncio.create_task(read_stderr(start, msg, process)),
-            asyncio.create_task(process.wait())
-        ])
-
-        if process.returncode == 0:
-            elapsed_time = round(time.time() - start)
-            await msg.edit(
-                f'✅ <b>Encoding Completed Successfully!</b>\n\n'
-                f'⏱️ Time Taken: {format_time_duration(elapsed_time)}'
-            )
-            await asyncio.sleep(1)
-            return output
-        else:
-            await msg.edit(
-                '❌ <b>Encoding Failed</b>\n\n'
-                'An error occurred during the encoding process.\n'
-                'Please try again or use different settings.'
-            )
-            # Clean up failed encoding file
-            if out_location and os.path.exists(out_location):
-                try:
-                    os.remove(out_location)
-                    logging.info(f"Removed failed encoding file: {output}")
-                except Exception as e:
-                    logging.error(f"Error removing failed encoding file: {e}")
-            return False
-
-    except Exception as e:
-        logging.error(f"Error during encoding: {e}")
-        # Clean up failed encoding file
-        if out_location and os.path.exists(out_location):
-            try:
-                os.remove(out_location)
-                logging.info(f"Removed failed encoding file: {output}")
-            except Exception as e:
-                logging.error(f"Error removing failed encoding file: {e}")
-        await msg.edit(
-            '❌ <b>Encoding Error</b>\n\n'
-            'An unexpected error occurred.\n'
-            'Please try again or contact support.'
-        )
-        return False
-    finally:
-        # Remove active process status
-        if chat_id in active_processes:
-            del active_processes[chat_id]
-
-# Define resolution options
-RESOLUTIONS = {
-    '8k': '7680x4320',
-    '4k': '3840x2160',
-    '1440p': '2560x1440',
-    '1080p': '1920x1080',
-    '720p': '1280x720',
-    '480p': '854x480',
-    '360p': '640x360',
-    '240p': '426x240',
-    '144p': '256x144',
-    'original': 'original'
-}
-
-# Define codec options
-CODECS = {
-    'h264': {
-        'ffmpeg_codec': 'libx264',
-        'description': 'H.264 (AVC) - Widely compatible'
-    },
-    'h265': {
-        'ffmpeg_codec': 'libx265',
-        'description': 'H.265 (HEVC) - Better compression, smaller file size'
-    }
-}
-
-async def hardmux_vid(vid_filename, sub_filename, msg, crf='23', preset='medium', resolution='original', codec='h264', fps='original', custom_filename=None, audio_bitrate='128k', audio_track='all'):
-    chat_id = msg.chat.id
-    
-    # Set active process
-    active_processes[chat_id] = 'encoding'
-    start = time.time()
-    out_location = None  # Define outside try block for cleanup
-    
-    try:
-        vid = Config.DOWNLOAD_DIR + '/' + vid_filename
-        sub = None if not sub_filename else Config.DOWNLOAD_DIR + '/' + sub_filename
-
-        # Get the base output file name
-        out_file = '.'.join(vid_filename.split('.')[:-1])
-        
-        # If custom filename is provided, extract its extension
-        if custom_filename:
-            # Extract extension from custom filename
-            custom_ext = custom_filename.split('.')[-1].lower()
-            # Use the custom extension but keep the same pattern
-            output = out_file + '_VidSub.' + custom_ext
-        else:
-            # Use default mp4 extension
-            output = out_file + '_VidSub.mp4'
-            
-        out_location = Config.DOWNLOAD_DIR + '/' + output
-        
-        # Base command without filters
-        filter_complex = ''
-        
-        # Add resolution scaling if not original
-        if resolution != 'original':
-            filter_complex = f"scale={RESOLUTIONS[resolution]}"
-        
-        # Add frame rate filter if not original
-        if fps != 'original':
-            fps_filter = f"fps={fps}"
-            filter_complex = f"{fps_filter},{filter_complex}" if filter_complex else fps_filter
-        
-        # Add subtitle filter if subtitle file exists
-        if sub:
-            # Get subtitle extension
-            sub_ext = sub_filename.split('.')[-1].lower()
-            
-            # Set up font configuration
-            font_dir = "./fonts"  # Directory containing fonts
-            default_font = "HelveticaRounded LT Std BdCn"
-            
-            # Different handling based on subtitle format
-            if sub_ext == 'ass' or sub_ext == 'ssa':
-                subtitle_filter = f"ass='{sub}':fontsdir='{font_dir}'"
-            else:
-                subtitle_filter = f"subtitles='{sub}':fontsdir='{font_dir}':force_style='FontName={default_font},FontSize=18'"
-            
-            # Add subtitle filter to the chain
-            filter_complex = f"{filter_complex},{subtitle_filter}" if filter_complex else subtitle_filter
-
-        # Get the codec command
-        video_codec = CODECS[codec]['ffmpeg_codec']
-        
-        # Base command
-        command = [
-            'ffmpeg', '-hide_banner',
-            '-fflags', '+genpts',
-            '-i', vid,
-        ]
-        
-        # Add filter complex if we have any filters
-        if filter_complex:
-            command.extend(['-vf', filter_complex])
-        
-        # Add encoding parameters
-        command.extend([
-            '-c:v', video_codec,
-            '-crf', crf,
-            '-preset', preset,
-            '-c:a', 'aac',
-            '-b:a', audio_bitrate,
-        ])
-        
-        # Handle audio track mapping
-        if audio_track == 'all':
-            # Map all audio tracks
-            command.extend([
-                '-map', '0:v:0',  # First video stream
-                '-map', '0:a',    # All audio streams
-            ])
-        else:
-            # Map specific audio track (convert from 1-based to 0-based indexing)
-            audio_stream_index = int(audio_track) - 1
-            command.extend([
-                '-map', '0:v:0',                      # First video stream
-                '-map', f'0:a:{audio_stream_index}',  # Specific audio stream
-            ])
-        
-        # Add remaining parameters
-        command.extend([
-            '-map_metadata', '-1',  # Remove all metadata
-            '-sn',  # Remove all subtitle streams
-        ])
-        
-        # Add codec-specific parameters
-        if codec == 'h265':
-            command.extend([
-                '-x265-params', 'log-level=error',
-                '-tag:v', 'hvc1'
-            ])
-        
-        # Add output file
-        command.extend(['-y', out_location])
-
-        process = await asyncio.create_subprocess_exec(
-            *command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-
-        await asyncio.wait([
-            asyncio.create_task(read_stderr(start, msg, process)),
-            asyncio.create_task(process.wait())
-        ])
-
-        if process.returncode == 0:
-            elapsed_time = round(time.time() - start)
-            await msg.edit(
-                f'✅ <b>Encoding Completed Successfully!</b>\n\n'
-                f'⏱️ Time Taken: {format_time_duration(elapsed_time)}'
-            )
-            await asyncio.sleep(1)
-            return output
-        else:
-            await msg.edit(
-                '❌ <b>Encoding Failed</b>\n\n'
-                'An error occurred during the encoding process.\n'
-                'Please try again or use different settings.'
-            )
-            # Clean up failed encoding file
-            if out_location and os.path.exists(out_location):
-                try:
-                    os.remove(out_location)
-                    logging.info(f"Removed failed encoding file: {output}")
-                except Exception as e:
-                    logging.error(f"Error removing failed encoding file: {e}")
-            return False
-
-    except Exception as e:
-        logging.error(f"Error during encoding: {e}")
-        # Clean up failed encoding file
-        if out_location and os.path.exists(out_location):
-            try:
-                os.remove(out_location)
-                logging.info(f"Removed failed encoding file: {output}")
-            except Exception as e:
-                logging.error(f"Error removing failed encoding file: {e}")
-        await msg.edit(
-            '❌ <b>Encoding Error</b>\n\n'
-            'An unexpected error occurred.\n'
-            'Please try again or contact support.'
-        )
-        return False
-    finally:
-        # Remove active process status
-        if chat_id in active_processes:
-            del active_processes[chat_id]
-
-async def check_active_process(client, chat_id, message_id):
-    """Check if user has an active process and send appropriate message"""
-    if chat_id in active_processes:
-        process_type = active_processes[chat_id]
-        process_messages = {
-            'download': '⚠️ Please wait until the current download completes!',
-            'encoding': '⚠️ Please wait until the current encoding completes!',
-            'upload': '⚠️ Please wait until the current upload completes!'
-        }
-        await client.edit_message_text(
-            chat_id=chat_id,
-            message_id=message_id,
-            text=process_messages.get(process_type, '⚠️ Another process is running!')
-        )
-        return True
-    return False
-
-# Create a function to log and set process status
-def set_process_status(chat_id, status):
-    """Set and log process status"""
-    active_processes[chat_id] = status
-    logging.info(f"Setting process status for {chat_id} to {status}")
-
-# Create a function to log and clear process status
-def clear_process_status(chat_id):
-    """Clear and log process status"""
-    if chat_id in active_processes:
-        status = active_processes[chat_id]
-        del active_processes[chat_id]
-        logging.info(f"Cleared process status {status} for {chat_id}")
-
-# Add this function to clean up old files
-async def cleanup_old_files():
-    """
-    Recursively delete files older than 12 hours from download directory and its subdirectories.
-    Also removes empty subdirectories after file cleanup.
-    """
-    while True:
-        try:
-            current_time = datetime.now()
-            timeout = timedelta(hours=12)
-            main_dir = Config.DOWNLOAD_DIR
-            
-            logging.info(f"Starting scheduled cleanup of files older than 12 hours")
-            
-            # First pass: Delete old files recursively
-            for root, dirs, files in os.walk(main_dir, topdown=False):
-                # Process each file in the current directory
-                for filename in files:
-                    try:
-                        filepath = os.path.join(root, filename)
-                        
-                        # Get file's last modification time
-                        file_time = datetime.fromtimestamp(os.path.getmtime(filepath))
-                        
-                        # If file is older than 12 hours
-                        if current_time - file_time > timeout:
-                            try:
-                                os.remove(filepath)
-                                logging.info(f"Deleted old file: {filepath} (Age: {current_time - file_time})")
-                            except Exception as e:
-                                logging.error(f"Error deleting old file {filepath}: {e}")
-                    except Exception as e:
-                        logging.error(f"Error processing file {filename}: {e}")
-            
-            # Second pass: Remove empty subdirectories
-            for root, dirs, files in os.walk(main_dir, topdown=False):
-                # Skip the main download directory
-                if root == main_dir:
-                    continue
-                    
-                try:
-                    # Check if directory is empty
-                    if not os.listdir(root):
-                        os.rmdir(root)
-                        logging.info(f"Removed empty directory: {root}")
-                except Exception as e:
-                    logging.error(f"Error removing empty directory {root}: {e}")
-            
-            logging.info(f"Completed scheduled cleanup")
-            
-        except Exception as e:
-            logging.error(f"Error in cleanup task: {e}")
-        
-        # Run every hour
-        await asyncio.sleep(3600)