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

StreamingCommunity/Api/Template/config_loader.py

@@ -0,0 +1,71 @@
+# 11.02.25
+
+import os
+import inspect
+
+
+# Internal utilities
+from StreamingCommunity.Util._jsonConfig import config_manager
+
+
+def get_site_name_from_stack():
+    for frame_info in inspect.stack():
+        file_path = frame_info.filename
+        
+        if "__init__" in file_path:
+            parts = file_path.split(f"Site{os.sep}")
+            
+            if len(parts) > 1:
+                site_name = parts[1].split(os.sep)[0]
+                return site_name
+    
+    return None
+
+
+class SiteConstant:
+    @property
+    def SITE_NAME(self):
+        return get_site_name_from_stack()
+    
+    @property
+    def ROOT_PATH(self):
+        return config_manager.get('DEFAULT', 'root_path')
+    
+    @property
+    def DOMAIN_NOW(self):
+        return config_manager.get_dict('SITE', self.SITE_NAME)['domain']
+    
+    @property
+    def SERIES_FOLDER(self):
+        base_path = self.ROOT_PATH
+        if config_manager.get_bool("DEFAULT", "add_siteName"):
+            base_path = os.path.join(base_path, self.SITE_NAME)
+        return os.path.join(base_path, config_manager.get('DEFAULT', 'serie_folder_name'))
+    
+    @property
+    def MOVIE_FOLDER(self):
+        base_path = self.ROOT_PATH
+        if config_manager.get_bool("DEFAULT", "add_siteName"):
+            base_path = os.path.join(base_path, self.SITE_NAME)
+        return os.path.join(base_path, config_manager.get('DEFAULT', 'movie_folder_name'))
+    
+    @property
+    def ANIME_FOLDER(self):
+        base_path = self.ROOT_PATH
+        if config_manager.get_bool("DEFAULT", "add_siteName"):
+            base_path = os.path.join(base_path, self.SITE_NAME)
+        return os.path.join(base_path, config_manager.get('DEFAULT', 'anime_folder_name'))
+    
+    @property
+    def COOKIE(self):
+        try:
+            return config_manager.get_dict('SITE', self.SITE_NAME)['extra']
+        except KeyError:
+            return None
+    
+    @property
+    def TELEGRAM_BOT(self):
+        return config_manager.get_bool('DEFAULT', 'telegram_bot')
+
+
+site_constant = SiteConstant()

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -43,7 +43,7 @@ DOWNLOAD_SPECIFIC_SUBTITLE = config_manager.get_list('M3U8_DOWNLOAD', 'specific_
 MERGE_AUDIO = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_audio')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
-FILTER_CUSTOM_REOLUTION = config_manager.get_int('M3U8_PARSER', 'force_resolution')
+FILTER_CUSTOM_REOLUTION = str(config_manager.get('M3U8_PARSER', 'force_resolution')).strip().lower()
 GET_ONLY_LINK = config_manager.get_bool('M3U8_PARSER', 'get_only_link')
 RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
@@ -60,11 +60,11 @@ class HLSClient:
     def request(self, url: str, return_content: bool = False) -> Optional[httpx.Response]:
         """
         Makes HTTP GET requests with retry logic.
-        
+
         Args:
             url: Target URL to request
             return_content: If True, returns response content instead of text
-            
+
         Returns:
             Response content/text or None if all retries fail
         """
@@ -74,7 +74,7 @@ class HLSClient:
                 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: {str(e)}")
                 time.sleep(1.5 ** attempt)
@@ -103,7 +103,7 @@ class PathManager:
             root = config_manager.get('DEFAULT', 'root_path')
             hash_name = compute_sha1_hash(self.m3u8_url) + ".mp4"
             return os.path.join(root, "undefined", hash_name)
-        
+
         if not path.endswith(".mp4"):
             path += ".mp4"
 
@@ -148,7 +148,7 @@ class M3U8Manager:
         content = self.client.request(self.m3u8_url)
         if not content:
             raise ValueError("Failed to fetch M3U8 content")
-        
+
         self.parser.parse_data(uri=self.m3u8_url, raw_content=content)
         self.url_fixer.set_playlist(self.m3u8_url)
         self.is_master = self.parser.is_master_playlist
@@ -159,18 +159,19 @@ class M3U8Manager:
         If it's a master playlist, only selects video stream.
         """
         if not self.is_master:
-            if FILTER_CUSTOM_REOLUTION != -1:
-                self.video_url, self.video_res = self.parser._video.get_custom_uri(y_resolution=FILTER_CUSTOM_REOLUTION)
-            else:
-                self.video_url, self.video_res = self.parser._video.get_best_uri()
-
+            self.video_url, self.video_res = self.m3u8_url, "0p"
             self.audio_streams = []
             self.sub_streams = []
-            
+
         else:
-            if FILTER_CUSTOM_REOLUTION != -1:
-                self.video_url, self.video_res = self.parser._video.get_custom_uri(y_resolution=FILTER_CUSTOM_REOLUTION)
+            if str(FILTER_CUSTOM_REOLUTION) == "best":
+                self.video_url, self.video_res = self.parser._video.get_best_uri()
+            elif str(FILTER_CUSTOM_REOLUTION) == "worst":
+                self.video_url, self.video_res = self.parser._video.get_worst_uri()
+            elif "p" in str(FILTER_CUSTOM_REOLUTION):
+                self.video_url, self.video_res = self.parser._video.get_custom_uri(int(FILTER_CUSTOM_REOLUTION.replace("p", "")))
             else:
+                logging.error("Resolution not recognized.")
                 self.video_url, self.video_res = self.parser._video.get_best_uri()
 
             self.audio_streams = []
@@ -188,17 +189,12 @@ class M3U8Manager:
                 ]
 
     def log_selection(self):
-        if FILTER_CUSTOM_REOLUTION == -1:
-            set_resolution = "Best"
-        else:
-            set_resolution = f"{FILTER_CUSTOM_REOLUTION}p"
-
         tuple_available_resolution = self.parser._video.get_list_resolution()
         list_available_resolution = [f"{r[0]}x{r[1]}" for r in tuple_available_resolution]
 
         console.print(
             f"[cyan bold]Video    →[/cyan bold] [green]Available:[/green] [purple]{', '.join(list_available_resolution)}[/purple] | "
-            f"[red]Set:[/red] [purple]{set_resolution}[/purple] | "
+            f"[red]Set:[/red] [purple]{FILTER_CUSTOM_REOLUTION}[/purple] | "
             f"[yellow]Downloadable:[/yellow] [purple]{self.video_res[0]}x{self.video_res[1]}[/purple]"
         )
 
@@ -264,13 +260,14 @@ class DownloadManager:
 
         if result.get('stopped', False):
             self.stopped = True
+        
         return self.stopped
 
     def download_audio(self, audio: Dict):
         """Downloads audio segments for a specific language track."""
-        if self.stopped:
-            return True
-        
+        #if self.stopped:
+        #    return True
+
         audio_full_url = self.url_fixer.generate_full_url(audio['uri'])
         audio_tmp_dir = os.path.join(self.temp_dir, 'audio', audio['language'])
 
@@ -284,14 +281,20 @@ class DownloadManager:
 
     def download_subtitle(self, sub: Dict):
         """Downloads and saves subtitle file for a specific language."""
-        if self.stopped:
-            return True
-        
-        content = self.client.request(sub['uri'])
-        if content:
+        #if self.stopped:
+        #    return True
+
+        raw_content = self.client.request(sub['uri'])
+        if raw_content:
             sub_path = os.path.join(self.temp_dir, 'subs', f"{sub['language']}.vtt")
-            with open(sub_path, 'w', encoding='utf-8') as f:
-                f.write(content)
+
+            subtitle_parser = M3U8_Parser()
+            subtitle_parser.parse_data(sub['uri'], raw_content)
+
+            with open(sub_path, 'wb') as f:
+                vtt_url = subtitle_parser.subtitle[-1]
+                vtt_content = self.client.request(vtt_url, True)
+                f.write(vtt_content)
 
         return self.stopped
 
@@ -299,30 +302,35 @@ class DownloadManager:
         """
         Downloads all selected streams (video, audio, subtitles).
         """
+        return_stopped = False
+
         video_file = os.path.join(self.temp_dir, 'video', '0.ts')
         if not os.path.exists(video_file):
             if self.download_video(video_url):
-                return True
-        
+                if not return_stopped:
+                    return_stopped = True
+
         for audio in audio_streams:
-            if self.stopped:
-                break
+            #if self.stopped:
+            #    break
 
             audio_file = os.path.join(self.temp_dir, 'audio', audio['language'], '0.ts')
             if not os.path.exists(audio_file):
                 if self.download_audio(audio):
-                    return True
+                    if not return_stopped:
+                        return_stopped = True
 
         for sub in sub_streams:
-            if self.stopped:
-                break
+            #if self.stopped:
+            #    break
 
             sub_file = os.path.join(self.temp_dir, 'subs', f"{sub['language']}.vtt")
             if not os.path.exists(sub_file):
                 if self.download_subtitle(sub):
-                    return True
-        
-        return self.stopped
+                    if not return_stopped:
+                        return_stopped = True
+
+        return return_stopped
 
 
 class MergeManager:
@@ -344,7 +352,7 @@ class MergeManager:
         """
         Merges downloaded streams into final video file.
         Returns path to the final merged file.
-        
+
         Process:
         1. If no audio/subs, just process video
         2. If audio exists, merge with video
@@ -387,7 +395,7 @@ class MergeManager:
                     subtitles_list=sub_tracks,
                     out_path=merged_subs_path
                 )
