StreamingCommunity 2.5.6__py3-none-any.whl → 2.5.8__py3-none-any.whl

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -3,6 +3,7 @@
 import os
 import re
 import sys
+import time
 import signal
 import logging
 from functools import partial
@@ -39,21 +40,38 @@ TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
 
 
 
-def signal_handler(signum, frame, kill_handler):
-    """Signal handler for graceful interruption"""
-    kill_handler[0] = True
-    print("\nReceived interrupt signal. Completing current download...")
+class InterruptHandler:
+    def __init__(self):
+        self.interrupt_count = 0
+        self.last_interrupt_time = 0
+        self.kill_download = False
+        self.force_quit = False
 
+def signal_handler(signum, frame, interrupt_handler, original_handler):
+    """Enhanced signal handler for multiple interrupt scenarios"""
+    current_time = time.time()
+    
+    # Reset counter if more than 2 seconds have passed since last interrupt
+    if current_time - interrupt_handler.last_interrupt_time > 2:
+        interrupt_handler.interrupt_count = 0
+    
+    interrupt_handler.interrupt_count += 1
+    interrupt_handler.last_interrupt_time = current_time
+
+    if interrupt_handler.interrupt_count == 1:
+        interrupt_handler.kill_download = True
+        console.print("\n[bold yellow]First interrupt received. Download will complete and save. Press Ctrl+C three times quickly to force quit.[/bold yellow]")
+    
+    elif interrupt_handler.interrupt_count >= 3:
+        interrupt_handler.force_quit = True
+        console.print("\n[bold red]Force quit activated. Saving partial download...[/bold red]")
+        signal.signal(signum, original_handler)
 
 def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = None):
     """
-    Downloads an MP4 video from a given URL with robust error handling and SSL bypass.
-
-    Parameters:
-        - url (str): The URL of the MP4 video to download.
-        - path (str): The local path where the downloaded MP4 file will be saved.
-        - referer (str, optional): The referer header value.
-        - headers_ (dict, optional): Custom headers for the request.
+    Downloads an MP4 video with enhanced interrupt handling.
+    - Single Ctrl+C: Completes download gracefully
+    - Triple Ctrl+C: Saves partial download and exits
     """
     if TELEGRAM_BOT:
         bot = get_bot_instance()
@@ -65,23 +83,19 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
             bot.send_message(f"Contenuto già scaricato!", None)
         return 400
 
-    # Early return for link-only mode
     if GET_ONLY_LINK:
         return {'path': path, 'url': url}
 
-    # Validate URL
     if not (url.lower().startswith('http://') or url.lower().startswith('https://')):
         logging.error(f"Invalid URL: {url}")
         console.print(f"[bold red]Invalid URL: {url}[/bold red]")
         return None
 
-    # Prepare headers
     try:
         headers = {}
         if referer:
             headers['Referer'] = referer
         
-        # Use custom headers if provided, otherwise use default user agent
         if headers_:
             headers.update(headers_)
         else:
@@ -93,17 +107,12 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
         return None
     
     temp_path = f"{path}.temp"
-    kill_handler = [False]  # Using list for mutable state
-    original_handler = signal.signal(signal.SIGINT, partial(signal_handler, kill_handler=kill_handler))
+    interrupt_handler = InterruptHandler()
+    original_handler = signal.signal(signal.SIGINT, partial(signal_handler, interrupt_handler=interrupt_handler, original_handler=signal.getsignal(signal.SIGINT)))
 
     try:
-        # Create a custom transport that bypasses SSL verification
-        transport = httpx.HTTPTransport(
-            verify=False, 
-            http2=True
-        )
+        transport = httpx.HTTPTransport(verify=False, http2=True)
         
-        # Download with streaming and progress tracking
         with httpx.Client(transport=transport, timeout=httpx.Timeout(60)) as client:
             with client.stream("GET", url, headers=headers, timeout=REQUEST_TIMEOUT) as response:
                 response.raise_for_status()
@@ -119,21 +128,22 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                     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}} {Colors.WHITE}]",
+                               f"{Colors.YELLOW}{{elapsed}} {Colors.WHITE}< {Colors.CYAN}{{remaining}}{Colors.WHITE}, "
+                               f"{Colors.YELLOW}{{rate_fmt}}{{postfix}} ",
                     unit='iB',
                     unit_scale=True,
                     desc='Downloading',
-                    mininterval=0.05
+                    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.
                 )
 
                 downloaded = 0
                 with open(temp_path, 'wb') as file, progress_bar as bar:
                     try:
                         for chunk in response.iter_bytes(chunk_size=1024):
-                            if kill_handler[0]:
-                                console.print("\n[bold yellow]Interrupting download...[/bold yellow]")
-                                return None, True
+                            if interrupt_handler.force_quit:
+                                console.print("\n[bold red]Force quitting... Saving partial download.[/bold red]")
+                                break
                             
                             if chunk:
                                 size = file.write(chunk)
@@ -141,18 +151,15 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                                 bar.update(size)
 
                     except KeyboardInterrupt:
-                        console.print("\n[bold red]Download interrupted by user.[/bold red]")
-                        if os.path.exists(temp_path):
-                            os.remove(temp_path)
-                        return None, True
+                        if not interrupt_handler.force_quit:
+                            interrupt_handler.kill_download = True
                     
-        # Rename temp file to final file
         if os.path.exists(temp_path):
             os.rename(temp_path, path)
 
         if os.path.exists(path):
             console.print(Panel(
-                f"[bold green]Download completed![/bold green]\n"
+                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"
                 f"[cyan]Duration: [bold]{print_duration_table(path, description=False, return_string=True)}[/bold]", 
                 title=f"{os.path.basename(path.replace('.mp4', ''))}", 
@@ -160,22 +167,22 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
             ))
 
             if TELEGRAM_BOT:
-                message = f"Download completato\nDimensione: {internet_manager.format_file_size(os.path.getsize(path))}\nDurata: {print_duration_table(path, description=False, return_string=True)}\nTitolo: {os.path.basename(path.replace('.mp4', ''))}"
+                message = f"Download completato{'(Parziale)' if interrupt_handler.force_quit else ''}\nDimensione: {internet_manager.format_file_size(os.path.getsize(path))}\nDurata: {print_duration_table(path, description=False, return_string=True)}\nTitolo: {os.path.basename(path.replace('.mp4', ''))}"
                 clean_message = re.sub(r'\[[a-zA-Z]+\]', '', message)
                 bot.send_message(clean_message, None)
 
-            return path, kill_handler[0]
+            return path, interrupt_handler.kill_download
+        
         else:
             console.print("[bold red]Download failed or file is empty.[/bold red]")
-            return None, kill_handler[0]
+            return None, interrupt_handler.kill_download
 
     except Exception as e:
         logging.error(f"Unexpected error: {e}")
         console.print(f"[bold red]Unexpected Error: {e}[/bold red]")
         if os.path.exists(temp_path):
             os.remove(temp_path)
-        return None, kill_handler[0]
+        return None, interrupt_handler.kill_download
     
     finally:
-        # Restore original signal handler
         signal.signal(signal.SIGINT, original_handler)

StreamingCommunity/Lib/FFmpeg/command.py

@@ -3,7 +3,7 @@
 import sys
 import logging
 import subprocess
-from typing import List, Dict
+from typing import List, Dict, Tuple, Optional
 
 
 # Internal utilities
@@ -34,6 +34,62 @@ USE_LARGE_BAR = not ("android" in sys.platform or "ios" in sys.platform)
 FFMPEG_PATH = os_summary.ffmpeg_path
 
 
