StreamingCommunity 1.9.1__py3-none-any.whl → 1.9.2__py3-none-any.whl

StreamingCommunity/Util/_jsonConfig.py

@@ -1,204 +0,0 @@
-# 29.01.24
-
-import os
-import json
-import httpx
-import logging
-from typing import Any, List
-
-
-class ConfigManager:
-    def __init__(self, file_path: str = 'config.json') -> None:
-        """Initialize the ConfigManager.
-
-        Parameters:
-            - file_path (str, optional): The path to the configuration file. Default is 'config.json'.
-        """
-        self.file_path = file_path
-        self.config = {}
-        self.cache = {}
-
-    def read_config(self) -> None:
-        """Read the configuration file."""
-        try:
-            logging.info(f"Reading file: {self.file_path}")
-            
-            # Check if file exist
-            if os.path.exists(self.file_path):
-                with open(self.file_path, 'r') as f:
-                    self.config = json.load(f)
-                logging.info("Configuration file loaded successfully.")
-            
-            # Download config.json
-            else:
-                logging.info("Configuration file does not exist. Downloading...")
-                url = "https://raw.githubusercontent.com/Lovi-0/StreamingCommunity/refs/heads/main/config.json"
-                
-                with httpx.Client() as client:
-                    response = client.get(url)
-                    
-                    if response.status_code == 200:
-                        with open(self.file_path, 'w') as f:
-                            f.write(response.text)
-
-                        self.config = json.loads(response.text)
-                        logging.info("Configuration file downloaded and saved.")
-
-                    else:
-                        logging.error(f"Failed to download configuration file. Status code: {response.status_code}")
-        
-        except Exception as e:
-            logging.error(f"Error reading configuration file: {e}")
-
-    def read_key(self, section: str, key: str, data_type: type = str) -> Any:
-        """Read a key from the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be read.
-            - data_type (type, optional): The expected data type of the key's value. Default is str.
-
-        Returns:
-            The value of the key converted to the specified data type.
-        """
-        cache_key = f"{section}.{key}"
-        logging.info(f"Read key: {cache_key}")
-
-        if cache_key in self.cache:
-            return self.cache[cache_key]
-        
-        if section in self.config and key in self.config[section]:
-            value = self.config[section][key]
-        else:
-            raise ValueError(f"Key '{key}' not found in section '{section}'")
-        
-        value = self._convert_to_data_type(value, data_type)
-        self.cache[cache_key] = value
-        
-        return value
-
-    def _convert_to_data_type(self, value: str, data_type: type) -> Any:
-        """Convert the value to the specified data type.
-
-        Parameters:
-            - value (str): The value to be converted.
-            - data_type (type): The expected data type.
-
-        Returns:
-            The value converted to the specified data type.
-        """
-        if data_type == int:
-            return int(value)
-        elif data_type == bool:
-            return bool(value)
-        elif data_type == list:
-            return value if isinstance(value, list) else [item.strip() for item in value.split(',')]
-        elif data_type == type(None):
-            return None
-        else:
-            return value
-        
-    def get(self, section: str, key: str) -> Any:
-        """Read a value from the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be read.
-
-        Returns:
-            The value associated with the key.
-        """
-        return self.read_key(section, key)
-
-    def get_int(self, section: str, key: str) -> int:
-        """Read an integer value from the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be read.
-
-        Returns:
-            int: The integer value.
-        """
-        return self.read_key(section, key, int)
-    
-    def get_float(self, section: str, key: str) -> int:
-        """Read an float value from the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be read.
-
-        Returns:
-            float: The float value.
-        """
-        return self.read_key(section, key, float)
-
-    def get_bool(self, section: str, key: str) -> bool:
-        """Read a boolean value from the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be read.
-
-        Returns:
-            bool: The boolean value.
-        """
-        return self.read_key(section, key, bool)
-
-    def get_list(self, section: str, key: str) -> List[str]:
-        """Read a list value from the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be read.
-
-        Returns:
-            list: The list value.
-        """
-        return self.read_key(section, key, list)
-    
-    def get_dict(self, section: str, key: str) -> dict:
-        """Read a dictionary value from the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be read.
-
-        Returns:
-            dict: The dictionary value.
-        """
-        return self.read_key(section, key, dict)
-
-    def set_key(self, section: str, key: str, value: Any) -> None:
-        """Set a key in the configuration file.
-
-        Parameters:
-            - section (str): The section in the configuration file.
-            - key (str): The key to be set.
-            - value (Any): The value to be associated with the key.
-        """
-        try:
-            if section not in self.config:
-                self.config[section] = {}
-
-            self.config[section][key] = value
-            cache_key = f"{section}.{key}"
-            self.cache[cache_key] = value
-            self.write_config()
-
-        except Exception as e:
-            print(f"Error setting key '{key}' in section '{section}': {e}")
-
-    def write_config(self) -> None:
-        """Write the configuration to the file."""
-        try:
-            with open(self.file_path, 'w') as f:
-                json.dump(self.config, f, indent=4)
-        except Exception as e:
-            print(f"Error writing configuration file: {e}")
-            
-
-# Initialize
-config_manager = ConfigManager()
-config_manager.read_config()