-                
+
         return merged_file
 
 
@@ -404,14 +412,16 @@ class HLS_Downloader:
     def start(self) -> Dict[str, Any]:
         """
         Main execution flow with handling for both index and playlist M3U8s.
-        
+
         Returns:
             Dict containing:
                 - path: Output file path
                 - url: Original M3U8 URL
                 - is_master: Whether the M3U8 was a master playlist
             Or raises an exception if there's an error
-        """       
+        """
+        console.print(f"[cyan]You can safely stop the download with [bold]Ctrl+c[bold] [cyan] \n")
+        
         if TELEGRAM_BOT:
             bot = get_bot_instance()
 
@@ -421,12 +431,12 @@ class HLS_Downloader:
                 response = {
                     'path': self.path_manager.output_path,
                     'url': self.m3u8_url,
-                    'is_master': False, 
+                    'is_master': False,
                     'error': 'File already exists',
                     'stopped': False
                 }
                 if TELEGRAM_BOT:
-                    bot.send_message(response)
+                    bot.send_message(f"Contenuto già scaricato!", None)
                 return response
 
             self.path_manager.setup_directories()
@@ -441,7 +451,7 @@ class HLS_Downloader:
                 client=self.client,
                 url_fixer=self.m3u8_manager.url_fixer
             )
-            
+
             # Check if download was stopped
             download_stopped = self.download_manager.download_all(
                 video_url=self.m3u8_manager.video_url,
@@ -449,15 +459,6 @@ class HLS_Downloader:
                 sub_streams=self.m3u8_manager.sub_streams
             )
 
-            if download_stopped:
-                return {
-                    'path': None,
-                    'url': self.m3u8_url,
-                    'is_master': self.m3u8_manager.is_master,
-                    'error': 'Download stopped by user',
-                    'stopped': True
-                }
-
             self.merge_manager = MergeManager(
                 temp_dir=self.path_manager.temp_dir,
                 parser=self.m3u8_manager.parser,
@@ -475,14 +476,14 @@ class HLS_Downloader:
                 'path': self.path_manager.output_path,
                 'url': self.m3u8_url,
                 'is_master': self.m3u8_manager.is_master,
-                'stopped': False
+                'stopped': download_stopped
             }
 
         except Exception as e:
             error_msg = str(e)
             console.print(f"[red]Download failed: {error_msg}[/red]")
             logging.error("Download error", exc_info=True)
-            
+
             return {
                 'path': None,
                 'url': self.m3u8_url,
@@ -490,7 +491,7 @@ class HLS_Downloader:
                 'error': error_msg,
                 'stopped': False
             }
-        
+
     def _print_summary(self):
         """Prints download summary including file size, duration, and any missing segments."""
         if TELEGRAM_BOT:
@@ -506,7 +507,6 @@ 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)
 
-        print()
         panel_content = (
             f"[cyan]File size: [bold red]{file_size}[/bold red]\n"
             f"[cyan]Duration: [bold]{duration}[/bold]\n"

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -47,6 +47,9 @@ PROXY_START_MAX = config_manager.get_float('REQUESTS', 'proxy_start_max')
 DEFAULT_VIDEO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_video_workser')
 DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_workser')
 MAX_TIMEOOUT = config_manager.get_int("REQUESTS", "timeout")
+MAX_INTERRUPT_COUNT = 3
+SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
+TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
 
 
 
@@ -82,12 +85,14 @@ class M3U8_Segments:
         # Stopping
         self.interrupt_flag = threading.Event()
         self.download_interrupted = False
+        self.interrupt_count = 0
+        self.force_stop = False
+        self.interrupt_lock = threading.Lock()
 
         # OTHER INFO
         self.info_maxRetry = 0
         self.info_nRetry = 0
         self.info_nFailed = 0
-
         self.active_retries = 0 
         self.active_retries_lock = threading.Lock()
 
@@ -156,12 +161,24 @@ class M3U8_Segments:
         Set up a signal handler for graceful interruption.
         """
         def interrupt_handler(signum, frame):
