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

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -1,16 +1,11 @@
 # 18.04.24
 
 import os
-import sys
 import time
-import queue
-import signal
 import logging
 import binascii
-import threading
-from queue import PriorityQueue
+import asyncio
 from urllib.parse import urljoin, urlparse
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import Dict, Optional
 
 
@@ -23,7 +18,7 @@ from rich.console import Console
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.headers import get_userAgent
-from StreamingCommunity.Util.http_client import create_client
+from StreamingCommunity.Util.http_client import create_client_curl
 from StreamingCommunity.Util.config_json import config_manager
 
 
@@ -35,16 +30,17 @@ from ...M3U8 import (
     M3U8_UrlFix
 )
 
+
 # Config
-TQDM_DELAY_WORKER = 0.01
 REQUEST_MAX_RETRY = config_manager.get_int('REQUESTS', 'max_retry')
 REQUEST_VERIFY = config_manager.get_bool('REQUESTS', 'verify')
 DEFAULT_VIDEO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_video_workers')
 DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_workers')
-MAX_TIMEOOUT = config_manager.get_int("REQUESTS", "timeout")
+MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
-TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
-MAX_INTERRUPT_COUNT = 3
+LIMIT_SEGMENT = config_manager.get_int('M3U8_DOWNLOAD', 'limit_segment')
+ENABLE_RETRY = config_manager.get_bool('M3U8_DOWNLOAD', 'enable_retry')
+
 
 # Variable
 console = Console()
@@ -58,78 +54,51 @@ class M3U8_Segments:
         Parameters:
             - 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.
+            - is_index_url (bool): Flag indicating if url is a URL (default True).
+            - limit_segments (int): Optional limit for number of segments (overrides LIMIT_SEGMENT if provided).
             - 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")
+        self.final_output_path = os.path.join(self.tmp_folder, "0.ts")
         os.makedirs(self.tmp_folder, exist_ok=True)
 
+        # Use LIMIT_SEGMENT from config if limit_segments not specified or is 0
+        if limit_segments is None or limit_segments == 0:
+            self.limit_segments = LIMIT_SEGMENT if LIMIT_SEGMENT > 0 else None
+        else:
+            self.limit_segments = limit_segments
+            
+        self.enable_retry = ENABLE_RETRY
+
         # Util class
         self.decryption: M3U8_Decryption = None 
         self.class_ts_estimator = M3U8_Ts_Estimator(0, self) 
         self.class_url_fixer = M3U8_UrlFix(url)
 
-        # Sync
-        self.queue = PriorityQueue(maxsize=20)
-        self.buffer = {}
-        self.expected_index = 0 
-        self.write_buffer = bytearray()  
-        self.write_batch_size = 50
-
-        self.stop_event = threading.Event()
+        # Stats
         self.downloaded_segments = set()
-        self.base_timeout = 1.0
-        self.current_timeout = 3.0
-
-        # Stopping
-        self.interrupt_flag = threading.Event()
         self.download_interrupted = False
-        self.interrupt_count = 0
-        self.force_stop = False
-        self.interrupt_lock = threading.Lock()
-
-        # HTTP Client
-        self._client = None
-        self._client_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()
 
+        # Progress throttling
         self._last_progress_update = 0
         self._progress_update_interval = 0.1
 
     def __get_key__(self, m3u8_parser: M3U8_Parser) -> bytes:
         """
         Fetches the encryption key from the M3U8 playlist.
-
-        Args:
-            m3u8_parser (M3U8_Parser): An instance of M3U8_Parser containing parsed M3U8 data.
-
-        Returns:
-            bytes: The decryption key in byte format.
         """
         key_uri = urljoin(self.url, m3u8_parser.keys.get('uri'))
         parsed_url = urlparse(key_uri)
         self.key_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}/"
         
         try:
-            client_params = {
-                'headers': self.custom_headers, 
-                'timeout': MAX_TIMEOOUT, 
-                'verify': REQUEST_VERIFY
-            }
-            response = httpx.get(url=key_uri, **client_params)
+            response = create_client_curl(headers=self.custom_headers).get(key_uri)
             response.raise_for_status()
 
             hex_content = binascii.hexlify(response.content).decode('utf-8')
