StreamingCommunity 3.3.6__py3-none-any.whl → 3.3.8__py3-none-any.whl

StreamingCommunity/Lib/Downloader/DASH/segments.py

@@ -25,13 +25,20 @@ SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
 
 
 class MPD_Segments:
-    def __init__(self, tmp_folder: str, representation: dict, pssh: str = None):
+    def __init__(self, tmp_folder: str, representation: dict, pssh: str = None, limit_segments: int = None):
         """
-        Initialize MPD_Segments with temp folder, representation, and optional pssh.
+        Initialize MPD_Segments with temp folder, representation, optional pssh, and segment limit.
+        
+        Parameters:
+            - tmp_folder (str): Temporary folder to store downloaded segments
+            - representation (dict): Selected representation with segment URLs
+            - pssh (str, optional): PSSH string for decryption
+            - limit_segments (int, optional): Optional limit for number of segments to download
         """
         self.tmp_folder = tmp_folder
         self.selected_representation = representation
         self.pssh = pssh
+        self.limit_segments = limit_segments
         self.download_interrupted = False
         self.info_nFailed = 0
         
@@ -42,7 +49,7 @@ class MPD_Segments:
         
         # Progress
         self._last_progress_update = 0
-        self._progress_update_interval = 0.5
+        self._progress_update_interval = 0.1
 
     def get_concat_path(self, output_dir: str = None):
         """
@@ -50,16 +57,35 @@ class MPD_Segments:
         """
         rep_id = self.selected_representation['id']
         return os.path.join(output_dir or self.tmp_folder, f"{rep_id}_encrypted.m4s")
+        
+    def get_segments_count(self) -> int:
+        """
+        Returns the total number of segments available in the representation.
+        """
+        return len(self.selected_representation.get('segment_urls', []))
 
-    def download_streams(self, output_dir: str = None):
+    def download_streams(self, output_dir: str = None, description: str = "DASH"):
         """
         Synchronous wrapper for download_segments, compatible with legacy calls.
+        
+        Parameters:
+            - output_dir (str): Output directory for segments
+            - description (str): Description for progress bar (e.g., "Video", "Audio Italian")
         """
         concat_path = self.get_concat_path(output_dir)
 
+        # Apply segment limit if specified
+        if self.limit_segments is not None:
+            orig_count = len(self.selected_representation.get('segment_urls', []))
+            if orig_count > self.limit_segments:
+                
+                # Limit segment URLs
+                self.selected_representation['segment_urls'] = self.selected_representation['segment_urls'][:self.limit_segments]
+                print(f"[yellow]Limiting segments from {orig_count} to {self.limit_segments}")
+
         # Run async download in sync mode
         try:
-            asyncio.run(self.download_segments(output_dir=output_dir))
+            asyncio.run(self.download_segments(output_dir=output_dir, description=description))
 
         except KeyboardInterrupt:
             self.download_interrupted = True
@@ -74,6 +100,11 @@ class MPD_Segments:
     async def download_segments(self, output_dir: str = None, concurrent_downloads: int = None, description: str = "DASH"):
         """
         Download and concatenate all segments (including init) asynchronously and in order.
+        
+        Parameters:
+            - output_dir (str): Output directory for segments
+            - concurrent_downloads (int): Number of concurrent downloads
+            - description (str): Description for progress bar (e.g., "Video", "Audio Italian")
         """
         rep = self.selected_representation
         rep_id = rep['id']
@@ -84,16 +115,15 @@ class MPD_Segments:
         concat_path = os.path.join(output_dir or self.tmp_folder, f"{rep_id}_encrypted.m4s")
 
         # Determine stream type (video/audio) for progress bar
-        stream_type = rep.get('type', description)
+        stream_type = description
         if concurrent_downloads is None:
-            concurrent_downloads = self._get_worker_count(stream_type)
+            worker_type = 'video' if 'Video' in description else 'audio'
+            concurrent_downloads = self._get_worker_count(worker_type)
 
         progress_bar = tqdm(
             total=len(segment_urls) + 1,
             desc=f"Downloading {rep_id}",
-            bar_format=self._get_bar_format(stream_type),
-            mininterval=1.0,
-            maxinterval=2.5,
+            bar_format=self._get_bar_format(stream_type)
         )
 
         # Define semaphore for concurrent downloads
@@ -231,7 +261,7 @@ class MPD_Segments:
                 # Update estimator with segment size
                 estimator.add_ts_file(len(data))
 