-            if not self.interrupt_flag.is_set():
-                console.log("\n[red] Stopping download gracefully...")
-                self.interrupt_flag.set()
-                self.download_interrupted = True
-                self.stop_event.set()
+            with self.interrupt_lock:
+                self.interrupt_count += 1
+                if self.interrupt_count >= MAX_INTERRUPT_COUNT:
+                    self.force_stop = True
+                    
+            if self.force_stop:
+                console.print("\n[red]Force stop triggered! Exiting immediately.")
+
+            else:
+                if not self.interrupt_flag.is_set():
+                    remaining = MAX_INTERRUPT_COUNT - self.interrupt_count
+                    console.print(f"\n[red]- Stopping gracefully... (Ctrl+C {remaining}x to force)")
+                    self.download_interrupted = True
+
+                    if remaining == 1:
+                        self.interrupt_flag.set()
 
+                    
         if threading.current_thread() is threading.main_thread():
             signal.signal(signal.SIGINT, interrupt_handler)
         else:
@@ -169,8 +186,9 @@ class M3U8_Segments:
 
     def _get_http_client(self, index: int = None):
         client_params = {
-            'headers': random_headers(self.key_base_url) if hasattr(self, 'key_base_url') else {'User-Agent': get_headers()},
-            'timeout': MAX_TIMEOOUT,
+            #'headers': random_headers(self.key_base_url) if hasattr(self, 'key_base_url') else {'User-Agent': get_headers()},
+            'headers': {'User-Agent': get_headers()},
+            'timeout': SEGMENT_MAX_TIMEOUT,
             'follow_redirects': True,
             'http2': False
         }
