StreamingCommunity 2.5.7__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:

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,7 +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}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.WHITE}{{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:
@@ -428,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()

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)