StreamingCommunity 2.6.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -17,14 +17,13 @@ from typing import Dict
 # External libraries
 import httpx
 from tqdm import tqdm
+from rich.console import Console
 
 
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
-from StreamingCommunity.Util.console import console
-from StreamingCommunity.Util.headers import get_headers, random_headers
-from StreamingCommunity.Util._jsonConfig import config_manager
-from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.headers import get_userAgent
+from StreamingCommunity.Util.config_json import config_manager, get_use_large_bar
 
 
 # Logic class
@@ -34,16 +33,11 @@ from ...M3U8 import (
     M3U8_Parser,
     M3U8_UrlFix
 )
-from .proxyes import main_test_proxy
 
 # Config
 TQDM_DELAY_WORKER = config_manager.get_float('M3U8_DOWNLOAD', 'tqdm_delay')
-USE_LARGE_BAR = not ("android" in sys.platform or "ios" in sys.platform)
 REQUEST_MAX_RETRY = config_manager.get_int('REQUESTS', 'max_retry')
-REQUEST_VERIFY = False
-THERE_IS_PROXY_LIST = os_manager.check_file("list_proxy.txt")
-PROXY_START_MIN = config_manager.get_float('REQUESTS', 'proxy_start_min')
-PROXY_START_MAX = config_manager.get_float('REQUESTS', 'proxy_start_max')
+REQUEST_VERIFY = config_manager.get_int('REQUESTS', 'verify')
 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")
@@ -52,6 +46,9 @@ SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
 TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
 
 
+# Variable
+console = Console()
+
 
 class M3U8_Segments:
     def __init__(self, url: str, tmp_folder: str, is_index_url: bool = True):
@@ -102,7 +99,7 @@ class M3U8_Segments:
         self.key_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}/"
         
         try:
-            client_params = {'headers': {'User-Agent': get_headers()}, 'timeout': MAX_TIMEOOUT}
+            client_params = {'headers': {'User-Agent': get_userAgent()}, 'timeout': MAX_TIMEOOUT}
             response = httpx.get(url=key_uri, **client_params)
             response.raise_for_status()
 
@@ -133,19 +130,10 @@ class M3U8_Segments:
         ]
         self.class_ts_estimator.total_segments = len(self.segments)
 
-        # Proxy
-        if THERE_IS_PROXY_LIST:
-            console.log("[red]Start validation proxy.")
-            self.valid_proxy = main_test_proxy(self.segments[0])
-            console.log(f"[cyan]N. Valid ip: [red]{len(self.valid_proxy)}")
-
-            if len(self.valid_proxy) == 0:
-                sys.exit(0)
-
     def get_info(self) -> None:
         if self.is_index_url:
             try:
-                client_params = {'headers': {'User-Agent': get_headers()}, 'timeout': MAX_TIMEOOUT}
+                client_params = {'headers': {'User-Agent': get_userAgent()}, 'timeout': MAX_TIMEOOUT}
                 response = httpx.get(self.url, **client_params)
                 response.raise_for_status()
                 
@@ -184,18 +172,13 @@ class M3U8_Segments:
         else:
             print("Signal handler must be set in the main thread")
 
-    def _get_http_client(self, index: int = None):
+    def _get_http_client(self):
         client_params = {
-            #'headers': random_headers(self.key_base_url) if hasattr(self, 'key_base_url') else {'User-Agent': get_headers()},
-            'headers': {'User-Agent': get_headers()},
+            'headers': {'User-Agent': get_userAgent()},
             'timeout': SEGMENT_MAX_TIMEOUT,
             'follow_redirects': True,
             'http2': False
         }
-        
-        if THERE_IS_PROXY_LIST and index is not None and hasattr(self, 'valid_proxy'):
-            client_params['proxies'] = self.valid_proxy[index % len(self.valid_proxy)]
-        
         return httpx.Client(**client_params)
                             
     def download_segment(self, ts_url: str, index: int, progress_bar: tqdm, backoff_factor: float = 1.1) -> None:
@@ -213,7 +196,7 @@ class M3U8_Segments:
                 return
             
             try:
