StreamingCommunity 3.3.9__py3-none-any.whl → 3.4.2__py3-none-any.whl

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -1,23 +1,20 @@
 # 17.10.24
 
 import os
-import time
 import logging
 import shutil
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 
 # External libraries
-import httpx
 from rich.console import Console
-from rich.panel import Panel
 from rich.table import Table
 
 
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.headers import get_userAgent
-from StreamingCommunity.Util.http_client import create_client
+from StreamingCommunity.Util.http_client import fetch
 from StreamingCommunity.Util.os import os_manager, internet_manager
 
 
@@ -33,15 +30,13 @@ from .segments import M3U8_Segments
 
 
 # Config
-ENABLE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'download_subtitle')
 DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_audio')
 DOWNLOAD_SPECIFIC_SUBTITLE = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_subtitles')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
 GET_ONLY_LINK = config_manager.get_int('M3U8_DOWNLOAD', 'get_only_link')
 FILTER_CUSTOM_RESOLUTION = str(config_manager.get('M3U8_CONVERSION', 'force_resolution')).strip().lower()
-RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
-MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
+EXTENSION_OUTPUT = config_manager.get("M3U8_CONVERSION", "extension")
 
 console = Console()
 
@@ -51,9 +46,9 @@ class HLSClient:
     def __init__(self, custom_headers: Optional[Dict[str, str]] = None):
         self.headers = custom_headers if custom_headers else {'User-Agent': get_userAgent()}
 
-    def request(self, url: str, return_content: bool = False) -> Optional[httpx.Response]:
+    def request(self, url: str, return_content: bool = False) -> Optional[Union[str, bytes]]:
         """
-        Makes HTTP GET requests with retry logic.
+        Makes HTTP GET requests with retry logic using http_client.
 
         Args:
             url: Target URL to request
@@ -67,21 +62,12 @@ class HLSClient:
             logging.error("URL is None or empty, cannot make request")
             return None
 
-        client = create_client(headers=self.headers)
-
-        for attempt in range(RETRY_LIMIT):
-            try:
-                response = client.get(url)
-                response.raise_for_status()
-                return response.content if return_content else response.text
-
-            except Exception as e:
-                logging.error(f"Attempt {attempt+1} failed for URL {url}: {str(e)}")
-                if attempt < RETRY_LIMIT - 1:  # Don't sleep on last attempt
-                    time.sleep(1.5 ** attempt)
-        
-        logging.error(f"All {RETRY_LIMIT} attempts failed for URL: {url}")
-        return None
+        return fetch(
+            url,
+            method="GET",
+            headers=self.headers,
+            return_content=return_content
+        )
 
 
 class PathManager:
@@ -94,7 +80,7 @@ class PathManager:
         """
         self.m3u8_url = m3u8_url
         self.output_path = self._sanitize_output_path(output_path)
-        base_name = os.path.basename(self.output_path).replace(".mp4", "")
+        base_name = os.path.basename(self.output_path).replace(EXTENSION_OUTPUT, "")
         self.temp_dir = os.path.join(os.path.dirname(self.output_path), f"{base_name}_tmp")
 
     def _sanitize_output_path(self, path: Optional[str]) -> str:
@@ -103,10 +89,10 @@ class PathManager:
         Creates a hash-based filename if no path is provided.
         """
         if not path:
-            path = "download.mp4"
+            path = f"download{EXTENSION_OUTPUT}"
             
-        if not path.endswith(".mp4"):
-            path += ".mp4"
+        if not path.endswith(EXTENSION_OUTPUT):
+            path += EXTENSION_OUTPUT
 
         return os_manager.get_sanitize_path(path)
 
@@ -168,6 +154,7 @@ class M3U8Manager:
         """
         Selects video, audio, and subtitle streams based on configuration.
         If it's a master playlist, only selects video stream.