@@ -189,7 +207,7 @@ class M3U8_Segments:
             - index (int): The index of the segment.
             - progress_bar (tqdm): Progress counter for tracking download progress.
             - backoff_factor (float): The backoff factor for exponential backoff (default is 1.5 seconds).
-        """       
+        """
         for attempt in range(REQUEST_MAX_RETRY):
             if self.interrupt_flag.is_set():
                 return
@@ -291,6 +309,8 @@ class M3U8_Segments:
 
                 except queue.Empty:
                     self.current_timeout = min(MAX_TIMEOOUT, self.current_timeout * 1.1)
+                    time.sleep(0.05)
+
                     if self.stop_event.is_set():
                         break
 
@@ -305,6 +325,11 @@ class M3U8_Segments:
             - description: Description to insert on tqdm bar
             - type (str): Type of download: 'video' or 'audio'
         """
+        if TELEGRAM_BOT:
+
+          # Viene usato per lo screen 
+          console.log("####")
+          
         self.get_info()
         self.setup_interrupt_handler()
 
@@ -313,7 +338,9 @@ class M3U8_Segments:
             unit='s',
             ascii='░▒█',
             bar_format=self._get_bar_format(description),
-            mininterval=0.05
+            mininterval=0.6,
+            maxinterval=1.0,
+            file=sys.stdout,        # Using file=sys.stdout to force in-place updates because sys.stderr may not support carriage returns in this environment.
         )
 
         try:
@@ -382,7 +409,6 @@ class M3U8_Segments:
             return (
                 f"{Colors.YELLOW}Proc{Colors.WHITE}: "
                 f"{Colors.RED}{{percentage:.2f}}% "
-                f"{Colors.WHITE}| "
                 f"{Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
             )
             
@@ -391,8 +417,7 @@ class M3U8_Segments:
                 f"{Colors.YELLOW}[HLS] {Colors.WHITE}({Colors.CYAN}{description}{Colors.WHITE}): "
                 f"{Colors.RED}{{percentage:.2f}}% "
                 f"{Colors.MAGENTA}{{bar}} "
-                f"{Colors.WHITE}[ {Colors.YELLOW}{{n_fmt}}{Colors.WHITE} / {Colors.RED}{{total_fmt}} {Colors.WHITE}] "
-                f"{Colors.YELLOW}{{elapsed}} {Colors.WHITE}< {Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
+                f"{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.WHITE}{{postfix}}{Colors.WHITE}"
             )
     
     def _get_worker_count(self, stream_type: str) -> int:
@@ -429,8 +454,8 @@ class M3U8_Segments:
         writer_thread.join(timeout=30)
         progress_bar.close()
         
-        if self.download_interrupted:
-            console.print("\n[red]Download terminated by user")
+        #if self.download_interrupted:
+        #    console.print("\n[red]Download terminated by user")
             
         if self.info_nFailed > 0:
             self._display_error_summary()