@@ -139,12 +108,7 @@ class M3U8_Segments:
             raise Exception(f"Failed to fetch key: {e}")
     
     def parse_data(self, m3u8_content: str) -> None:
-        """
-        Parses the M3U8 content and extracts necessary data.
-
-        Args:
-            m3u8_content (str): The raw M3U8 playlist content.
-        """
+        """Parses the M3U8 content and extracts necessary data."""
         m3u8_parser = M3U8_Parser()
         m3u8_parser.parse_data(uri=self.url, raw_content=m3u8_content)
 
@@ -157,11 +121,11 @@ class M3U8_Segments:
             self.decryption = M3U8_Decryption(key, m3u8_parser.keys.get('iv'), m3u8_parser.keys.get('method'))
 
         segments = [
-            self.class_url_fixer.generate_full_url(seg)
-            if "http" not in seg else seg
+            self.class_url_fixer.generate_full_url(seg) if "http" not in seg else seg
             for seg in m3u8_parser.segments
         ]
         
+        # Apply segment limit
         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]
@@ -181,12 +145,7 @@ class M3U8_Segments:
         """
         if self.is_index_url:
             try:
-                client_params = {
-                    'headers': self.custom_headers, 
-                    'timeout': MAX_TIMEOOUT, 
-                    'verify': REQUEST_VERIFY
-                }
-                response = httpx.get(self.url, **client_params, follow_redirects=True)
+                response = create_client_curl(headers=self.custom_headers).get(self.url)
                 response.raise_for_status()
                 
                 self.parse_data(response.text)
@@ -195,205 +154,29 @@ class M3U8_Segments:
                     
             except Exception as e:
                 raise RuntimeError(f"M3U8 info retrieval failed: {e}")
-    
-    def setup_interrupt_handler(self):
-        """
-        Set up a signal handler for graceful interruption.
-        """
-        def interrupt_handler(signum, frame):
-            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.")
-                self._cleanup_client()
-
-            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:
-            print("Signal handler must be set in the main thread")
-
-    def _get_http_client(self):
-        """
-        Get a reusable HTTP client using the centralized factory.
-        Uses optimized settings for segment downloading with custom headers.
+    def _throttled_progress_update(self, content_size: int, progress_bar: tqdm):
         """
-        if self._client is None:
-            with self._client_lock:
-                self._client = create_client(
-                    headers=self.custom_headers,
-                    timeout=SEGMENT_MAX_TIMEOUT
-                )
-                
-        return self._client
-    
-    def _cleanup_client(self):
-        """Pulizia client"""
-        if self._client:
-            try:
-                self._client.close()
-            except Exception:
-                pass
-            self._client = None
-                            
-    def download_segment(self, ts_url: str, index: int, progress_bar: tqdm, backoff_factor: float = 1.02) -> None:
+        Throttled progress update to reduce CPU usage.
         """