+
+def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
+    """
+    Executes 'ffmpeg -encoders' and checks if 'mov_text' and 'webvtt' encoders are available.
+    
+    Returns:
+        Tuple[Optional[bool], Optional[bool]]: A tuple containing (mov_text_supported, webvtt_supported)
+            Returns (None, None) if the FFmpeg command fails
+    """
+    try:
+        result = subprocess.run(
+            [FFMPEG_PATH, '-encoders'],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        # Check for encoder presence in output
+        output = result.stdout
+        mov_text_supported = "mov_text" in output
+        webvtt_supported = "webvtt" in output
+        
+        return mov_text_supported, webvtt_supported
+        
+    except subprocess.CalledProcessError as e:
+        print(f"Error executing 'ffmpeg -encoders': {e}")
+        return None, None
+
+
+def select_subtitle_encoder() -> Optional[str]:
+    """
+    Determines the best available subtitle encoder to use.
+    Prefers mov_text over webvtt if both are available.
+ 
+    Returns:
+        Optional[str]: Name of the best available encoder ('mov_text' or 'webvtt')
+            or None if no supported encoder is found
+    """
+    mov_text_supported, webvtt_supported = check_subtitle_encoders()
+    
+    # Return early if check failed
+    if mov_text_supported is None:
+        return None
+        
+    # Prioritize mov_text over webvtt
+    if mov_text_supported:
+        logging.info("Using 'mov_text' as the subtitle encoder.")
+        return "mov_text"
+    elif webvtt_supported:
+        logging.info("Using 'webvtt' as the subtitle encoder.")
+        return "webvtt"
+    
+    logging.error("No supported subtitle encoder found.")
+    return None
+
+
 def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
     """
     Joins single ts video file to mp4
@@ -238,9 +294,9 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
 
     # Add output Parameters
     if USE_CODEC:
-        ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', 'mov_text'])
+        ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', select_subtitle_encoder()])
     else:
-        ffmpeg_cmd.extend(['-c', 'copy', '-c:s', 'mov_text'])
+        ffmpeg_cmd.extend(['-c', 'copy', '-c:s', select_subtitle_encoder()])
 
     # Overwrite
     ffmpeg_cmd += [out_path, "-y"]

StreamingCommunity/Lib/M3U8/estimator.py

@@ -106,12 +106,12 @@ class M3U8_Ts_Estimator:
         try:
             self.add_ts_file(total_downloaded * self.total_segments, total_downloaded, duration)
             
-            downloaded_file_size_str = internet_manager.format_file_size(self.now_downloaded_size)
+            #downloaded_file_size_str = internet_manager.format_file_size(self.now_downloaded_size)
             file_total_size = self.calculate_total_size()
             
-            number_file_downloaded = downloaded_file_size_str.split(' ')[0]
+            #number_file_downloaded = downloaded_file_size_str.split(' ')[0]
             number_file_total_size = file_total_size.split(' ')[0]
-            units_file_downloaded = downloaded_file_size_str.split(' ')[1]
+            #units_file_downloaded = downloaded_file_size_str.split(' ')[1]
             units_file_total_size = file_total_size.split(' ')[1]
             
             if USE_LARGE_BAR:
@@ -124,21 +124,19 @@ class M3U8_Ts_Estimator:
                     average_internet_speed = "N/A"
                     average_internet_unit = ""
                 
-                # Retrieve retry count from segments_instance
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
-                    f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size} "
-                    f"{Colors.WHITE}| {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit} "
-                    f"{Colors.WHITE}| {Colors.GREEN}CRR {Colors.RED}{retry_count}"
+                    #f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
+                    f"{Colors.WHITE} {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
+                    f"{Colors.WHITE} {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
             else:
-                # Retrieve retry count from segments_instance
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
-                    f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size} "
-                    f"{Colors.WHITE}| {Colors.GREEN}CRR {Colors.RED}{retry_count}"
+                    #f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
+                    f"{Colors.WHITE} {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
             
             progress_counter.set_postfix_str(progress_str)

StreamingCommunity/Lib/M3U8/parser.py

@@ -39,12 +39,17 @@ CODEC_MAPPINGS = {
 }
     
 RESOLUTIONS = [
-    (7680, 4320),
-    (3840, 2160),
-    (2560, 1440),
-    (1920, 1080),
-    (1280, 720),
-    (640, 480)
+    (7680, 4320),  # 8K
+    (3840, 2160),  # 4K
+    (2560, 1440),  # 1440p
+    (1920, 1080),  # 1080p
+    (1280, 720),   # 720p
+    (640, 480),    # VGA
+    (640, 360),    # 360p
+    (480, 320),    # HVGA
+    (426, 240),    # 240p
+    (320, 240),    # QVGA
+    (256, 144),    # 144p
 ]
 
 
@@ -377,47 +382,6 @@ class M3U8_Subtitle:
                 return subtitle
         return None
 
-    def download_all(self, custom_subtitle):
-        """
-        Download all subtitles listed in the object's attributes, filtering based on a provided list of custom subtitles.
-
-        Parameters:
-            - custom_subtitle (list): A list of custom subtitles to download.
-
-        Returns:
-            list: A list containing dictionaries with subtitle information including name, language, and URI.
-        """
-            
-        output = []  # Initialize an empty list to store subtitle information
-
-        # Iterate through all available subtitles
-        for obj_subtitle in self.subtitle_get_all_uris_and_names():
-
-            # Check if the subtitle name is not in the list of custom subtitles, and skip if not found
-            if obj_subtitle.get('name') not in custom_subtitle:
-                continue
-
-            # Send a request to retrieve the subtitle content
-            logging.info(f"Download subtitle: {obj_subtitle.get('name')}")
-            response_subitle = httpx.get(obj_subtitle.get('uri'))
-
-            try:
-                # Try to extract the VTT URL from the subtitle content
-                sub_parse = M3U8_Parser()
-                sub_parse.parse_data(obj_subtitle.get('uri'), response_subitle.text)
-                url_subititle = sub_parse.subtitle[0]
-
-                output.append({
-                    'name': obj_subtitle.get('name'),
-                    'language': obj_subtitle.get('language'),
-                    'uri': url_subititle
-                })
-
-            except Exception as e:
-                logging.error(f"Cant download: {obj_subtitle.get('name')}, error: {e}")
-
-        return output
-
 
 class M3U8_Parser:
     def __init__(self):
@@ -555,7 +519,6 @@ class M3U8_Parser:
             - m3u8_obj: The M3U8 object containing encryption keys.
         """
         try:
-
             if m3u8_obj.key is not None:
                 if self.keys is None:
                     self.keys = {
@@ -564,7 +527,6 @@ class M3U8_Parser:
                         'uri': m3u8_obj.key.uri
                     }
 
-
         except Exception as e:
             logging.error(f"Error parsing encryption keys: {e}")
             sys.exit(0)
@@ -629,7 +591,6 @@ class M3U8_Parser:
         """
         Initialize variables for video, audio, and subtitle playlists.
         """
-
         self._video = M3U8_Video(self.video_playlist)
         self._audio = M3U8_Audio(self.audio_playlist)
         self._subtitle = M3U8_Subtitle(self.subtitle_playlist)
@@ -663,4 +624,4 @@ class M3U8_Parser:
         if return_string:
             return f"[yellow]{int(hours)}[red]h [yellow]{int(minutes)}[red]m [yellow]{int(seconds)}[red]s"
         else:
-            return {'h': int(hours), 'm': int(minutes), 's': int(seconds)}
+            return {'h': int(hours), 'm': int(minutes), 's': int(seconds)}