-                # Update progress bar with estimated info
+                # Update progress bar with estimated info and segment count
                 self._throttled_progress_update(len(data), estimator, progress_bar)
 
             except KeyboardInterrupt:
@@ -319,10 +349,11 @@ class MPD_Segments:
         Generate platform-appropriate progress bar format.
         """
         return (
-            f"{Colors.YELLOW}[MPD] ({Colors.CYAN}{description}{Colors.WHITE}): "
-            f"{Colors.RED}{{percentage:.2f}}% "
-            f"{Colors.MAGENTA}{{bar}} "
-            f"{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.WHITE}{{postfix}}{Colors.WHITE}"
+            f"{Colors.YELLOW}[DASH]{Colors.CYAN} {description}{Colors.WHITE}: "
+            f"{Colors.MAGENTA}{{bar:40}} "
+            f"{Colors.LIGHT_GREEN}{{n_fmt}}{Colors.WHITE}/{Colors.CYAN}{{total_fmt}} {Colors.LIGHT_MAGENTA}TS {Colors.WHITE}"
+            f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
+            f"{Colors.WHITE}{{postfix}}"
         )
 
     def _get_worker_count(self, stream_type: str) -> int:

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -1,7 +1,6 @@
 # 17.10.24
 
 import os
-import re
 import time
 import logging
 import shutil
@@ -20,7 +19,6 @@ 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.os import os_manager, internet_manager
-from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
 
 # Logic class
@@ -44,15 +42,14 @@ 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")
-TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
 
 console = Console()
 
 
 class HLSClient:
     """Client for making HTTP requests to HLS endpoints with retry mechanism."""
-    def __init__(self):
-        self.headers = {'User-Agent': get_userAgent()}
+    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]:
         """
@@ -238,22 +235,26 @@ class M3U8Manager:
             # Subtitle information
             available_subtitles = self.parser._subtitle.get_all_uris_and_names() or []
             available_sub_languages = [sub.get('language') for sub in available_subtitles]
-            available_subs = ', '.join(available_sub_languages) if available_sub_languages else "Nothing"
             
-            downloadable_sub_languages = available_sub_languages if "*" in DOWNLOAD_SPECIFIC_SUBTITLE else list(set(available_sub_languages) & set(DOWNLOAD_SPECIFIC_SUBTITLE))
-            downloadable_subs = ', '.join(downloadable_sub_languages) if downloadable_sub_languages else "Nothing"
-            
-            data_rows.append(["Subtitle", available_subs, ', '.join(DOWNLOAD_SPECIFIC_SUBTITLE), downloadable_subs])
+            if available_sub_languages:
+                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_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]
-            available_audios = ', '.join(available_audio_languages) if available_audio_languages else "Nothing"
             
-            downloadable_audio_languages = list(set(available_audio_languages) & set(DOWNLOAD_SPECIFIC_AUDIO))
-            downloadable_audios = ', '.join(downloadable_audio_languages) if downloadable_audio_languages else "Nothing"
-            
-            data_rows.append(["Audio", available_audios, ', '.join(DOWNLOAD_SPECIFIC_AUDIO), downloadable_audios])
+            if available_audio_languages:
+                available_audios = ', '.join(available_audio_languages)
+                
+                downloadable_audio_languages = list(set(available_audio_languages) & set(DOWNLOAD_SPECIFIC_AUDIO))
+                downloadable_audios = ', '.join(downloadable_audio_languages) if downloadable_audio_languages else "Nothing"
+                
+                data_rows.append(["Audio", available_audios, ', '.join(DOWNLOAD_SPECIFIC_AUDIO), downloadable_audios])
             
             # Calculate max width for each column
             headers = ["Type", "Available", "Set", "Downloadable"]
@@ -284,18 +285,21 @@ class M3U8Manager:
             
 class DownloadManager:
     """Manages downloading of video, audio, and subtitle streams."""
-    def __init__(self, temp_dir: str, client: HLSClient, url_fixer: M3U8_UrlFix):
+    def __init__(self, temp_dir: str, client: HLSClient, url_fixer: M3U8_UrlFix, custom_headers: Optional[Dict[str, str]] = None):
         """
         Args:
             temp_dir: Directory for storing temporary files
             client: HLSClient instance for making requests
             url_fixer: URL fixer instance for generating complete URLs
+            custom_headers: Optional custom headers to use for all requests
         """
         self.temp_dir = temp_dir
         self.client = client
         self.url_fixer = url_fixer