-        Downloads a TS segment
-
-        Parameters:
-            - ts_url (str): The URL of the TS segment.
-            - index (int): The index of the segment.
-            - progress_bar (tqdm): Progress counter for tracking download progress.
-            - backoff_factor (float): Backoff factor.
-        """
-        for attempt in range(REQUEST_MAX_RETRY):
-            if self.interrupt_flag.is_set():
-                return
-            
-            try:
-                client = self._get_http_client()
-                timeout = min(SEGMENT_MAX_TIMEOUT, 10 + attempt * 5)
-
-                # 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)
-
-                # Decrypt if needed
-                if self.decryption is not None:
-                    try:
-                        segment_content = self.decryption.decrypt(segment_content)
-                    except Exception as e:
-                        logging.error(f"Decryption failed for segment {index}: {str(e)}")
-
-                        if attempt + 1 == REQUEST_MAX_RETRY:
-                            self.interrupt_flag.set()
-                            self.stop_event.set()
-
-                        raise e
-
-                current_time = time.time()
-                if current_time - self._last_progress_update > self._progress_update_interval:
-                    self.class_ts_estimator.update_progress_bar(content_size, progress_bar)
-                    self._last_progress_update = current_time
-                
-                try:
-                    self.queue.put((index, segment_content), timeout=0.05)
-                    self.downloaded_segments.add(index)  
-                    progress_bar.update(1)
-                    return
-                
-                except queue.Full:
-                    time.sleep(0.02)
-
-                    try:
-                        self.queue.put((index, segment_content), timeout=0.1)
-                        self.downloaded_segments.add(index)  
-                        progress_bar.update(1)
-                        return
-                    
-                    except queue.Full:
-                        self.queue.put((index, segment_content))
-                        self.downloaded_segments.add(index)  
-                        progress_bar.update(1)
-                        return
-
-            except Exception:
-                
-                if attempt > self.info_maxRetry:
-                    self.info_maxRetry = attempt + 1
-                self.info_nRetry += 1
-
-                if attempt + 1 == REQUEST_MAX_RETRY:
-                    console.print(f" -- [red]Final retry failed for segment: {index}")
-                    
-                    try:
-                        self.queue.put((index, None), timeout=0.1)
-                    except queue.Full:
-                        time.sleep(0.02)
-                        self.queue.put((index, None))
-
-                    progress_bar.update(1)
-                    self.info_nFailed += 1
-                    return
-                
-                if attempt < 2:
-                    sleep_time = 0.5 + attempt * 0.5
-                else:
-                    sleep_time = min(3.0, backoff_factor ** attempt)
-                
-                time.sleep(sleep_time)
+        current_time = time.time()
+        if current_time - self._last_progress_update > self._progress_update_interval:
+            self.class_ts_estimator.update_progress_bar(content_size, progress_bar)
+            self._last_progress_update = current_time
 
-    def write_segments_to_file(self):
+    def _get_temp_segment_path(self, temp_dir: str, index: int) -> str:
         """
-        Writes segments to file with additional verification.
+        Get the file path for a temporary segment.
         """
-        with open(self.tmp_file_path, 'wb') as f:
-            while not self.stop_event.is_set() or not self.queue.empty():
-                if self.interrupt_flag.is_set():
-                    break
-                
-                try:
-                    index, segment_content = self.queue.get(timeout=self.current_timeout)
-
-                    # Successful queue retrieval: reduce timeout
-                    self.current_timeout = max(self.base_timeout, self.current_timeout / 2)
-
-                    # Handle failed segments
-                    if segment_content is None:
-                        if index == self.expected_index:
-                            self.expected_index += 1
-                        continue
-
-                    # Write segment if it's the next expected one
-                    if index == self.expected_index:
-                        f.write(segment_content)
-                        f.flush()
-                        self.expected_index += 1
-
-                        # Write any buffered segments that are now in order
-                        while self.expected_index in self.buffer:
-                            next_segment = self.buffer.pop(self.expected_index)
-
-                            if next_segment is not None:
-                                f.write(next_segment)
-                                f.flush()
+        return os.path.join(temp_dir, f"seg_{index:06d}.ts")
 
-                            self.expected_index += 1
-                    
-                    else:
-                        self.buffer[index] = segment_content
-
-                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
-
-                except Exception as e:
-                    logging.error(f"Error writing segment {index}: {str(e)}")
-    
-    def download_init_segment(self) -> bool:
+    async def _download_init_segment(self, client: httpx.AsyncClient, output_path: str, progress_bar: tqdm) -> bool:
         """