+        Auto-selects first audio if only one is available and none match filters.
         """
         if not self.is_master:
             self.video_url, self.video_res = self.m3u8_url, "undefined"
@@ -175,6 +162,7 @@ class M3U8Manager:
             self.sub_streams = []
 
         else:
+            # Video selection logic
             if str(FILTER_CUSTOM_RESOLUTION) == "best":
                 self.video_url, self.video_res = self.parser._video.get_best_uri()
             elif str(FILTER_CUSTOM_RESOLUTION) == "worst":
@@ -182,25 +170,41 @@ class M3U8Manager:
             elif str(FILTER_CUSTOM_RESOLUTION).replace("p", "").replace("px", "").isdigit():
                 resolution_value = int(str(FILTER_CUSTOM_RESOLUTION).replace("p", "").replace("px", ""))
                 self.video_url, self.video_res = self.parser._video.get_custom_uri(resolution_value)
+
+                # Fallback to best if custom resolution not found
+                if self.video_url is None:
+                    self.video_url, self.video_res = self.parser._video.get_best_uri()
             else:
                 logging.error("Resolution not recognized.")
                 self.video_url, self.video_res = self.parser._video.get_best_uri()
 
-            # Audio info
+            # Audio selection with auto-select fallback
+            all_audio = self.parser._audio.get_all_uris_and_names() or []
+            
+            # Try to match with configured languages
             self.audio_streams = [
-                s for s in (self.parser._audio.get_all_uris_and_names() or [])
+                s for s in all_audio
                 if s.get('language') in DOWNLOAD_SPECIFIC_AUDIO
             ]
-
+            
+            # Auto-select first audio if:
+            # 1. No audio matched the filters
+            # 2. At least one audio track is available
+            # 3. Filters are configured (not empty)
+            if not self.audio_streams and all_audio and DOWNLOAD_SPECIFIC_AUDIO:
+                first_audio_lang = all_audio[0].get('language', 'unknown')
+                console.print(f"\n[yellow]Auto-selecting first available audio track: {first_audio_lang}[/yellow]")
+                self.audio_streams = [all_audio[0]]
+
+            # Subtitle selection
             self.sub_streams = []
-            if ENABLE_SUBTITLE:
-                if "*" in DOWNLOAD_SPECIFIC_SUBTITLE:
-                    self.sub_streams = self.parser._subtitle.get_all_uris_and_names() or []
-                else:
-                    self.sub_streams = [
-                        s for s in (self.parser._subtitle.get_all_uris_and_names() or [])
-                        if s.get('language') in DOWNLOAD_SPECIFIC_SUBTITLE
-                    ]
+            if "*" in DOWNLOAD_SPECIFIC_SUBTITLE:
+                self.sub_streams = self.parser._subtitle.get_all_uris_and_names() or []
+            else:
+                self.sub_streams = [
+                    s for s in (self.parser._subtitle.get_all_uris_and_names() or [])
+                    if s.get('language') in DOWNLOAD_SPECIFIC_SUBTITLE
+                ]
 
     def log_selection(self):
         """Log the stream selection information in a formatted table."""
@@ -220,38 +224,22 @@ class M3U8Manager:
             
             data_rows.append(["Video", available_video, str(FILTER_CUSTOM_RESOLUTION), downloadable_video])
             
-            # Codec information
-            if self.parser.codec is not None:
-                available_codec_info = (
-                    f"v: {self.parser.codec.video_codec_name} "
-                    f"(b: {self.parser.codec.video_bitrate // 1000}k), "
-                    f"a: {self.parser.codec.audio_codec_name} "
-                    f"(b: {self.parser.codec.audio_bitrate // 1000}k)"
-                )
-                set_codec_info = available_codec_info if config_manager.get_bool("M3U8_CONVERSION", "use_codec") else "copy"
-                
-                data_rows.append(["Codec", available_codec_info, set_codec_info, set_codec_info])
-
             # Subtitle information
             available_subtitles = self.parser._subtitle.get_all_uris_and_names() or []
-            available_sub_languages = [sub.get('language') for sub in available_subtitles]
-            
-            if available_sub_languages:
+            if available_subtitles:
+                available_sub_languages = [sub.get('language') for sub in available_subtitles]
                 available_subs = ', '.join(available_sub_languages)
-                
-                downloadable_sub_languages = available_sub_languages if "*" in DOWNLOAD_SPECIFIC_SUBTITLE else list(set(available_sub_languages) & set(DOWNLOAD_SPECIFIC_SUBTITLE))
+                downloadable_sub_languages = [sub.get('language') for sub in self.sub_streams]
                 downloadable_subs = ', '.join(downloadable_sub_languages) if downloadable_sub_languages else "Nothing"
                 
                 data_rows.append(["Subtitle", available_subs, ', '.join(DOWNLOAD_SPECIFIC_SUBTITLE), downloadable_subs])
 
             # Audio information
             available_audio = self.parser._audio.get_all_uris_and_names() or []
-            available_audio_languages = [audio.get('language') for audio in available_audio]
-            
-            if available_audio_languages:
+            if available_audio:
+                available_audio_languages = [audio.get('language') for audio in available_audio]
                 available_audios = ', '.join(available_audio_languages)
-                
-                downloadable_audio_languages = list(set(available_audio_languages) & set(DOWNLOAD_SPECIFIC_AUDIO))
+                downloadable_audio_languages = [audio.get('language') for audio in self.audio_streams]
                 downloadable_audios = ', '.join(downloadable_audio_languages) if downloadable_audio_languages else "Nothing"
                 
                 data_rows.append(["Audio", available_audios, ', '.join(DOWNLOAD_SPECIFIC_AUDIO), downloadable_audios])
@@ -282,7 +270,8 @@ class M3U8Manager:
 
         console.print(table)
         print("")
-            
+
+
 class DownloadManager:
     """Manages downloading of video, audio, and subtitle streams."""
     def __init__(self, temp_dir: str, client: HLSClient, url_fixer: M3U8_UrlFix, custom_headers: Optional[Dict[str, str]] = None):
@@ -301,6 +290,10 @@ class DownloadManager:
         self.stopped = False
         self.video_segments_count = 0
 
+        # For progress tracking
+        self.current_downloader: Optional[M3U8_Segments] = None
+        self.current_download_type: Optional[str] = None
+
     def download_video(self, video_url: str) -> bool:
         """
         Downloads video segments from the M3U8 playlist.