+        self.custom_headers = custom_headers
         self.missing_segments = []
         self.stopped = False
+        self.video_segments_count = 0
 
     def download_video(self, video_url: str) -> bool:
         """
@@ -308,8 +312,16 @@ class DownloadManager:
             video_full_url = self.url_fixer.generate_full_url(video_url)
             video_tmp_dir = os.path.join(self.temp_dir, 'video')
 
-            downloader = M3U8_Segments(url=video_full_url, tmp_folder=video_tmp_dir)
+            # Create downloader without segment limit for video
+            downloader = M3U8_Segments(
+                url=video_full_url, 
+                tmp_folder=video_tmp_dir,
+                custom_headers=self.custom_headers
+            )
+            
+            # 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)
 
             if result.get('stopped', False):
@@ -325,6 +337,7 @@ class DownloadManager:
     def download_audio(self, audio: Dict) -> bool:
         """
         Downloads audio segments for a specific language track.
+        Uses video segment count as a limit if available.
         
         Returns:
             bool: True if download was successful, False otherwise
@@ -332,8 +345,15 @@ class DownloadManager:
         try:
             audio_full_url = self.url_fixer.generate_full_url(audio['uri'])
             audio_tmp_dir = os.path.join(self.temp_dir, 'audio', audio['language'])
-
-            downloader = M3U8_Segments(url=audio_full_url, tmp_folder=audio_tmp_dir)
+            
+            # Create downloader with segment limit for audio
+            downloader = M3U8_Segments(
+                url=audio_full_url, 
+                tmp_folder=audio_tmp_dir,
+                limit_segments=self.video_segments_count if self.video_segments_count > 0 else None,
+                custom_headers=self.custom_headers
+            )
+            
             result = downloader.download_streams(f"Audio {audio['language']}", "audio")
             self.missing_segments.append(result)
 
@@ -500,10 +520,14 @@ class MergeManager:
 
 class HLS_Downloader:
     """Main class for HLS video download and processing."""
-    def __init__(self, m3u8_url: str, output_path: Optional[str] = None):
+    def __init__(self, m3u8_url: str, output_path: Optional[str] = None, headers: Optional[Dict[str, str]] = None):
+        """
+        Initializes the HLS_Downloader with parameters.
+        """
         self.m3u8_url = m3u8_url
         self.path_manager = PathManager(m3u8_url, output_path)
-        self.client = HLSClient()
+        self.custom_headers = headers
+        self.client = HLSClient(custom_headers=self.custom_headers)
         self.m3u8_manager = M3U8Manager(m3u8_url, self.client)
         self.download_manager: Optional[DownloadManager] = None
         self.merge_manager: Optional[MergeManager] = None
@@ -536,9 +560,6 @@ class HLS_Downloader:
 
         console.print("[cyan]You can safely stop the download with [bold]Ctrl+c[bold] [cyan]")
 
-        if TELEGRAM_BOT:
-            bot = get_bot_instance()
-
         try:
             if os.path.exists(self.path_manager.output_path):
                 console.print(f"[red]Output file {self.path_manager.output_path} already exists![/red]")
@@ -550,8 +571,6 @@ class HLS_Downloader:
                     'error': None,
                     'stopped': False
                 }
-                if TELEGRAM_BOT:
-                    bot.send_message("Contenuto già scaricato!", None)
                 return response
 
             self.path_manager.setup_directories()
@@ -559,12 +578,16 @@ class HLS_Downloader:
             # Parse M3U8 and determine if it's a master playlist
             self.m3u8_manager.parse()
             self.m3u8_manager.select_streams()
-            self.m3u8_manager.log_selection()
+
+            if self.m3u8_manager.is_master:
+                logging.info("Detected media playlist (not master)")
+                self.m3u8_manager.log_selection()
 
             self.download_manager = DownloadManager(
                 temp_dir=self.path_manager.temp_dir,
                 client=self.client,
-                url_fixer=self.m3u8_manager.url_fixer
+                url_fixer=self.m3u8_manager.url_fixer,
+                custom_headers=self.custom_headers
             )
 
             # Check if download had critical failures
@@ -639,9 +662,6 @@ class HLS_Downloader:
 
     def _print_summary(self, use_shortest: bool):
         """Prints download summary including file size, duration, and any missing segments."""
-        if TELEGRAM_BOT:
-            bot = get_bot_instance()
-
         missing_ts = False
         missing_info = ""
         for item in self.download_manager.missing_segments:
@@ -658,11 +678,6 @@ class HLS_Downloader:
             f"[cyan]Output: [bold]{os.path.abspath(self.path_manager.output_path)}[/bold]"
         )
 
-        if TELEGRAM_BOT:
-            message = f"Download completato\nDimensione: {file_size}\nDurata: {duration}\nPercorso: {os.path.abspath(self.path_manager.output_path)}"
-            clean_message = re.sub(r'\[[a-zA-Z]+\]', '', message)
-            bot.send_message(clean_message, None)
-
         if missing_ts:
             panel_content += f"\n{missing_info}"
 

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -11,7 +11,7 @@ import threading
 from queue import PriorityQueue
 from urllib.parse import urljoin, urlparse
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import Dict
+from typing import Dict, Optional
 
 
 # External libraries
@@ -51,7 +51,7 @@ console = Console()
 
 
 class M3U8_Segments:
-    def __init__(self, url: str, tmp_folder: str, is_index_url: bool = True):
+    def __init__(self, url: str, tmp_folder: str, is_index_url: bool = True, limit_segments: int = None, custom_headers: Optional[Dict[str, str]] = None):
         """
         Initializes the M3U8_Segments object.
 
@@ -59,10 +59,14 @@ class M3U8_Segments:
             - url (str): The URL of the M3U8 playlist.
             - tmp_folder (str): The temporary folder to store downloaded segments.
             - is_index_url (bool): Flag indicating if `m3u8_index` is a URL (default True).
+            - limit_segments (int): Optional limit for number of segments to process.
+            - custom_headers (Dict[str, str]): Optional custom headers to use for all requests.
         """
         self.url = url
         self.tmp_folder = tmp_folder
         self.is_index_url = is_index_url
+        self.limit_segments = limit_segments
+        self.custom_headers = custom_headers if custom_headers else {'User-Agent': get_userAgent()}
         self.expected_real_time = None
         self.tmp_file_path = os.path.join(self.tmp_folder, "0.ts")
         os.makedirs(self.tmp_folder, exist_ok=True)
@@ -103,7 +107,7 @@ class M3U8_Segments:
         self.active_retries_lock = threading.Lock()
 
         self._last_progress_update = 0
-        self._progress_update_interval = 0.5
+        self._progress_update_interval = 0.1
 
     def __get_key__(self, m3u8_parser: M3U8_Parser) -> bytes:
         """
@@ -120,7 +124,11 @@ class M3U8_Segments:
         self.key_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}/"
         
         try:
-            client_params = {'headers': {'User-Agent': get_userAgent()}, 'timeout': MAX_TIMEOOUT, 'verify': REQUEST_VERIFY}
+            client_params = {
+                'headers': self.custom_headers, 
+                'timeout': MAX_TIMEOOUT, 
+                'verify': REQUEST_VERIFY
+            }
             response = httpx.get(url=key_uri, **client_params)
             response.raise_for_status()
 
@@ -141,21 +149,31 @@ class M3U8_Segments:
         m3u8_parser.parse_data(uri=self.url, raw_content=m3u8_content)
 
         self.expected_real_time_s = m3u8_parser.duration
+        self.segment_init_url = m3u8_parser.init_segment
+        self.has_init_segment = self.segment_init_url is not None
 
         if m3u8_parser.keys:
             key = self.__get_key__(m3u8_parser)    
-            self.decryption = M3U8_Decryption(
-                key, 
-                m3u8_parser.keys.get('iv'), 
-                m3u8_parser.keys.get('method')
-            )
+            self.decryption = M3U8_Decryption(key, m3u8_parser.keys.get('iv'), m3u8_parser.keys.get('method'))
 
-        self.segments = [
+        segments = [
             self.class_url_fixer.generate_full_url(seg)
             if "http" not in seg else seg
             for seg in m3u8_parser.segments
         ]
+        
+        if self.limit_segments and len(segments) > self.limit_segments:
+            logging.info(f"Limiting segments from {len(segments)} to {self.limit_segments}")
+            segments = segments[:self.limit_segments]
+            
+        self.segments = segments
         self.class_ts_estimator.total_segments = len(self.segments)
+        
+    def get_segments_count(self) -> int:
+        """
+        Returns the total number of segments.
+        """
+        return len(self.segments) if hasattr(self, 'segments') else 0
 
     def get_info(self) -> None:
         """