-        Downloads the initialization segment if available.
-        
-        Returns:
-            bool: True if init segment was downloaded successfully, False otherwise
+        Downloads the initialization segment and writes to output file.
         """
         if not self.has_init_segment:
+            with open(output_path, 'wb') as f:
+                pass
             return False
             
         init_url = self.segment_init_url
@@ -401,139 +184,260 @@ class M3U8_Segments:
             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 = await 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)
+            # Decrypt if needed
             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)
+            # Write init segment to output file
+            with open(output_path, 'wb') as f:
+                f.write(init_content)
             
-            # Adjust expected_index to 1 since we've handled index 0 separately
-            self.expected_index = 0
+            progress_bar.update(1)
+            self._throttled_progress_update(len(init_content), progress_bar)
             logging.info("Init segment downloaded successfully")
             return True
             
         except Exception as e:
             logging.error(f"Failed to download init segment: {str(e)}")
+            with open(output_path, 'wb') as f:
+                pass
             return False
-    
-    def download_streams(self, description: str, type: str):
+
+    async def _download_single_segment(self, client: httpx.AsyncClient, ts_url: str, index: int, temp_dir: str,
+                                       semaphore: asyncio.Semaphore, max_retry: int) -> tuple:
+        """
+        Downloads a single TS segment and saves to temp file IMMEDIATELY.
+
+        Returns:
+            tuple: (index, success, retry_count, file_size)
+        """
+        async with semaphore:
+            temp_file = self._get_temp_segment_path(temp_dir, index)
+            
+            for attempt in range(max_retry):
+                if self.download_interrupted:
+                    return index, False, attempt, 0
+                
+                try:
+                    timeout = min(SEGMENT_MAX_TIMEOUT, 10 + attempt * 5)
+                    response = await client.get(ts_url, timeout=timeout, headers=self.custom_headers, follow_redirects=True)
+                    response.raise_for_status()
+                    segment_content = response.content
+
+                    # Decrypt if needed
+                    if self.decryption is not None:
+                        try:
+                            segment_content = self.decryption.decrypt(segment_content)
+                        except Exception as e:
+                            logging.error(f"Decryption failed for segment {index}: {str(e)}")
+                            if attempt + 1 == max_retry:
+                                return index, False, attempt, 0
+                            raise e
+
+                    # Write segment to temp file IMMEDIATELY
+                    with open(temp_file, 'wb') as f:
+                        f.write(segment_content)
+                    
+                    size = len(segment_content)
+                    del segment_content
+                    return index, True, attempt, size
+
+                except Exception:
+                    if attempt + 1 == max_retry:
+                        console.print(f" -- [red]Final retry failed for segment: {index}")
+                        return index, False, max_retry, 0
+                    
+                    sleep_time = 0.5 + attempt * 0.5 if attempt < 2 else min(3.0, 1.02 ** attempt)
+                    await asyncio.sleep(sleep_time)
+            
+            return index, False, max_retry, 0
+
+    async def _download_all_segments(self, client: httpx.AsyncClient, temp_dir: str, semaphore: asyncio.Semaphore, progress_bar: tqdm):
+        """
+        Download all segments in parallel with automatic retry.
+        """
+        
+        # First pass: download all segments
+        tasks = [
+            self._download_single_segment(client, url, i, temp_dir, semaphore, REQUEST_MAX_RETRY)
+            for i, url in enumerate(self.segments)
+        ]
+        
+        for coro in asyncio.as_completed(tasks):
+            try:
+                idx, success, nretry, size = await coro
+                
+                if success:
+                    self.downloaded_segments.add(idx)
+                else:
+                    self.info_nFailed += 1
+                
+                if nretry > self.info_maxRetry:
+                    self.info_maxRetry = nretry
+                self.info_nRetry += nretry
+                
+                progress_bar.update(1)
+                self._throttled_progress_update(size, progress_bar)
+                
+            except KeyboardInterrupt:
+                self.download_interrupted = True
+                console.print("\n[red]Download interrupted by user (Ctrl+C).")
+                break
+
+        # Retry failed segments only if enabled
+        if self.enable_retry and not self.download_interrupted:
+            await self._retry_failed_segments(client, temp_dir, semaphore, progress_bar)
+
+    async def _retry_failed_segments(self, client: httpx.AsyncClient, temp_dir: str, semaphore: asyncio.Semaphore, 
+                                     progress_bar: tqdm):
+        """
+        Retry failed segments up to 3 times.
+        """
+        max_global_retries = 3
+        global_retry_count = 0
+
+        while self.info_nFailed > 0 and global_retry_count < max_global_retries and not self.download_interrupted:
+            failed_indices = [i for i in range(len(self.segments)) if i not in self.downloaded_segments]
+            if not failed_indices:
+                break
+
+            console.print(f" -- [yellow]Retrying {len(failed_indices)} failed segments (attempt {global_retry_count+1}/{max_global_retries})...")
+            
+            retry_tasks = [
+                self._download_single_segment(client, self.segments[i], i, temp_dir, semaphore, REQUEST_MAX_RETRY)
+                for i in failed_indices
+            ]
+            
+            nFailed_this_round = 0
+            for coro in asyncio.as_completed(retry_tasks):
+                try:
+                    idx, success, nretry, size = await coro
+
+                    if success:
+                        self.downloaded_segments.add(idx)
+                    else:
+                        nFailed_this_round += 1
+
+                    if nretry > self.info_maxRetry:
+                        self.info_maxRetry = nretry
+                    self.info_nRetry += nretry
+                    
+                    progress_bar.update(0)
+                    self._throttled_progress_update(size, progress_bar)
+
+                except KeyboardInterrupt:
+                    self.download_interrupted = True
+                    console.print("\n[red]Download interrupted by user (Ctrl+C).")
+                    break
+                    
+            self.info_nFailed = nFailed_this_round
+            global_retry_count += 1
+
+    async def _concatenate_segments(self, output_path: str, temp_dir: str):
         """
