StreamingCommunity 1.9.8__py3-none-any.whl → 1.9.90__py3-none-any.whl

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -0,0 +1,155 @@
+# 09.06.24
+
+import os
+import sys
+import ssl
+import certifi
+import logging
+
+
+# External libraries
+import httpx
+from tqdm import tqdm
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.color import Colors
+from StreamingCommunity.Util.console import console, Panel
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.os import internet_manager
+
+
+# Logic class
+from ...FFmpeg import print_duration_table
+
+
+# Suppress SSL warnings
+import urllib3
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+
+# Config
+GET_ONLY_LINK = config_manager.get_bool('M3U8_PARSER', 'get_only_link')
+TQDM_USE_LARGE_BAR = config_manager.get_int('M3U8_DOWNLOAD', 'tqdm_use_large_bar')
+REQUEST_TIMEOUT = config_manager.get_float('REQUESTS', 'timeout')
+
+
+
+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.
+    """
+    # 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:
+            headers['User-Agent'] = get_headers()
+
+    except Exception as header_err:
+        logging.error(f"Error preparing headers: {header_err}")
+        console.print(f"[bold red]Error preparing headers: {header_err}[/bold red]")
+        return None
+
+    try:
+        # Create a custom transport that bypasses SSL verification
+        transport = httpx.HTTPTransport(
+            verify=False,  # Disable SSL certificate verification
+            http2=True     # Optional: enable HTTP/2 support
+        )
+        
+        # Download with streaming and progress tracking
+        with httpx.Client(transport=transport, timeout=httpx.Timeout(60.0)) as client:
+            with client.stream("GET", url, headers=headers, timeout=REQUEST_TIMEOUT) as response:
+                response.raise_for_status()
+                
+                # Get total file size
+                total = int(response.headers.get('content-length', 0))
+                
+                # Handle empty streams
+                if total == 0:
+                    console.print("[bold red]No video stream found.[/bold red]")
+                    return None
+
+                # Create progress bar
+                progress_bar = tqdm(
+                    total=total,
+                    ascii='░▒█',
+                    bar_format=f"{Colors.YELLOW}[MP4] {Colors.WHITE}({Colors.CYAN}video{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}]",
+                    unit='iB',
+                    unit_scale=True,
+                    desc='Downloading',
+                    mininterval=0.05
+                )
+
+                # Ensure directory exists
+                os.makedirs(os.path.dirname(path), exist_ok=True)
+
+                # Download file
+                with open(path, 'wb') as file, progress_bar as bar:
+                    downloaded = 0
+                    for chunk in response.iter_bytes(chunk_size=1024):
+                        if chunk:
+                            size = file.write(chunk)
+                            downloaded += size
+                            bar.update(size)
+
+                            # Optional: Add a check to stop download if needed
+                            # if downloaded > MAX_DOWNLOAD_SIZE:
+                            #     break
+
+        # Post-download processing
+        if os.path.exists(path) and os.path.getsize(path) > 0:
+            console.print(Panel(
+                f"[bold green]Download completed![/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', ''))}", 
+                border_style="green"
+            ))
+            return path
+        
+        else:
+            console.print("[bold red]Download failed or file is empty.[/bold red]")
+            return None
+
+    except httpx.HTTPStatusError as http_err:
+        logging.error(f"HTTP error occurred: {http_err}")
+        console.print(f"[bold red]HTTP Error: {http_err}[/bold red]")
+        return None
+    
+    except httpx.RequestError as req_err:
+        logging.error(f"Request error: {req_err}")
+        console.print(f"[bold red]Request Error: {req_err}[/bold red]")
+        return None
+    
+    except Exception as e:
+        logging.error(f"Unexpected error during download: {e}")
+        console.print(f"[bold red]Unexpected Error: {e}[/bold red]")
+        return None

StreamingCommunity/Lib/Downloader/TOR/downloader.py

@@ -0,0 +1,296 @@
+# 23.06.24
+
+import os
+import re
+import sys
+import time
+import shutil
+import psutil
+import logging
+
+
+# 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
+
+
+# External libraries
+from tqdm import tqdm
+from qbittorrent import Client
+
+
+# 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'])
+
+# Config
+TQDM_USE_LARGE_BAR = config_manager.get_int('M3U8_DOWNLOAD', 'tqdm_use_large_bar')
+REQUEST_TIMEOUT = config_manager.get_float('REQUESTS', 'timeout')
+
+
+
+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.
+        """
+        try:
+            console.print(f"[cyan]Connect to: [green]{HOST}:{PORT}")
+            self.qb = Client(f'http://{HOST}:{PORT}/')
+        except: 
+            logging.error("Start qbitorrent first.")
+            sys.exit(0)
+        
+        self.username = USERNAME
+        self.password = PASSWORD
+        self.latest_torrent_hash = None
+        self.output_file = None
+        self.file_name = None
+
+        self.login()
+
+    def login(self):
+        """
+        Logs into the qBittorrent Web UI.
+        """
+        try:
+            self.qb.login(self.username, self.password)
+            self.logged_in = True
+            logging.info("Successfully logged in to qBittorrent.")
+
+        except Exception as e:
+            logging.error(f"Failed to log in: {str(e)}")
+            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]")
+            
+            try:
+                # Rimuovi il torrent
+                self.qb.delete_permanently(torrent_info['hash'])
+
+            except Exception as delete_error:
+                logging.error(f"Errore durante la rimozione del 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
+        
+        Returns:
+            dict: Informazioni del torrent aggiunto, o None se fallisce
+        """
+
+        # 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")
+        
+        magnet_hash = magnet_hash_match.group(1).lower()
+        
+        # Estrai il nome del file dal magnet link (se presente)
+        name_match = re.search(r'dn=([^&]+)', magnet_link)
+        torrent_name = name_match.group(1).replace('+', ' ') if name_match else "Nome non disponibile"
+        
+        # Salva il timestamp prima di aggiungere il 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)
+        
+        # Aspetta un attimo per essere sicuri che il torrent sia stato aggiunto
+        time.sleep(1)
+        
+        # Cerca il torrent
+        torrents = self.qb.torrents()
+        matching_torrents = [
+            t for t in torrents 
+            if (t['hash'].lower() == magnet_hash) or (t.get('added_on', 0) > before_add_time)
+        ]
+        
+        if not matching_torrents:
+            raise ValueError("Nessun torrent corrispondente trovato")
+        
+        # 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]Nome:[/yellow] {torrent_info.get('name', torrent_name)}")
+        console.print(f"[yellow]Hash:[/yellow] {torrent_info['hash']}")
+        console.print(f"[yellow]Dimensione:[/yellow] {internet_manager.format_file_size(torrent_info.get('size'))}")
+        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']
+
+        # Controlla che sia possibile il download
+        time.sleep(5)
+        self.delete_magnet(self.qb.get_torrent(self.latest_torrent_hash))
+        
+        return torrent_info
+
+    def start_download(self):
+        """
+        Starts downloading the latest added torrent and monitors progress.
+        """    
+        if self.latest_torrent_hash is not None:
+            try:
+            
+                # Custom bar for mobile and pc
+                if TQDM_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}[ "
+                        f"{Colors.YELLOW}{{elapsed}} {Colors.WHITE}< {Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
+                    )
+                else:
+                    bar_format = (
+                        f"{Colors.YELLOW}Proc{Colors.WHITE}: "
+                        f"{Colors.RED}{{percentage:.2f}}% {Colors.WHITE}| "
+                        f"{Colors.CYAN}{{remaining}}{{postfix}} {Colors.WHITE}]"
+                    )
+
+                progress_bar = tqdm(
+                    total=100,
+                    ascii='░▒█',
+                    bar_format=bar_format,
+                    unit_scale=True,
+                    unit_divisor=1024,
+                    mininterval=0.05
+                )
+
+                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']
+
+                        # 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
+                        pbar.n = progress
+
+                        download_speed = torrent_info['dl_speed']
+                        total_size = torrent_info['total_size']
+                        downloaded_size = torrent_info['total_downloaded']
+
+                        # Format variable
+                        downloaded_size_str = internet_manager.format_file_size(downloaded_size)
+                        downloaded_size = downloaded_size_str.split(' ')[0]
+
+                        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]
+
+                        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]
+
+                        # Update the progress bar's postfix
+                        if TQDM_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}"
+                            )
+                        else:
+                            pbar.set_postfix_str(
+                                f"{Colors.WHITE}[ {Colors.GREEN}{downloaded_size}{Colors.RED} {total_size} "
+                                f"{Colors.WHITE}| {Colors.CYAN}{average_internet} {Colors.RED}{average_internet_unit}"
+                            )
+                        
+                        pbar.refresh()
+                        time.sleep(0.2)
+
+                        # Break at the end
+                        if int(progress) == 100:
+                            break
+
+            except KeyboardInterrupt:
+                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."""
+        for proc in psutil.process_iter(['open_files']):
+            try:
+                if any(file_path == f.path for f in proc.info['open_files'] or []):
+                    return True
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                continue
+
+        return False
+
+    def move_downloaded_files(self, destination: str):
+        """
+        Moves downloaded files of the latest torrent to another location.
+
+        Parameters:
+            - destination (str): Destination directory to move files.
+
+        Returns:
+            - bool: True if files are moved successfully, False otherwise.
+        """
+        console.print(f"[cyan]Destination folder: [red]{destination}")
+        
+        try:
+
+            # Ensure the file is not in use
+            timeout = 3
+            elapsed = 0
+            while self.is_file_in_use(self.output_file) and elapsed < timeout:
+                time.sleep(1)
+                elapsed += 1
+            
+            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
+                    shutil.copy2(self.output_file, destination)
+                    os.remove(self.output_file)
+                else:
+                    raise
+
+            # Delete the torrent data
+            #self.qb.delete_permanently(self.qb.torrents()[-1]['hash'])
+            return True
+
+        except Exception as e:
+            print(f"Error moving file: {e}")
+            return False

StreamingCommunity/Lib/Downloader/__init__.py

@@ -0,0 +1,5 @@
+# 23.06.24
+
+from .HLS.downloader import HLS_Downloader
+from .MP4.downloader import MP4_downloader
+from .TOR.downloader import TOR_downloader

StreamingCommunity/Lib/FFmpeg/__init__.py

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

StreamingCommunity/Lib/FFmpeg/capture.py

@@ -0,0 +1,170 @@
+# 16.04.24
+
+import re
+import logging
+import threading
+import subprocess
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util.os import internet_manager
+
+
+# Variable
+terminate_flag = threading.Event()
+
+
+def capture_output(process: subprocess.Popen, description: str) -> None:
+    """
+    Function to capture and print output from a subprocess.
+
+    Parameters:
+        - process (subprocess.Popen): The subprocess whose output is captured.
+        - 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, ''):
+            try:
+                line = line.strip()
+                if not line:
+                    continue
+
+                logging.info(f"FFMPEG line: {line}")
+
+                # Capture only error
+                if "rror" in str(line):
+                    console.log(f"[red]FFMPEG: {str(line).strip()}")
+
+                # Check if termination is requested
+                if terminate_flag.is_set():
+                    break
+
+                if "size=" in line:
+                    try:
+
+                        # Parse the output line to extract relevant information
+                        data = parse_output_line(line)
+
+                        if 'q' in data:
+                            is_end = (float(data.get('q', -1.0)) == -1.0)
+                            size_key = 'Lsize' if is_end else 'size'
+                            byte_size = int(re.findall(r'\d+', data.get(size_key, '0'))[0]) * 1000
+                        else:
+                            byte_size = int(re.findall(r'\d+', data.get('size', '0'))[0]) * 1000
+
+
+                        # Construct the progress string with formatted output information
+                        progress_string = (f"[yellow][FFmpeg] [white][{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))
+
+                        # Print the progress string to the console, overwriting the previous line
+                        console.print(progress_string.ljust(max_length), end="\r")
+
+                    except Exception as e:
+                        logging.error(f"Error parsing output line: {line} - {e}")
+
+            except Exception as e:
+                logging.error(f"Error processing line from subprocess: {e}")
+
+    except Exception as e:
+        logging.error(f"Error in capture_output: {e}")
+
+    finally:
+        try:
+            terminate_process(process)
+        except Exception as e:
+            logging.error(f"Error terminating process: {e}")
+
+
+def parse_output_line(line: str) -> dict:
+    """
+    Function to parse the output line and extract relevant information.
+
+    Parameters:
+        - line (str): The output line to parse.
+
+    Returns:
+        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:
+            key_value = part.split('=')
+
+            if len(key_value) == 2:
+                key = key_value[0]
+                value = key_value[1]
+                data[key] = value
+
+        return data
+    
+    except Exception as e:
+        logging.error(f"Error parsing line: {line} - {e}")
+        return {}
+
+
+def terminate_process(process):
+    """
+    Function to terminate a subprocess if it's still running.
+
+    Parameters:
+        - process (subprocess.Popen): The subprocess to terminate.
+    """
+    try:
+        if process.poll() is None:  # Check if the process is still running
+            process.kill()
+    except Exception as e:
+        logging.error(f"Failed to terminate process: {e}")
+
+
+def capture_ffmpeg_real_time(ffmpeg_command: list, description: str) -> None:
+    """
+    Function to capture real-time output from ffmpeg process.
+
+    Parameters:
+        - 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
+    terminate_flag.clear()
+
+    try:
+
+        # Start the ffmpeg process with subprocess.Popen
+        process = subprocess.Popen(ffmpeg_command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
+
+        # Start a thread to capture and print output
+        output_thread = threading.Thread(target=capture_output, args=(process, description))
+        output_thread.start()
+
+        try:
+            # Wait for ffmpeg process to complete
+            process.wait()
+
+        except KeyboardInterrupt:
+            logging.error("Terminating ffmpeg process...")
+
+        except Exception as e:
+            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
+
+    except Exception as e:
+        logging.error(f"Failed to start ffmpeg process: {e}")