@@ -163,7 +181,11 @@ class M3U8_Segments:
         """
         if self.is_index_url:
             try:
-                client_params = {'headers': {'User-Agent': get_userAgent()}, 'timeout': MAX_TIMEOOUT, 'verify': REQUEST_VERIFY}
+                client_params = {
+                    'headers': self.custom_headers, 
+                    'timeout': MAX_TIMEOOUT, 
+                    'verify': REQUEST_VERIFY
+                }
                 response = httpx.get(self.url, **client_params, follow_redirects=True)
                 response.raise_for_status()
                 
@@ -205,11 +227,12 @@ class M3U8_Segments:
     def _get_http_client(self):
         """
         Get a reusable HTTP client using the centralized factory.
-        Uses optimized settings for segment downloading.
+        Uses optimized settings for segment downloading with custom headers.
         """
         if self._client is None:
             with self._client_lock:
                 self._client = create_client(
+                    headers=self.custom_headers,
                     timeout=SEGMENT_MAX_TIMEOUT
                 )
                 
@@ -242,8 +265,8 @@ class M3U8_Segments:
                 client = self._get_http_client()
                 timeout = min(SEGMENT_MAX_TIMEOUT, 10 + attempt * 5)
 
-                # Make request
-                response = client.get(ts_url, timeout=timeout, headers={"User-Agent": get_userAgent()})
+                # Make request with custom headers
+                response = client.get(ts_url, timeout=timeout, headers=self.custom_headers)
                 response.raise_for_status()
                 segment_content = response.content
                 content_size = len(segment_content)
@@ -294,7 +317,7 @@ class M3U8_Segments:
                 self.info_nRetry += 1
 
                 if attempt + 1 == REQUEST_MAX_RETRY:
-                    console.print(f"[red]Final retry failed for segment: {index}")
+                    console.print(f" -- [red]Final retry failed for segment: {index}")
                     
                     try:
                         self.queue.put((index, None), timeout=0.1)
@@ -363,6 +386,52 @@ class M3U8_Segments:
                 except Exception as e:
                     logging.error(f"Error writing segment {index}: {str(e)}")
     
+    def download_init_segment(self) -> bool:
+        """
+        Downloads the initialization segment if available.
+        
+        Returns:
+            bool: True if init segment was downloaded successfully, False otherwise
+        """
+        if not self.has_init_segment:
+            return False
+            
+        init_url = self.segment_init_url
+        if not init_url.startswith("http"):
+            init_url = self.class_url_fixer.generate_full_url(init_url)
+            
+        try:
+            client = self._get_http_client()
+            response = client.get(
+                init_url, 
+                timeout=SEGMENT_MAX_TIMEOUT, 
+                headers=self.custom_headers
+            )
+            response.raise_for_status()
+            init_content = response.content
+            
+            # Decrypt if needed (although init segments are typically not encrypted)
+            if self.decryption is not None:
+                try:
+                    init_content = self.decryption.decrypt(init_content)
+
+                except Exception as e:
+                    logging.error(f"Decryption failed for init segment: {str(e)}")
+                    return False
+            
+            # Put init segment in queue with highest priority (0)
+            self.queue.put((0, init_content))
+            self.downloaded_segments.add(0)
+            
+            # Adjust expected_index to 1 since we've handled index 0 separately
+            self.expected_index = 0
+            logging.info("Init segment downloaded successfully")
+            return True
+            
+        except Exception as e:
+            logging.error(f"Failed to download init segment: {str(e)}")
+            return False
+    
     def download_streams(self, description: str, type: str):
         """
         Downloads all TS segments in parallel and writes them to a file.
@@ -378,33 +447,42 @@ class M3U8_Segments:
         self.setup_interrupt_handler()
 
         progress_bar = tqdm(
-            total=len(self.segments), 
-            unit='s',
-            ascii='░▒█',
+            total=len(self.segments) + (1 if self.has_init_segment else 0), 
             bar_format=self._get_bar_format(description),
-            mininterval=2.0,
-            maxinterval=5.0,
             file=sys.stdout,
         )
 
         try:
+            self.class_ts_estimator.total_segments = len(self.segments)
+            
             writer_thread = threading.Thread(target=self.write_segments_to_file)
             writer_thread.daemon = True
             writer_thread.start()
             max_workers = self._get_worker_count(type)
             
+            # First download the init segment if available
+            if self.has_init_segment:
+                if self.download_init_segment():
+                    progress_bar.update(1)
+            
             with ThreadPoolExecutor(max_workers=max_workers) as executor:
                 futures = []
                 