-                with self._get_http_client(index) as client:
+                with self._get_http_client() as client:
                     start_time = time.time()
                     response = client.get(ts_url)
         
@@ -350,7 +333,6 @@ class M3U8_Segments:
 
             # Configure workers and delay
             max_workers = self._get_worker_count(type)
-            delay = max(PROXY_START_MIN, min(PROXY_START_MAX, 1 / (len(self.valid_proxy) + 1))) if THERE_IS_PROXY_LIST else TQDM_DELAY_WORKER
             
             # Download segments with completion verification
             with ThreadPoolExecutor(max_workers=max_workers) as executor:
@@ -361,7 +343,7 @@ class M3U8_Segments:
                     if self.interrupt_flag.is_set():
                         break
 
-                    time.sleep(delay)
+                    time.sleep(TQDM_DELAY_WORKER)
                     futures.append(executor.submit(self.download_segment, segment_url, index, progress_bar))
 
                 # Wait for futures with interrupt handling
@@ -405,7 +387,7 @@ class M3U8_Segments:
         """
         Generate platform-appropriate progress bar format.
         """
-        if not USE_LARGE_BAR:
+        if not get_use_large_bar():
             return (
                 f"{Colors.YELLOW}Proc{Colors.WHITE}: "
                 f"{Colors.RED}{{percentage:.2f}}% "
@@ -429,8 +411,6 @@ class M3U8_Segments:
             'audio': DEFAULT_AUDIO_WORKERS
         }.get(stream_type.lower(), 1)
 
-        if THERE_IS_PROXY_LIST:
-            return min(len(self.valid_proxy), base_workers * 2)
         return base_workers
     
     def _generate_results(self, stream_type: str) -> Dict:

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -12,13 +12,15 @@ from functools import partial
 # External libraries
 import httpx
 from tqdm import tqdm
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.panel import Panel
 
 
 # Internal utilities
-from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.headers import get_userAgent
 from StreamingCommunity.Util.color import Colors
-from StreamingCommunity.Util.console import console, Panel
-from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.os import internet_manager
 from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
@@ -27,18 +29,17 @@ from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 from ...FFmpeg import print_duration_table
 
 
-# Suppress SSL warnings
-import urllib3
-urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-
-
 # Config
+REQUEST_VERIFY = config_manager.get_int('REQUESTS', 'verify')
 GET_ONLY_LINK = config_manager.get_bool('M3U8_PARSER', 'get_only_link')
 REQUEST_TIMEOUT = config_manager.get_float('REQUESTS', 'timeout')
-
 TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
 
 
+# Variable
+msg = Prompt()
+console = Console()
+
 
 class InterruptHandler:
     def __init__(self):
@@ -47,6 +48,7 @@ class InterruptHandler:
         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()
@@ -67,6 +69,7 @@ def signal_handler(signum, frame, interrupt_handler, original_handler):
         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 with enhanced interrupt handling.
@@ -99,7 +102,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
         if headers_:
             headers.update(headers_)
         else:
-            headers['User-Agent'] = get_headers()
+            headers['User-Agent'] = get_userAgent()
 
     except Exception as header_err:
         logging.error(f"Error preparing headers: {header_err}")
@@ -111,7 +114,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
     original_handler = signal.signal(signal.SIGINT, partial(signal_handler, interrupt_handler=interrupt_handler, original_handler=signal.getsignal(signal.SIGINT)))
 
     try:
-        transport = httpx.HTTPTransport(verify=False, http2=True)
+        transport = httpx.HTTPTransport(verify=REQUEST_VERIFY, http2=True)
         
         with httpx.Client(transport=transport, timeout=httpx.Timeout(60)) as client:
             with client.stream("GET", url, headers=headers, timeout=REQUEST_TIMEOUT) as response:

StreamingCommunity/Lib/Downloader/TOR/downloader.py

@@ -9,47 +9,55 @@ import psutil
 import logging
 
 
+# External library
+from rich.console import Console
+
+
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.os import internet_manager
-from StreamingCommunity.Util.console import console
-from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.config_json import config_manager, get_use_large_bar
 
 
 # External libraries
 from tqdm import tqdm
-from qbittorrent import Client
+import qbittorrentapi
 
 
 # Tor config
