StreamingCommunity 2.7.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

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}")

StreamingCommunity/Lib/FFmpeg/command.py

@@ -6,10 +6,13 @@ import subprocess
 from typing import List, Dict, Tuple, Optional
 
 
+# External library
+from rich.console import Console
+
+
 # Internal utilities
-from StreamingCommunity.Util._jsonConfig import config_manager
-from StreamingCommunity.Util.os import os_manager, os_summary, suppress_output
-from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util.config_json import config_manager, get_use_large_bar
+from StreamingCommunity.Util.os import os_manager, suppress_output, get_ffmpeg_path
 
 
 # Logic class
@@ -30,9 +33,7 @@ FFMPEG_DEFAULT_PRESET = config_manager.get("M3U8_CONVERSION", "default_preset")
 
 
 # Variable
-USE_LARGE_BAR = not ("android" in sys.platform or "ios" in sys.platform)
-FFMPEG_PATH = os_summary.ffmpeg_path
-
+console = Console()
 
 
 def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
@@ -45,7 +46,7 @@ def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
     """
     try:
         result = subprocess.run(
-            [FFMPEG_PATH, '-encoders'],
+            [get_ffmpeg_path(), '-encoders'],
             capture_output=True,
             text=True,
             check=True
@@ -99,7 +100,7 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
         - out_path (str): The path to save the output file.
         - codec (M3U8_Codec): The video codec to use. Defaults to 'copy'.
     """
-    ffmpeg_cmd = [FFMPEG_PATH]
+    ffmpeg_cmd = [get_ffmpeg_path()]
 
     # Enabled the use of gpu
     if USE_GPU:
@@ -156,7 +157,7 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
         subprocess.run(ffmpeg_cmd, check=True)
     else:
 
-        if USE_LARGE_BAR:
+        if get_use_large_bar():
             capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join video")
             print()
 
@@ -182,7 +183,7 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
     video_audio_same_duration = check_duration_v_a(video_path, audio_tracks[0].get('path'))
 
     # Start command with locate ffmpeg
-    ffmpeg_cmd = [FFMPEG_PATH]
+    ffmpeg_cmd = [get_ffmpeg_path()]
 
     # Enabled the use of gpu
     if USE_GPU:
@@ -252,7 +253,7 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
         subprocess.run(ffmpeg_cmd, check=True)
     else:
 
-        if USE_LARGE_BAR:
+        if get_use_large_bar():
             capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join audio")
             print()
 
@@ -275,7 +276,7 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
             Each dictionary should contain the 'path' key with the path to the subtitle file and the 'name' key with the name of the subtitle.
         - out_path (str): The path to save the output file.
     """
-    ffmpeg_cmd = [FFMPEG_PATH, "-i", video_path]
+    ffmpeg_cmd = [get_ffmpeg_path(), "-i", video_path]
 
     # Add subtitle input files first
     for subtitle in subtitles_list:
@@ -305,9 +306,9 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
     # Run join
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
-    else:
 
-        if USE_LARGE_BAR:
+    else:
+        if get_use_large_bar():
             capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join subtitle")
             print()
 

StreamingCommunity/Lib/FFmpeg/util.py

@@ -8,14 +8,16 @@ import logging
 from typing import Tuple
 
 
+# External library
+from rich.console import Console
+
+
 # Internal utilities
-from StreamingCommunity.Util.console import console
-from StreamingCommunity.Util.os import os_summary
+from StreamingCommunity.Util.os import get_ffprobe_path
 
 
 # Variable
-FFPROB_PATH = os_summary.ffprobe_path
-
+console = Console()
 
 
 def has_audio_stream(video_path: str) -> bool:
@@ -29,7 +31,7 @@ def has_audio_stream(video_path: str) -> bool:
         has_audio (bool): True if the input video has an audio stream, False otherwise.
     """
     try:
-        ffprobe_cmd = [FFPROB_PATH, '-v', 'error', '-print_format', 'json', '-select_streams', 'a', '-show_streams', video_path]
+        ffprobe_cmd = [get_ffprobe_path(), '-v', 'error', '-print_format', 'json', '-select_streams', 'a', '-show_streams', video_path]
         logging.info(f"FFmpeg command: {ffprobe_cmd}")
 
         with subprocess.Popen(ffprobe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) as proc:
@@ -57,7 +59,7 @@ def get_video_duration(file_path: str) -> float:
     """
 
     try:
-        ffprobe_cmd = [FFPROB_PATH, '-v', 'error', '-show_format', '-print_format', 'json', file_path]
+        ffprobe_cmd = [get_ffprobe_path(), '-v', 'error', '-show_format', '-print_format', 'json', file_path]
         logging.info(f"FFmpeg command: {ffprobe_cmd}")
 
         # Use a with statement to ensure the subprocess is cleaned up properly
@@ -83,37 +85,6 @@ def get_video_duration(file_path: str) -> float:
         sys.exit(0)
 
 
-def get_video_duration_s(filename):
-    """
-    Get the duration of a video file using ffprobe.
-
-    Parameters:
-        - filename (str): Path to the video file (e.g., 'sim.mp4')
-
-    Returns:
-        - duration (float): Duration of the video in seconds, or None if an error occurs.
-    """
-    ffprobe_cmd = ['ffprobe', '-v', 'error', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', filename]
-
-    try:
-        
-        # Run ffprobe command and capture output
-        result = subprocess.run(ffprobe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True, text=True)
-        
-        # Extract duration from the output
-        duration_str = result.stdout.strip()
-        duration = float(duration_str)  # Convert duration to float
-        
-        return int(duration)
-    
-    except subprocess.CalledProcessError as e:
-        print(f"Error running ffprobe: {e}")
-        return None
-    except ValueError as e:
-        print(f"Error converting duration to float: {e}")
-        return None
-
-
 def format_duration(seconds: float) -> Tuple[int, int, int]:
     """
     Format duration in seconds into hours, minutes, and seconds.
@@ -172,7 +143,7 @@ def get_ffprobe_info(file_path):
     """
     try:
         result = subprocess.run(
-            [FFPROB_PATH, '-v', 'error', '-show_format', '-show_streams', '-print_format', 'json', file_path],
+            [get_ffprobe_path(), '-v', 'error', '-show_format', '-show_streams', '-print_format', 'json', file_path],
             stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, check=True
         )
         output = result.stdout