+                # Start segment indices from 1 if we have an init segment
+                start_idx = 1 if self.has_init_segment else 0
+                
                 for index, segment_url in enumerate(self.segments):
                     if self.interrupt_flag.is_set():
                         break
 
+                    # Adjust index if we have an init segment
+                    queue_index = index + start_idx
+                        
                     # Delay every 200 submissions to reduce CPU usage
                     if index % 200 == 0 and index > 0:
                         time.sleep(TQDM_DELAY_WORKER)
                         
-                    futures.append(executor.submit(self.download_segment, segment_url, index, progress_bar))
+                    futures.append(executor.submit(self.download_segment, segment_url, queue_index, progress_bar))
 
                 # Process completed futures
                 for future in as_completed(futures):
@@ -449,15 +527,17 @@ class M3U8_Segments:
 
         return self._generate_results(type)
     
+    
     def _get_bar_format(self, description: str) -> str:
         """
         Generate platform-appropriate progress bar format.
         """
         return (
-            f"{Colors.YELLOW}[HLS] {Colors.WHITE}({Colors.CYAN}{description}{Colors.WHITE}): "
-            f"{Colors.RED}{{percentage:.2f}}% "
-            f"{Colors.MAGENTA}{{bar}} "
-            f"{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.WHITE}{{postfix}}{Colors.WHITE}"
+            f"{Colors.YELLOW}[HLS]{Colors.CYAN} {description}{Colors.WHITE}: "
+            f"{Colors.MAGENTA}{{bar:40}} "
+            f"{Colors.LIGHT_GREEN}{{n_fmt}}{Colors.WHITE}/{Colors.CYAN}{{total_fmt}} {Colors.LIGHT_MAGENTA}TS {Colors.WHITE}"
+            f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
+            f"{Colors.WHITE}{{postfix}}"
         )
     
     def _get_worker_count(self, stream_type: str) -> int:

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -102,7 +102,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
     else:
         headers['User-Agent'] = get_userAgent()
 
-    # Set interrupt handler (only in main thread). In background threads (e.g., Django), skip custom signal handling.
+    # Set interrupt handler (only in main thread)
     temp_path = f"{path}.temp"
     interrupt_handler = InterruptHandler()
     original_handler = None
@@ -117,14 +117,12 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                 ),
             )
     except Exception:
-        # If setting signal handler fails (non-main thread), continue without it
         original_handler = None
 
     # Ensure the output directory exists
     os.makedirs(os.path.dirname(path), exist_ok=True)
 
     try:
-        # Use unified HTTP client (verify/timeout/proxy from config)
         with create_client() as client:
             with client.stream("GET", url, headers=headers) as response:
                 response.raise_for_status()
@@ -134,20 +132,20 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                     console.print("[bold red]No video stream found.[/bold red]")
                     return None, False
 
-                # Create a fancy progress bar
+                # 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.WHITE}: "
-                               f"{Colors.RED}{{percentage:.2f}}% {Colors.MAGENTA}{{bar}} {Colors.WHITE}[ "
-                               f"{Colors.YELLOW}{{n_fmt}}{Colors.WHITE} / {Colors.RED}{{total_fmt}} {Colors.WHITE}] "
-                               f"{Colors.YELLOW}{{elapsed}} {Colors.WHITE}< {Colors.CYAN}{{remaining}}{Colors.WHITE}, "
-                               f"{Colors.YELLOW}{{rate_fmt}}{{postfix}} ",
-                    unit='iB',
+                    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}}",
+                    unit='B',
                     unit_scale=True,
-                    desc='Downloading',
+                    unit_divisor=1024,
                     mininterval=0.05,
-                    file=sys.stdout                         # Using file=sys.stdout to force in-place updates because sys.stderr may not support carriage returns in this environment.  
+                    file=sys.stdout
                 )
 
                 downloaded = 0
@@ -171,6 +169,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
             os.rename(temp_path, path)
 
         if os.path.exists(path):
+            print("")
             console.print(Panel(
                 f"[bold green]Download completed{' (Partial)' if interrupt_handler.force_quit else ''}![/bold green]\n"
                 f"[cyan]File size: [bold red]{internet_manager.format_file_size(os.path.getsize(path))}[/bold red]\n"
@@ -202,4 +201,4 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
             try:
                 signal.signal(signal.SIGINT, original_handler)
             except Exception:
-                pass
+                pass