-HOST = str(config_manager.get_dict('DEFAULT', 'config_qbit_tor')['host'])
-PORT = str(config_manager.get_dict('DEFAULT', 'config_qbit_tor')['port'])
-USERNAME = str(config_manager.get_dict('DEFAULT', 'config_qbit_tor')['user'])
-PASSWORD = str(config_manager.get_dict('DEFAULT', 'config_qbit_tor')['pass'])
+HOST = config_manager.get_dict('QBIT_CONFIG', 'host')
+PORT = config_manager.get_dict('QBIT_CONFIG', 'port')
+USERNAME = config_manager.get_dict('QBIT_CONFIG', 'user')
+PASSWORD = config_manager.get_dict('QBIT_CONFIG', 'pass')
 
 
-# Config
-USE_LARGE_BAR = not ("android" in sys.platform or "ios" in sys.platform)
+# Variable
 REQUEST_TIMEOUT = config_manager.get_float('REQUESTS', 'timeout')
-
+console = Console()
 
 
 class TOR_downloader:
     def __init__(self):
         """
         Initializes the TorrentManager instance.
-
+        
         Parameters:
             - host (str): IP address or hostname of the qBittorrent Web UI.
-            - port (int): Port number of the qBittorrent Web UI.
-            - username (str): Username for logging into qBittorrent.
-            - password (str): Password for logging into qBittorrent.
+            - port (int): Port of the qBittorrent Web UI.
+            - username (str): Username for accessing qBittorrent.
+            - password (str): Password for accessing qBittorrent.
         """
         try:
             console.print(f"[cyan]Connect to: [green]{HOST}:{PORT}")
-            self.qb = Client(f'http://{HOST}:{PORT}/')
-        except: 
-            logging.error("Start qbitorrent first.")
+            self.qb = qbittorrentapi.Client(
+                host=HOST,
+                port=PORT,
+                username=USERNAME,
+                password=PASSWORD
+            )
+
+        except:
+            logging.error("Start qbittorrent first.")
             sys.exit(0)
         
         self.username = USERNAME
@@ -65,7 +73,7 @@ class TOR_downloader:
         Logs into the qBittorrent Web UI.
         """
         try:
-            self.qb.login(self.username, self.password)
+            self.qb.auth_log_in()
             self.logged_in = True
             logging.info("Successfully logged in to qBittorrent.")
 
@@ -74,96 +82,87 @@ class TOR_downloader:
             self.logged_in = False
 
     def delete_magnet(self, torrent_info):
-
-        if (int(torrent_info.get('dl_speed')) == 0 and 
-            int(torrent_info.get('peers')) == 0 and 
-            int(torrent_info.get('seeds')) == 0):
-            
-            # Elimina il torrent appena aggiunto
-            console.print(f"[bold red]⚠️ Torrent non scaricabile. Rimozione in corso...[/bold red]")
+        """
+        Deletes a torrent if it is not downloadable (no seeds/peers).
+        
+        Parameters:
+            - torrent_info: Object containing torrent information obtained from the qBittorrent API.
+        """
+        if (int(torrent_info.dlspeed) == 0 and 
+            int(torrent_info.num_leechs) == 0 and 
+            int(torrent_info.num_seeds) == 0):
             
+            console.print(f"[bold red]Torrent not downloadable. Removing...[/bold red]")
             try:
-                # Rimuovi il torrent
-                self.qb.delete_permanently(torrent_info['hash'])
-
+                self.qb.torrents_delete(delete_files=True, torrent_hashes=torrent_info.hash)
             except Exception as delete_error:
-                logging.error(f"Errore durante la rimozione del torrent: {delete_error}")
+                logging.error(f"Error while removing torrent: {delete_error}")
             
-            # Resetta l'ultimo hash
             self.latest_torrent_hash = None
 
     def add_magnet_link(self, magnet_link):
         """
-        Aggiunge un magnet link e recupera le informazioni dettagliate.
-
-        Args:
-            magnet_link (str): Magnet link da aggiungere
+        Adds a magnet link and retrieves detailed torrent information.
+        
+        Arguments:
+            magnet_link (str): Magnet link to add.
         
         Returns:
-            dict: Informazioni del torrent aggiunto, o None se fallisce
+            dict: Information about the added torrent, or None in case of error.
         """
-
-        # Estrai l'hash dal magnet link
         magnet_hash_match = re.search(r'urn:btih:([0-9a-fA-F]+)', magnet_link)
-        
         if not magnet_hash_match:
-            raise ValueError("Hash del magnet link non trovato")
+            raise ValueError("Magnet link hash not found")
         
         magnet_hash = magnet_hash_match.group(1).lower()
         
-        # Estrai il nome del file dal magnet link (se presente)
+        # Extract the torrent name, if available
         name_match = re.search(r'dn=([^&]+)', magnet_link)
-        torrent_name = name_match.group(1).replace('+', ' ') if name_match else "Nome non disponibile"
+        torrent_name = name_match.group(1).replace('+', ' ') if name_match else "Name not available"
         
-        # Salva il timestamp prima di aggiungere il torrent
+        # Save the timestamp before adding the torrent
         before_add_time = time.time()
         
-        # Aggiungi il magnet link
-        console.print(f"[cyan]Aggiunta magnet link[/cyan]: [red]{magnet_link}")
-        self.qb.download_from_link(magnet_link)
+        console.print(f"[cyan]Adding magnet link ...")
+        self.qb.torrents_add(urls=magnet_link)
         
-        # Aspetta un attimo per essere sicuri che il torrent sia stato aggiunto
         time.sleep(1)
         
-        # Cerca il torrent
-        torrents = self.qb.torrents()
+        torrents = self.qb.torrents_info()
         matching_torrents = [
             t for t in torrents 
-            if (t['hash'].lower() == magnet_hash) or (t.get('added_on', 0) > before_add_time)
+            if (t.hash.lower() == magnet_hash) or (getattr(t, 'added_on', 0) > before_add_time)
         ]
         
         if not matching_torrents:
-            raise ValueError("Nessun torrent corrispondente trovato")
+            raise ValueError("No matching torrent found")
         
-        # Prendi il primo torrent corrispondente
         torrent_info = matching_torrents[0]
         
-        # Formatta e stampa le informazioni
-        console.print("\n[bold green]🔗 Dettagli Torrent Aggiunto:[/bold green]")
-        console.print(f"[yellow]Name:[/yellow] {torrent_info.get('name', torrent_name)}")
-        console.print(f"[yellow]Hash:[/yellow] {torrent_info['hash']}")
+        console.print("\n[bold green]Added Torrent Details:[/bold green]")
+        console.print(f"[yellow]Name:[/yellow] {torrent_info.name or torrent_name}")
+        console.print(f"[yellow]Hash:[/yellow] {torrent_info.hash}")
         print()
 
-        # Salva l'hash per usi successivi e il path
-        self.latest_torrent_hash = torrent_info['hash']
-        self.output_file = torrent_info['content_path']
-        self.file_name = torrent_info['name']
+        self.latest_torrent_hash = torrent_info.hash
+        self.output_file = torrent_info.content_path
+        self.file_name = torrent_info.name
 
-        # Controlla che sia possibile il download
+        # Wait and verify if the download is possible
         time.sleep(5)
-        self.delete_magnet(self.qb.get_torrent(self.latest_torrent_hash))
+        self.delete_magnet(self.qb.torrents_info(torrent_hashes=self.latest_torrent_hash)[0])
         
         return torrent_info
 
     def start_download(self):
         """
-        Starts downloading the latest added torrent and monitors progress.
-        """    
+        Starts downloading the added torrent and monitors its progress.
+        """
         if self.latest_torrent_hash is not None:
             try:
-            
-                # Custom bar for mobile and pc
-                if USE_LARGE_BAR:
+
+                # Custom progress bar for mobile and PC
+                if get_use_large_bar():
                     bar_format = (
                         f"{Colors.YELLOW}[TOR] {Colors.WHITE}({Colors.CYAN}video{Colors.WHITE}): "
                         f"{Colors.RED}{{percentage:.2f}}% {Colors.MAGENTA}{{bar}} {Colors.WHITE}[ "
@@ -189,35 +188,42 @@ class TOR_downloader:
                 with progress_bar as pbar:
                     while True:
 
-                        # Get variable from qtorrent
-                        torrent_info = self.qb.get_torrent(self.latest_torrent_hash)
-                        self.save_path = torrent_info['save_path']
-                        self.torrent_name = torrent_info['name']
+                        torrent_info = self.qb.torrents_info(torrent_hashes=self.latest_torrent_hash)[0]
+                        self.save_path = torrent_info.save_path
+                        self.torrent_name = torrent_info.name
 
-                        # Fetch important variable
-                        pieces_have = torrent_info['pieces_have']
-                        pieces_num = torrent_info['pieces_num']
-                        progress = (pieces_have / pieces_num) * 100 if pieces_num else 0
+                        progress = torrent_info.progress * 100
                         pbar.n = progress
 
-                        download_speed = torrent_info['dl_speed']
-                        total_size = torrent_info['total_size']
-                        downloaded_size = torrent_info['total_downloaded']
+                        download_speed = torrent_info.dlspeed
+                        total_size = torrent_info.size
+                        downloaded_size = torrent_info.downloaded
 
-                        # Format variable
+                        # Format the downloaded size
                         downloaded_size_str = internet_manager.format_file_size(downloaded_size)
                         downloaded_size = downloaded_size_str.split(' ')[0]
 
+                        # Safely format the total size
                         total_size_str = internet_manager.format_file_size(total_size)
-                        total_size = total_size_str.split(' ')[0]
-                        total_size_unit = total_size_str.split(' ')[1]
+                        total_size_parts = total_size_str.split(' ')
+                        if len(total_size_parts) >= 2:
+                            total_size = total_size_parts[0]
+                            total_size_unit = total_size_parts[1]
+                        else:
+                            total_size = total_size_str
+                            total_size_unit = ""
 
+                        # Safely format the average download speed
                         average_internet_str = internet_manager.format_transfer_speed(download_speed)
-                        average_internet = average_internet_str.split(' ')[0]
-                        average_internet_unit = average_internet_str.split(' ')[1]
+                        average_internet_parts = average_internet_str.split(' ')
+                        if len(average_internet_parts) >= 2:
+                            average_internet = average_internet_parts[0]
+                            average_internet_unit = average_internet_parts[1]
+                        else:
+                            average_internet = average_internet_str
+                            average_internet_unit = ""
 
-                        # Update the progress bar's postfix
-                        if USE_LARGE_BAR:
+                        if get_use_large_bar():
                             pbar.set_postfix_str(
                                 f"{Colors.WHITE}[ {Colors.GREEN}{downloaded_size} {Colors.WHITE}< {Colors.GREEN}{total_size} {Colors.RED}{total_size_unit} "
                                 f"{Colors.WHITE}| {Colors.CYAN}{average_internet} {Colors.RED}{average_internet_unit}"
@@ -231,7 +237,6 @@ class TOR_downloader:
                         pbar.refresh()
                         time.sleep(0.2)
 
-                        # Break at the end
                         if int(progress) == 100:
                             break
 
@@ -239,7 +244,15 @@ class TOR_downloader:
                 logging.info("Download process interrupted.")
 
     def is_file_in_use(self, file_path: str) -> bool:
-        """Check if a file is in use by any process."""
+        """
+        Checks if a file is being used by any process.
+        
+        Parameters:
+            - file_path (str): The file path to check.
+            
+        Returns:
+            - bool: True if the file is in use, False otherwise.
+        """
         for proc in psutil.process_iter(['open_files']):
             try:
                 if any(file_path == f.path for f in proc.info['open_files'] or []):
@@ -251,21 +264,20 @@ class TOR_downloader:
 
     def move_downloaded_files(self, destination: str):
         """
-        Moves downloaded files of the latest torrent to another location.
-
+        Moves the downloaded files of the most recent torrent to a new location.
+        
         Parameters:
-            - destination (str): Destination directory to move files.
-
+            - destination (str): Destination folder.
+            
         Returns:
-            - bool: True if files are moved successfully, False otherwise.
+            - bool: True if the move was successful, False otherwise.
         """
         console.print(f"[cyan]Destination folder: [red]{destination}")
         
         try:
-
-            # Ensure the file is not in use
-            timeout = 3
+            timeout = 5
             elapsed = 0
+            
             while self.is_file_in_use(self.output_file) and elapsed < timeout:
                 time.sleep(1)
                 elapsed += 1
@@ -273,24 +285,20 @@ class TOR_downloader:
             if elapsed == timeout:
                 raise Exception(f"File '{self.output_file}' is in use and could not be moved.")
 
-            # Ensure destination directory exists
             os.makedirs(destination, exist_ok=True)
 
-            # Perform the move operation
             try:
                 shutil.move(self.output_file, destination)
-
             except OSError as e:
-                if e.errno == 17:  # Cross-disk move error
-                    # Perform copy and delete manually
+                if e.errno == 17:  # Error when moving between different disks
                     shutil.copy2(self.output_file, destination)
                     os.remove(self.output_file)
                 else:
                     raise
 
-            # Delete the torrent data
             time.sleep(5)
-            self.qb.delete_permanently(self.qb.torrents()[-1]['hash'])
+            last_torrent = self.qb.torrents_info()[-1]
+            self.qb.torrents_delete(delete_files=True, torrent_hashes=last_torrent.hash)
             return True
 
         except Exception as e:

StreamingCommunity/Lib/FFmpeg/__init__.py

@@ -1,4 +1,4 @@
 # 18.04.24
 
 from .command import join_video, join_audios, join_subtitle
-from .util import print_duration_table, get_video_duration
+from .util import print_duration_table, get_video_duration

StreamingCommunity/Lib/FFmpeg/capture.py

@@ -6,12 +6,16 @@ import threading
 import subprocess
 
 
+# External library
+from rich.console import Console
+
+
 # Internal utilities
-from StreamingCommunity.Util.console import console
 from StreamingCommunity.Util.os import internet_manager
 
 
 # Variable
+console = Console()
 terminate_flag = threading.Event()
 
 
@@ -24,8 +28,6 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
         - description (str): Description of the command being executed.
     """
     try:
-
-        # Variable to store the length of the longest progress string
         max_length = 0
 
         for line in iter(process.stdout.readline, ''):
@@ -59,7 +61,7 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
 
 
                         # Construct the progress string with formatted output information
-                        progress_string = (f"→ {description}[white]: "
+                        progress_string = (f" {description}[white]: "
                                            f"([green]'speed': [yellow]{data.get('speed', 'N/A')}[white], "
                                            f"[green]'size': [yellow]{internet_manager.format_file_size(byte_size)}[white])")
                         max_length = max(max_length, len(progress_string))
@@ -94,10 +96,7 @@ def parse_output_line(line: str) -> dict:
         dict: A dictionary containing parsed information.
     """
     try:
-
         data = {}
-
-        # Split the line by whitespace and extract key-value pairs
         parts = line.replace("  ", "").replace("= ", "=").split()
 
         for part in parts:
@@ -123,7 +122,7 @@ def terminate_process(process):
         - process (subprocess.Popen): The subprocess to terminate.
     """
     try:
-        if process.poll() is None:  # Check if the process is still running
+        if process.poll() is None:
             process.kill()
     except Exception as e:
         logging.error(f"Failed to terminate process: {e}")
@@ -137,7 +136,6 @@ def capture_ffmpeg_real_time(ffmpeg_command: list, description: str) -> None:
         - ffmpeg_command (list): The command to execute ffmpeg.
         - description (str): Description of the command being executed.
     """
-
     global terminate_flag
 
     # Clear the terminate_flag before starting a new capture
@@ -163,8 +161,8 @@ def capture_ffmpeg_real_time(ffmpeg_command: list, description: str) -> None:
             logging.error(f"Error in ffmpeg process: {e}")
             
         finally:
-            terminate_flag.set()  # Signal the output capture thread to terminate
-            output_thread.join()  # Wait for the output capture thread to complete
+            terminate_flag.set()
+            output_thread.join()
 
     except Exception as e:
-        logging.error(f"Failed to start ffmpeg process: {e}")
+        logging.error(f"Failed to start ffmpeg process: {e}")