@@ -318,12 +311,20 @@ class DownloadManager:
                 tmp_folder=video_tmp_dir,
                 custom_headers=self.custom_headers
             )
+
+            # Set current downloader for progress tracking
+            self.current_downloader = downloader
+            self.current_download_type = 'video'
             
             # Download video and get segment count
             result = downloader.download_streams("Video", "video")
             self.video_segments_count = downloader.get_segments_count()
             self.missing_segments.append(result)
 
+            # Reset current downloader after completion
+            self.current_downloader = None
+            self.current_download_type = None
+
             if result.get('stopped', False):
                 self.stopped = True
                 return False
@@ -332,6 +333,8 @@ class DownloadManager:
         
         except Exception as e:
             logging.error(f"Error downloading video from {video_url}: {str(e)}")
+            self.current_downloader = None
+            self.current_download_type = None
             return False
 
     def download_audio(self, audio: Dict) -> bool:
@@ -353,10 +356,19 @@ class DownloadManager:
                 limit_segments=self.video_segments_count if self.video_segments_count > 0 else None,
                 custom_headers=self.custom_headers
             )
-            
+
+            # Set current downloader for progress tracking
+            self.current_downloader = downloader
+            self.current_download_type = f"audio_{audio['language']}"
+
+            # Download audio
             result = downloader.download_streams(f"Audio {audio['language']}", "audio")
             self.missing_segments.append(result)
 
+            # Reset current downloader after completion
+            self.current_downloader = None
+            self.current_download_type = None
+
             if result.get('stopped', False):
                 self.stopped = True
                 return False
@@ -365,6 +377,8 @@ class DownloadManager:
         
         except Exception as e:
             logging.error(f"Error downloading audio {audio.get('language', 'unknown')}: {str(e)}")
+            self.current_downloader = None
+            self.current_download_type = None
             return False
 
     def download_subtitle(self, sub: Dict) -> bool:
@@ -664,6 +678,7 @@ class HLS_Downloader:
         """Prints download summary including file size, duration, and any missing segments."""
         missing_ts = False
         missing_info = ""
+
         for item in self.download_manager.missing_segments:
             if int(item['nFailed']) >= 1:
                 missing_ts = True
@@ -672,30 +687,33 @@ class HLS_Downloader:
         file_size = internet_manager.format_file_size(os.path.getsize(self.path_manager.output_path))
         duration = print_duration_table(self.path_manager.output_path, description=False, return_string=True)
 
-        panel_content = (
-            f"[cyan]File size: [bold red]{file_size}[/bold red]\n"
-            f"[cyan]Duration: [bold]{duration}[/bold]\n"
-            f"[cyan]Output: [bold]{os.path.abspath(self.path_manager.output_path)}[/bold]"
-        )
-
-        if missing_ts:
-            panel_content += f"\n{missing_info}"
-
+        # Rename output file if there were missing segments or shortest used
         new_filename = self.path_manager.output_path
         if missing_ts and use_shortest:
-            new_filename = new_filename.replace(".mp4", "_failed_sync_ts.mp4")
+            new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_sync_ts{EXTENSION_OUTPUT}")
         elif missing_ts:
-            new_filename = new_filename.replace(".mp4", "_failed_ts.mp4")
+            new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_ts{EXTENSION_OUTPUT}")
         elif use_shortest:
-            new_filename = new_filename.replace(".mp4", "_failed_sync.mp4")
+            new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_sync{EXTENSION_OUTPUT}")
 
+        # Rename the file accordingly
         if missing_ts or use_shortest:
             os.rename(self.path_manager.output_path, new_filename)
             self.path_manager.output_path = new_filename
 
-        print("")
-        console.print(Panel(
-            panel_content,
-            title=f"{os.path.basename(self.path_manager.output_path.replace('.mp4', ''))}",
-            border_style="green"
-        ))
+        console.print(f"[yellow]Output [red]{os.path.abspath(self.path_manager.output_path)} [cyan]with size [red]{file_size} [cyan]and duration [red]{duration}")
+
+    def get_progress_data(self) -> Optional[Dict]:
+        """Get current download progress data."""
+        if not self.download_manager.current_downloader:
+            return None
+
+        try:
+            progress = self.download_manager.current_downloader.get_progress_data()
+            if progress:
+                progress['download_type'] = self.download_manager.current_download_type
+            return progress
+            
+        except Exception as e:
+            logging.error(f"Error getting progress data: {e}")
+            return None

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -18,6 +18,7 @@ from rich.console import Console
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.headers import get_userAgent
+from StreamingCommunity.Util.http_client import create_client_curl
 from StreamingCommunity.Util.config_json import config_manager
 
 
@@ -38,6 +39,7 @@ DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_w
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
 LIMIT_SEGMENT = config_manager.get_int('M3U8_DOWNLOAD', 'limit_segment')
+ENABLE_RETRY = config_manager.get_bool('M3U8_DOWNLOAD', 'enable_retry')
 
 
 # Variable
@@ -68,6 +70,8 @@ class M3U8_Segments:
             self.limit_segments = LIMIT_SEGMENT if LIMIT_SEGMENT > 0 else None
         else:
             self.limit_segments = limit_segments
+            
+        self.enable_retry = ENABLE_RETRY
 
         # Util class
         self.decryption: M3U8_Decryption = None 
@@ -94,12 +98,7 @@ class M3U8_Segments:
         self.key_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}/"
         
         try:
-            client_params = {
-                'headers': self.custom_headers, 
-                'timeout': MAX_TIMEOUT, 
-                'verify': REQUEST_VERIFY
-            }
-            response = httpx.get(url=key_uri, **client_params)
+            response = create_client_curl(headers=self.custom_headers).get(key_uri)
             response.raise_for_status()
 
             hex_content = binascii.hexlify(response.content).decode('utf-8')
@@ -146,12 +145,7 @@ class M3U8_Segments:
         """
         if self.is_index_url:
             try:
-                client_params = {
-                    'headers': self.custom_headers, 
-                    'timeout': MAX_TIMEOUT, 
-                    'verify': REQUEST_VERIFY
-                }
-                response = httpx.get(self.url, **client_params, follow_redirects=True)
+                response = create_client_curl(headers=self.custom_headers).get(self.url)
                 response.raise_for_status()
                 
                 self.parse_data(response.text)
@@ -174,7 +168,7 @@ class M3U8_Segments:
         """
         Get the file path for a temporary segment.
         """
-        return os.path.join(temp_dir, f"seg_{index:06d}.tmp")
+        return os.path.join(temp_dir, f"seg_{index:06d}.ts")
 
     async def _download_init_segment(self, client: httpx.AsyncClient, output_path: str, progress_bar: tqdm) -> bool:
         """