-        Downloads all TS segments in parallel and writes them to a file.
+        Concatenate all segment files in order to the final output file.
+        """
+        with open(output_path, 'ab') as outfile:
+            for idx in range(len(self.segments)):
+                temp_file = self._get_temp_segment_path(temp_dir, idx)
+                
+                if os.path.exists(temp_file):
+                    with open(temp_file, 'rb') as infile:
+                        outfile.write(infile.read())
+                    os.remove(temp_file)
+
+    async def download_segments_async(self, description: str, type: str):
+        """
+        Downloads all TS segments asynchronously.
 
         Parameters:
             - description: Description to insert on tqdm bar
             - type (str): Type of download: 'video' or 'audio'
         """
-        if TELEGRAM_BOT:
-          console.log("####")
-          
         self.get_info()
-        self.setup_interrupt_handler()
 
+        # Setup directories
+        temp_dir = os.path.join(self.tmp_folder, "segments_temp")
+        os.makedirs(temp_dir, exist_ok=True)
+
+        # Initialize progress bar
+        total_segments = len(self.segments) + (1 if self.has_init_segment else 0)
         progress_bar = tqdm(
-            total=len(self.segments) + (1 if self.has_init_segment else 0), 
-            bar_format=self._get_bar_format(description),
-            file=sys.stdout,
+            total=total_segments,
+            bar_format=self._get_bar_format(description)
         )
 
+        # Reset stats
+        self.downloaded_segments = set()
+        self.info_nFailed = 0
+        self.info_nRetry = 0
+        self.info_maxRetry = 0
+        self.download_interrupted = False
+
         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)
+            # Configure HTTP client
+            timeout_config = httpx.Timeout(SEGMENT_MAX_TIMEOUT, connect=10.0)
+            limits = httpx.Limits(max_keepalive_connections=20, max_connections=100)
             
-            with ThreadPoolExecutor(max_workers=max_workers) as executor:
-                futures = []
+            async with httpx.AsyncClient(timeout=timeout_config, limits=limits, verify=REQUEST_VERIFY) as client:
                 
-                # Start segment indices from 1 if we have an init segment
-                start_idx = 1 if self.has_init_segment else 0
+                # Download init segment first (writes to 0.ts)
+                await self._download_init_segment(client, self.final_output_path, progress_bar)
                 
-                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, queue_index, progress_bar))
-
-                # Process completed futures
-                for future in as_completed(futures):
-                    if self.interrupt_flag.is_set():
-                        break
-                    try:
-                        future.result(timeout=1.0)
-                    except Exception as e:
-                        logging.error(f"Error in download thread: {str(e)}")
-
-                # Retry missing segments if necessary
-                if not self.interrupt_flag.is_set():
-                    total_segments = len(self.segments)
-                    completed_segments = len(self.downloaded_segments)
-                    
-                    if completed_segments < total_segments:
-                        missing_segments = set(range(total_segments)) - self.downloaded_segments
-                        logging.warning(f"Missing {len(missing_segments)} segments")
-
-                        # Retry missing segments with interrupt check
-                        retry_workers = min(2, len(missing_segments))
-                        if retry_workers > 0:
-                            retry_futures = []
-                            for index in missing_segments:
-                                if self.interrupt_flag.is_set():
-                                    break
-                                retry_futures.append(executor.submit(self.download_segment, self.segments[index], index, progress_bar))
-                            
-                            for future in as_completed(retry_futures):
-                                if self.interrupt_flag.is_set():
-                                    break
-                                try:
-                                    future.result(timeout=2.0)
-                                except Exception as e:
-                                    logging.error(f"Failed to retry segment: {str(e)}")
+                # Determine worker count based on type
+                max_workers = self._get_worker_count(type)
+                semaphore = asyncio.Semaphore(max_workers)
+                
+                # Update estimator
+                self.class_ts_estimator.total_segments = len(self.segments)
+                
+                # Download all segments to temp files
+                await self._download_all_segments(client, temp_dir, semaphore, progress_bar)
+                
+                # Concatenate all segments to 0.ts
+                if not self.download_interrupted:
+                    await self._concatenate_segments(self.final_output_path, temp_dir)
 
+        except KeyboardInterrupt:
+            self.download_interrupted = True
+            console.print("\n[red]Download interrupted by user (Ctrl+C).")
+            
         finally:
-            self._cleanup_resources(writer_thread, progress_bar)
+            self._cleanup_resources(temp_dir, progress_bar)
 
-        if not self.interrupt_flag.is_set():
+        if not self.download_interrupted:
             self._verify_download_completion()
 
         return self._generate_results(type)
-    
-    
-    def _get_bar_format(self, description: str) -> str:
+
+    def download_streams(self, description: str, type: str):
         """