StreamingCommunity/Util/call_stack.py

@@ -1,42 +0,0 @@
-# 21.06.24
-
-import os
-import inspect
-
-
-def get_call_stack():
-    """
-    Retrieves the current call stack with details about each call.
-
-    This function inspects the current call stack and returns a list of dictionaries,
-    where each dictionary contains details about a function call in the stack.
-
-    Returns:
-        list: A list of dictionaries, each containing the following keys:
-            - function (str): The name of the function.
-            - folder (str): The directory path of the script containing the function.
-            - folder_base (str): The base name of the directory path.
-            - script (str): The name of the script file containing the function.
-            - line (int): The line number in the script where the function is defined.
-    """
-    
-    stack = inspect.stack()
-    call_stack = []
-
-    for frame_info in stack:
-        function_name = frame_info.function
-        filename = frame_info.filename
-        lineno = frame_info.lineno
-        folder_name = os.path.dirname(filename)
-        folder_base = os.path.basename(folder_name)
-        script_name = os.path.basename(filename)
-
-        call_stack.append({
-            "function": function_name,
-            "folder": folder_name,
-            "folder_base": folder_base,
-            "script": script_name,
-            "line": lineno
-        })
-        
-    return call_stack

StreamingCommunity/Util/color.py

@@ -1,20 +0,0 @@
-# 24.05.24
-
-class Colors:
-    BLACK = "\033[30m"
-    RED = "\033[31m"
-    GREEN = "\033[32m"
-    YELLOW = "\033[33m"
-    BLUE = "\033[34m"
-    MAGENTA = "\033[35m"
-    CYAN = "\033[36m"
-    LIGHT_GRAY = "\033[37m"
-    DARK_GRAY = "\033[90m"
-    LIGHT_RED = "\033[91m"
-    LIGHT_GREEN = "\033[92m"
-    LIGHT_YELLOW = "\033[93m"
-    LIGHT_BLUE = "\033[94m"
-    LIGHT_MAGENTA = "\033[95m"
-    LIGHT_CYAN = "\033[96m"
-    WHITE = "\033[97m"
-    RESET = "\033[0m"

StreamingCommunity/Util/console.py

@@ -1,12 +0,0 @@
-# 24.02.24
-
-from rich.console import Console
-from rich.prompt import Prompt, Confirm
-from rich.panel import Panel
-from rich.table import Table
-from rich.text import Text
-
-
-# Variable
-msg = Prompt()
-console = Console()

StreamingCommunity/Util/ffmpeg_installer.py