@@ -220,7 +214,7 @@ class M3U8_Segments:
     async def _download_single_segment(self, client: httpx.AsyncClient, ts_url: str, index: int, temp_dir: str,
                                        semaphore: asyncio.Semaphore, max_retry: int) -> tuple:
         """
-        Downloads a single TS segment and saves to temp file.
+        Downloads a single TS segment and saves to temp file IMMEDIATELY.
 
         Returns:
             tuple: (index, success, retry_count, file_size)
@@ -248,11 +242,13 @@ class M3U8_Segments:
                                 return index, False, attempt, 0
                             raise e
 
-                    # Write to temp file
+                    # Write segment to temp file IMMEDIATELY
                     with open(temp_file, 'wb') as f:
                         f.write(segment_content)
-
-                    return index, True, attempt, len(segment_content)
+                    
+                    size = len(segment_content)
+                    del segment_content
+                    return index, True, attempt, size
 
                 except Exception:
                     if attempt + 1 == max_retry:
@@ -296,8 +292,8 @@ class M3U8_Segments:
                 console.print("\n[red]Download interrupted by user (Ctrl+C).")
                 break
 
-        # Retry failed segments
-        if not self.download_interrupted:
+        # Retry failed segments only if enabled
+        if self.enable_retry and not self.download_interrupted:
             await self._retry_failed_segments(client, temp_dir, semaphore, progress_bar)
 
     async def _retry_failed_segments(self, client: httpx.AsyncClient, temp_dir: str, semaphore: asyncio.Semaphore, 
@@ -356,6 +352,7 @@ class M3U8_Segments:
                 if os.path.exists(temp_file):
                     with open(temp_file, 'rb') as infile:
                         outfile.write(infile.read())
+                    os.remove(temp_file)
 
     async def download_segments_async(self, description: str, type: str):
         """
@@ -473,13 +470,12 @@ class M3U8_Segments:
         """Ensure resource cleanup and final reporting."""
         progress_bar.close()
         
-        # Delete temp segment files
+        # Delete temp directory if exists
         if temp_dir and os.path.exists(temp_dir):
             try:
-                for idx in range(len(self.segments)):
-                    temp_file = self._get_temp_segment_path(temp_dir, idx)
-                    if os.path.exists(temp_file):
-                        os.remove(temp_file)
+                # Remove any remaining files (in case of interruption)
+                for file in os.listdir(temp_dir):
+                    os.remove(os.path.join(temp_dir, file))
                 os.rmdir(temp_dir)
             except Exception as e:
                 console.print(f"[yellow]Warning: Could not clean temp directory: {e}")
@@ -489,7 +485,23 @@ class M3U8_Segments:
 
     def _display_error_summary(self) -> None:
         """Generate final error report."""
-        console.print(f"\n[green]Retry Summary: "
-                     f"[cyan]Max retries: [red]{self.info_maxRetry} "
-                     f"[cyan]Total retries: [red]{self.info_nRetry} "
-                     f"[cyan]Failed segments: [red]{self.info_nFailed}")
+        console.print(f" [cyan]Max retries: [red]{self.info_maxRetry} [white] | "
+            f"[cyan]Total retries: [red]{self.info_nRetry} [white] | "
+            f"[cyan]Failed segments: [red]{self.info_nFailed}")
+        
+    def get_progress_data(self) -> Dict:
+        """Returns current download progress data for API consumption."""
+        total = self.get_segments_count()
+        downloaded = len(self.downloaded_segments)
+        percentage = (downloaded / total * 100) if total > 0 else 0
+        stats = self.class_ts_estimator.get_stats(downloaded, total)
+        
+        return {
+            'total_segments': total,
+            'downloaded_segments': downloaded,
+            'failed_segments': self.info_nFailed,
+            'current_speed': stats['download_speed'],
+            'estimated_size': stats['estimated_total_size'],
+            'percentage': round(percentage, 2),
+            'eta_seconds': stats['eta_seconds']
+        }

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -76,6 +76,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
     - Single Ctrl+C: Completes download gracefully
     - Triple Ctrl+C: Saves partial download and exits
     """
+    url = url.strip()
     if TELEGRAM_BOT:
         bot = get_bot_instance()
         console.log("####")
@@ -134,20 +135,23 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
 
                 # Create progress bar with percentage instead of n_fmt/total_fmt
                 console.print("[cyan]You can safely stop the download with [bold]Ctrl+c[bold] [cyan]")
+                
                 progress_bar = tqdm(
                     total=total,
                     ascii='░▒█',
                     bar_format=f"{Colors.YELLOW}MP4{Colors.CYAN} Downloading{Colors.WHITE}: "
-                               f"{Colors.RED}{{percentage:.1f}}% {Colors.MAGENTA}{{bar:40}} {Colors.WHITE}"
-                               f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
-                               f"{Colors.LIGHT_CYAN}{{rate_fmt}}",
+                               f"{Colors.MAGENTA}{{bar:40}} "
+                               f"{Colors.LIGHT_GREEN}{{n_fmt}}{Colors.WHITE}/{Colors.CYAN}{{total_fmt}}"
+                               f" {Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}]"
+                               f"{Colors.WHITE}{{postfix}} ",
                     unit='B',
                     unit_scale=True,
                     unit_divisor=1024,
                     mininterval=0.05,
                     file=sys.stdout
                 )
-
+                
+                start_time = time.time()
                 downloaded = 0
                 with open(temp_path, 'wb') as file, progress_bar as bar:
                     try:
@@ -160,6 +164,14 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                                 size = file.write(chunk)
                                 downloaded += size
                                 bar.update(size)
+                                
+                                # Update postfix with speed and final size
+                                elapsed = time.time() - start_time
+                                if elapsed > 0:
+                                    speed = downloaded / elapsed
+                                    speed_str = internet_manager.format_transfer_speed(speed)
+                                    postfix_str = f"{Colors.LIGHT_MAGENTA}@ {Colors.LIGHT_CYAN}{speed_str}"
+                                    bar.set_postfix_str(postfix_str)
 
                     except KeyboardInterrupt:
                         if not interrupt_handler.force_quit:

StreamingCommunity/Lib/FFmpeg/capture.py

@@ -1,6 +1,7 @@
 # 16.04.24
 
 import re
+import time
 import logging
 import threading
 import subprocess
@@ -29,6 +30,7 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
     """
     try:
         max_length = 0