-        Generate platform-appropriate progress bar format.
+        Synchronous wrapper for download_segments_async.
+
+        Parameters:
+            - description: Description to insert on tqdm bar
+            - type (str): Type of download: 'video' or 'audio'
         """
+        try:
+            return asyncio.run(self.download_segments_async(description, type))
+        
+        except KeyboardInterrupt:
+            self.download_interrupted = True
+            console.print("\n[red]Download interrupted by user (Ctrl+C).")
+            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.CYAN} {description}{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}] "
@@ -541,9 +445,7 @@ class M3U8_Segments:
         )
     
     def _get_worker_count(self, stream_type: str) -> int:
-        """
-        Return parallel workers based on stream type and infrastructure.
-        """
+        """Return parallel workers based on stream type."""
         return {
             'video': DEFAULT_VIDEO_WORKERS,
             'audio': DEFAULT_AUDIO_WORKERS
@@ -564,26 +466,25 @@ class M3U8_Segments:
             missing = sorted(set(range(total)) - self.downloaded_segments)
             raise RuntimeError(f"Download incomplete ({len(self.downloaded_segments)/total:.1%}). Missing segments: {missing}")
         
-    def _cleanup_resources(self, writer_thread: threading.Thread, progress_bar: tqdm) -> None:
+    def _cleanup_resources(self, temp_dir: str, progress_bar: tqdm) -> None:
         """Ensure resource cleanup and final reporting."""
-        self.stop_event.set()
-        writer_thread.join(timeout=30)
         progress_bar.close()
-        self._cleanup_client()
+        
+        # Delete temp directory if exists
+        if temp_dir and os.path.exists(temp_dir):
+            try:
+                # Remove any remaining files (in case of interruption)
+                for file in os.listdir(temp_dir):
+                    os.remove(os.path.join(temp_dir, file))
+                os.rmdir(temp_dir)
+            except Exception as e:
+                console.print(f"[yellow]Warning: Could not clean temp directory: {e}")
         
         if self.info_nFailed > 0:
             self._display_error_summary()
 
-        self.buffer = {}
-        self.write_buffer.clear()
-        self.expected_index = 0
-
     def _display_error_summary(self) -> None:
         """Generate final error report."""
-        console.print(f"\n[cyan]Retry Summary: "
-                     f"[white]Max retries: [green]{self.info_maxRetry} "
-                     f"[white]Total retries: [green]{self.info_nRetry} "
-                     f"[white]Failed segments: [red]{self.info_nFailed}")
-        
-        if self.info_nRetry > len(self.segments) * 0.3:
-            console.print("[yellow]Warning: High retry count detected. Consider reducing worker count in config.")
+        console.print(f" [cyan]Max retries: [red]{self.info_maxRetry} [white] | "
+            f"[cyan]Total retries: [red]{self.info_nRetry} [white] | "
+            f"[cyan]Failed segments: [red]{self.info_nFailed}")