@@ -1,275 +0,0 @@
-# 24.01.2024
-
-import os
-import platform
-import subprocess
-import zipfile
-import tarfile
-import logging
-import requests
-import shutil
-import glob
-from typing import Optional, Tuple
-
-
-# External library
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeRemainingColumn
-
-
-# Variable
-console = Console()
-FFMPEG_CONFIGURATION = {
-    'windows': {
-        'base_dir': lambda home: os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary'),
-        'download_url': 'https://github.com/GyanD/codexffmpeg/releases/download/{version}/ffmpeg-{version}-full_build.zip',
-        'file_extension': '.zip',
-        'executables': ['ffmpeg.exe', 'ffprobe.exe', 'ffplay.exe']
-    },
-    'darwin': {
-        'base_dir': lambda home: os.path.join(home, 'Applications', 'binary'),
-        'download_url': 'https://evermeet.cx/ffmpeg/ffmpeg-{version}.zip',
-        'file_extension': '.zip',
-        'executables': ['ffmpeg', 'ffprobe', 'ffplay']
-    },
-    'linux': {
-        'base_dir': lambda home: os.path.join(home, '.local', 'bin', 'binary'),
-        'download_url': 'https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-{arch}-static.tar.xz',
-        'file_extension': '.tar.xz',
-        'executables': ['ffmpeg', 'ffprobe', 'ffplay']
-    }
-}
-
-
-
-class FFMPEGDownloader:
-    def __init__(self):
-        self.os_name = self._detect_system()
-        self.arch = self._detect_arch()
-        self.home_dir = os.path.expanduser('~')
-        self.base_dir = self._get_base_directory()
-
-    def _detect_system(self) -> str:
-        """Detect and normalize operating system name."""
-        system = platform.system().lower()
-
-        if system in FFMPEG_CONFIGURATION:
-            return system
-        
-        raise ValueError(f"Unsupported operating system: {system}")
-
-    def _detect_arch(self) -> str:
-        """
-        Detect system architecture
-        """
-        machine = platform.machine().lower()
-
-        arch_map = {
-            'amd64': 'x86_64', 
-            'x86_64': 'x86_64', 
-            'x64': 'x86_64',
-            'arm64': 'arm64', 
-            'aarch64': 'arm64'
-        }
-
-        return arch_map.get(machine, machine)
-
-    def _get_base_directory(self) -> str:
-        """
-        Get base directory for binaries
-        """
-        base_dir = FFMPEG_CONFIGURATION[self.os_name]['base_dir'](self.home_dir)
-        os.makedirs(base_dir, exist_ok=True)
-
-        return base_dir
-
-    def _check_existing_binaries(self) -> Tuple[Optional[str], Optional[str]]:
-        """
-        Check if FFmpeg binaries already exist in the base directory
-        """
-        config = FFMPEG_CONFIGURATION[self.os_name]
-        executables = config['executables']
-
-        found_executables = []
-        for executable in executables:
-            
-            # Search for exact executable in base directory
-            exe_paths = glob.glob(os.path.join(self.base_dir, executable))
-            if exe_paths:
-                found_executables.append(exe_paths[0])
-
-        # Return paths if both executables are found
-        if len(found_executables) == len(executables):
-            return tuple(found_executables)
-
-        return None, None
-
-    def _get_latest_version(self) -> str:
-        """
-        Get the latest FFmpeg version
-        """
-        try:
-            version_url = 'https://www.gyan.dev/ffmpeg/builds/release-version'
-            return requests.get(version_url).text.strip()
-        
-        except Exception as e:
-            logging.error(f"Unable to get version: {e}")
-            return None
-
-    def _download_file(self, url: str, destination: str) -> bool:
-        """
-        Download with Rich progress bar
-        """
-        try:
-            response = requests.get(url, stream=True)
-            response.raise_for_status()
-            
-            total_size = int(response.headers.get('content-length', 0))
-            
-            with open(destination, 'wb') as file, \
-                Progress(
-                    SpinnerColumn(),
-                    TextColumn("[progress.description]{task.description}"),
-                    BarColumn(),
-                    TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-                    TimeRemainingColumn()
-                ) as progress:
-                
-                download_task = progress.add_task("[green]Downloading FFmpeg", total=total_size)
-                
-                for chunk in response.iter_content(chunk_size=8192):
-                    size = file.write(chunk)
-                    progress.update(download_task, advance=size)
-            
-            return True
-        
-        except Exception as e:
-            logging.error(f"Download error: {e}")
-            return False
-
-    def _extract_and_copy_binaries(self, archive_path: str) -> Tuple[Optional[str], Optional[str]]:
-        """
-        Extract archive and copy executables to base directory
-        """
-        try:
-            # Temporary extraction path
-            extraction_path = os.path.join(self.base_dir, 'temp_extract')
-            os.makedirs(extraction_path, exist_ok=True)
-
-            # Extract based on file type
-            if archive_path.endswith('.zip'):
-                with zipfile.ZipFile(archive_path, 'r') as zip_ref:
-                    zip_ref.extractall(extraction_path)
-            elif archive_path.endswith('.tar.xz'):
-                import lzma
-                with lzma.open(archive_path, 'rb') as xz_file:
-                    with tarfile.open(fileobj=xz_file) as tar_ref:
-                        tar_ref.extractall(extraction_path)
-
-            # Find and copy executables
-            config = FFMPEG_CONFIGURATION[self.os_name]
-            executables = config['executables']
-            
-            found_paths = []
-            for executable in executables:
-                # Find executable in extracted files
-                exe_paths = glob.glob(os.path.join(extraction_path, '**', executable), recursive=True)
-                
-                if exe_paths:
-                    # Copy to base directory
-                    dest_path = os.path.join(self.base_dir, executable)
-                    shutil.copy2(exe_paths[0], dest_path)
-                    
-                    # Set execution permissions for Unix-like systems
-                    if self.os_name != 'windows':
-                        os.chmod(dest_path, 0o755)
-                    
-                    found_paths.append(dest_path)
-
-            # Clean up temporary extraction directory
-            shutil.rmtree(extraction_path, ignore_errors=True)
-            
-            # Remove downloaded archive
-            os.remove(archive_path)
-
-            # Return paths if both executables found
-            if len(found_paths) == len(executables):
-                return tuple(found_paths)
-            
-            return None, None
-
-        except Exception as e:
-            logging.error(f"Extraction/copy error: {e}")
-            return None, None
-
-    def download(self) -> Tuple[Optional[str], Optional[str]]:
-        """
-        Main download procedure
-        Returns paths of ffmpeg and ffprobe
-        """
-        # First, check if binaries already exist in base directory
-        existing_ffmpeg, existing_ffprobe, existing_ffplay = self._check_existing_binaries()
-        if existing_ffmpeg and existing_ffprobe:
-            return existing_ffmpeg, existing_ffprobe
-
-        # Get latest version
-        version = self._get_latest_version()
-        if not version:
-            logging.error("Cannot proceed: version not found")
-            return None, None
-
-        # Prepare configurations
-        config = FFMPEG_CONFIGURATION[self.os_name]
-        
-        # Build download URL
-        download_url = config['download_url'].format(
-            version=version, 
-            arch=self.arch
-        )
-        
-        # Download path
-        download_path = os.path.join(
-            self.base_dir, 
-            f'ffmpeg-{version}{config["file_extension"]}'
-        )
-        
-        # Download
-        console.print(
-            f"[bold blue]Downloading FFmpeg from:[/] {download_url}", 
-        )
-        if not self._download_file(download_url, download_path):
-            return None, None
-        
-        # Extract and copy binaries
-        ffmpeg_path, ffprobe_path = self._extract_and_copy_binaries(download_path)
-        
-        if ffmpeg_path and ffprobe_path:
-            return ffmpeg_path, ffprobe_path
-        
-        logging.error("FFmpeg executables not found")
-        return None, None
-
-
-def check_ffmpeg():
-    try:
-        # First, use 'where' command to check existing binaries on Windows
-        if platform.system().lower() == 'windows':
-            ffmpeg_path = subprocess.check_output(['where', 'ffmpeg'], text=True).strip().split('\n')[0] if subprocess.call(['where', 'ffmpeg'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0 else None
-            ffprobe_path = subprocess.check_output(['where', 'ffprobe'], text=True).strip().split('\n')[0] if subprocess.call(['where', 'ffprobe'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0 else None
-            
-            if ffmpeg_path and ffprobe_path:
-                return ffmpeg_path, ffprobe_path
-        
-        # Fallback to which/shutil method for Unix-like systems
-        ffmpeg_path = shutil.which('ffmpeg')
-        ffprobe_path = shutil.which('ffprobe')
-        
-        if ffmpeg_path and ffprobe_path:
-            return ffmpeg_path, ffprobe_path
-        
-        downloader = FFMPEGDownloader()
-        return downloader.download()
-    
-    except Exception as e:
-        logging.error(f"Error checking FFmpeg: {e}")
-        return None, None