+        start_time = time.time()
 
         for line in iter(process.stdout.readline, ''):          
             try:
@@ -44,8 +46,7 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
 
                 if "size=" in line:
                     try:
-
-                        # Parse the output line to extract relevant information
+                        elapsed_time = time.time() - start_time
                         data = parse_output_line(line)
 
                         if 'q' in data:
@@ -55,11 +56,25 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
                         else:
                             byte_size = int(re.findall(r'\d+', data.get('size', '0'))[0]) * 1000
 
+                        # Extract additional information
+                        fps = data.get('fps', 'N/A')
+                        time_processed = data.get('time', 'N/A')
+                        bitrate = data.get('bitrate', 'N/A')
+                        speed = data.get('speed', 'N/A')
+
+                        # Format elapsed time as HH:MM:SS
+                        elapsed_formatted = format_time(elapsed_time)
 
                         # Construct the progress string with formatted output information
-                        progress_string = (f"{description}[white]: "
-                                           f"([green]'speed': [yellow]{data.get('speed', 'N/A')}[white], "
-                                           f"[green]'size': [yellow]{internet_manager.format_file_size(byte_size)}[white])")
+                        progress_string = (
+                            f"{description}[white]: "
+                            f"([green]'fps': [yellow]{fps}[white], "
+                            f"[green]'speed': [yellow]{speed}[white], "
+                            f"[green]'size': [yellow]{internet_manager.format_file_size(byte_size)}[white], "
+                            f"[green]'time': [yellow]{time_processed}[white], "
+                            f"[green]'bitrate': [yellow]{bitrate}[white], "
+                            f"[green]'elapsed': [yellow]{elapsed_formatted}[white])"
+                        )
                         max_length = max(max_length, len(progress_string))
 
                         # Print the progress string to the console, overwriting the previous line
@@ -81,6 +96,19 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
             logging.error(f"Error terminating process: {e}")
 
 
+def format_time(seconds: float) -> str:
+    """
+    Format seconds into HH:MM:SS format.
+
+    Parameters:
+        - seconds (float): Time in seconds.
+    """
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}"
+
+
 def parse_output_line(line: str) -> dict:
     """
     Function to parse the output line and extract relevant information.
@@ -101,6 +129,10 @@ def parse_output_line(line: str) -> dict:
             if len(key_value) == 2:
                 key = key_value[0]
                 value = key_value[1]
+
+                # Remove milliseconds from time value
+                if key == 'time' and isinstance(value, str) and '.' in value:
+                    value = value.split('.')[0]
                 data[key] = value
 
         return data