StreamingCommunity 1.7.6__py3-none-any.whl

StreamingCommunity/Src/Lib/Downloader/MP4/downloader.py

@@ -0,0 +1,156 @@
+# 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.Src.Util.headers import get_headers
+from StreamingCommunity.Src.Util.color import Colors
+from StreamingCommunity.Src.Util.console import console, Panel
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+from StreamingCommunity.Src.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_VERIFY = config_manager.get_float('REQUESTS', 'verify_ssl')
+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/Src/Lib/Downloader/TOR/downloader.py

@@ -0,0 +1,222 @@
+# 23.06.24
+
+import os
+import sys
+import time
+import shutil
+import logging
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.color import Colors
+from StreamingCommunity.Src.Util.os import internet_manager
+from StreamingCommunity.Src.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_VERIFY = config_manager.get_float('REQUESTS', 'verify_ssl')
+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: 
+            self.qb = Client(f'http://{HOST}:{PORT}/')
+        except: 
+            logging.error("Start qbitorrent first.")
+        
+        self.username = USERNAME
+        self.password = PASSWORD
+        self.logged_in = False
+        self.save_path = None
+        self.torrent_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 add_magnet_link(self, magnet_link):
+        """
+        Adds a torrent via magnet link to qBittorrent.
+
+        Parameters:
+            - magnet_link (str): Magnet link of the torrent to be added.
+        """
+        try:
+            self.qb.download_from_link(magnet_link)
+            logging.info("Added magnet link to qBittorrent.")
+
+            # Get the hash of the latest added torrent
+            torrents = self.qb.torrents()
+            if torrents:
+                self.latest_torrent_hash = torrents[-1]['hash']
+                logging.info(f"Latest torrent hash: {self.latest_torrent_hash}")
+
+        except Exception as e:
+            logging.error(f"Failed to add magnet link: {str(e)}")
+
+    def start_download(self):
+        """
+        Starts downloading the latest added torrent and monitors progress.
+        """    
+        try:
+            
+            torrents = self.qb.torrents()
+            if not torrents:
+                logging.error("No torrents found.")
+                return
+            
+            # Sleep to load magnet to qbit app
+            time.sleep(10)
+            latest_torrent = torrents[-1]
+            torrent_hash = latest_torrent['hash']
+
+            # 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(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.")
+
+        except Exception as e:
+            logging.error(f"Download error: {str(e)}")
+            sys.exit(0)
+
+    def move_downloaded_files(self, destination=None):
+        """
+        Moves downloaded files of the latest torrent to another location.
+
+        Parameters:
+            - save_path (str): Current save path (output directory) of the torrent.
+            - destination (str, optional): Destination directory to move files. If None, moves to current directory.
+
+        Returns:
+            - bool: True if files are moved successfully, False otherwise.
+        """
+
+        video_extensions = {'.mp4', '.mkv', 'avi'}
+        time.sleep(2)
+        
+        # List directories in the save path
+        dirs = [d for d in os.listdir(self.save_path) if os.path.isdir(os.path.join(self.save_path, d))]
+        
+        for dir_name in dirs:
+            if self.torrent_name.split(" ")[0] in dir_name:
+                dir_path = os.path.join(self.save_path, dir_name)
+
+                # Ensure destination is set; if not, use current directory
+                destination = destination or os.getcwd()
+
+                # Move only video files
+                for file_name in os.listdir(dir_path):
+                    file_path = os.path.join(dir_path, file_name)
+                    
+                    # Check if it's a file and if it has a video extension
+                    if os.path.isfile(file_path) and os.path.splitext(file_name)[1] in video_extensions:
+                        shutil.move(file_path, os.path.join(destination, file_name))
+                        logging.info(f"Moved file {file_name} to {destination}")
+
+        time.sleep(2)
+        self.qb.delete_permanently(self.qb.torrents()[-1]['hash'])
+        return True

StreamingCommunity/Src/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/Src/Lib/Driver/driver_1.py

@@ -0,0 +1,76 @@
+# 29.06.24
+
+import tempfile
+import logging
+
+
+# External library
+from bs4 import BeautifulSoup
+from seleniumbase import Driver
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+
+
+# Config
+USE_HEADLESS = config_manager.get_bool("BROWSER", "headless")
+
+
+class WebAutomation:
+    """
+    A class for automating web interactions using SeleniumBase and BeautifulSoup.
+    """
+
+    def __init__(self):
+        """
+        Initializes the WebAutomation instance with SeleniumBase Driver.
+
+        Parameters:
+            headless (bool, optional): Whether to run the browser in headless mode. Default is True.
+        """
+        logging.getLogger('seleniumbase').setLevel(logging.ERROR)
+
+        self.driver = Driver(
+            uc=True, 
+            uc_cdp_events=True, 
+            headless=USE_HEADLESS,
+            user_data_dir = tempfile.mkdtemp(),
+            chromium_arg="--disable-search-engine-choice-screen"
+        )
+    
+    def quit(self):
+        """
+        Quits the WebDriver instance.
+        """
+        self.driver.quit()
+    
+    def get_page(self, url):
+        """
+        Navigates the browser to the specified URL.
+
+        Parameters:
+            url (str): The URL to navigate to.
+        """
+        self.driver.get(url)
+    
+    def retrieve_soup(self):
+        """
+        Retrieves the BeautifulSoup object for the current page's HTML content.
+
+        Returns:
+            BeautifulSoup object: Parsed HTML content of the current page.
+        """
+        html_content = self.driver.page_source
+        soup = BeautifulSoup(html_content, 'html.parser')
+        return soup
+    
+    def get_content(self):
+        """
+        Returns the HTML content of the current page.
+
+        Returns:
+            str: The HTML content of the current page.
+        """
+        return self.driver.page_source
+

StreamingCommunity/Src/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_s

StreamingCommunity/Src/Lib/FFmpeg/capture.py

@@ -0,0 +1,170 @@
+# 16.04.24
+
+import re
+import logging
+import threading
+import subprocess
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console
+from StreamingCommunity.Src.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}")