StreamingCommunity 3.3.1__py3-none-any.whl → 3.3.3__py3-none-any.whl

StreamingCommunity/Util/{ffmpeg_installer.py → installer/ffmpeg_install.py}

@@ -5,7 +5,6 @@ import glob
 import gzip
 import shutil
 import logging
-import platform
 import subprocess
 from typing import Optional, Tuple
 
@@ -16,25 +15,26 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeRemainingColumn
 
 
+# Internal utilities
+from .binary_paths import binary_paths
+
+
 # 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/eugeneware/ffmpeg-static/releases/latest/download/ffmpeg-win32-{arch}.gz',
         'file_extension': '.gz',
         'executables': ['ffmpeg-win32-{arch}', 'ffprobe-win32-{arch}']
     },
     'darwin': {
-        'base_dir': lambda home: os.path.join(home, 'Applications', 'binary'),
         'download_url': 'https://github.com/eugeneware/ffmpeg-static/releases/latest/download/ffmpeg-darwin-{arch}.gz',
         'file_extension': '.gz',
         'executables': ['ffmpeg-darwin-{arch}', 'ffprobe-darwin-{arch}']
     },
     'linux': {
-        'base_dir': lambda home: os.path.join(home, '.local', 'bin', 'binary'),
         'download_url': 'https://github.com/eugeneware/ffmpeg-static/releases/latest/download/ffmpeg-linux-{arch}.gz',
         'file_extension': '.gz',
         'executables': ['ffmpeg-linux-{arch}', 'ffprobe-linux-{arch}']
@@ -44,88 +44,98 @@ FFMPEG_CONFIGURATION = {
 
 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()
+        self.os_name = binary_paths.system
+        self.arch = binary_paths.arch
+        self.home_dir = binary_paths.home_dir
+        self.base_dir = binary_paths.ensure_binary_directory()
 
-    def _detect_system(self) -> str:
+    def _check_existing_binaries(self) -> Tuple[Optional[str], Optional[str], Optional[str]]:
         """
-        Detect and normalize the operating system name.
-
+        Check if FFmpeg binaries already exist.
+        Order: system PATH (where/which) -> binary directory
+        
         Returns:
-            str: Normalized operating system name ('windows', 'darwin', or 'linux')
-        """
-        system = platform.system().lower()
-        if system in FFMPEG_CONFIGURATION:
-            return system
-        raise ValueError(f"Unsupported operating system: {system}")
-
-    def _detect_arch(self) -> str:
+            Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, ffplay
         """
-        Detect and normalize the system architecture.
+        try:
 
-        Returns:
-            str: Normalized architecture name (e.g., 'x86_64', 'arm64')
-        """
-        machine = platform.machine().lower()
-        arch_map = {
-            'amd64': 'x64', 
-            'x86_64': 'x64',
-            'x64': 'x64',
-            'arm64': 'arm64',
-            'aarch64': 'arm64',
-            'armv7l': 'arm',
-            'i386': 'ia32',
-            'i686': 'ia32'
-        }
-        return arch_map.get(machine, machine)
-
-    def _get_base_directory(self) -> str:
-        """
-        Get and create the base directory for storing FFmpeg binaries.
+            # STEP 1: Check system PATH first
+            console.print("[cyan]Checking for FFmpeg in system PATH...[/]")
+            if self.os_name == 'windows':
+                try:
+                    ffmpeg_path = subprocess.check_output(
+                        ['where', 'ffmpeg'], stderr=subprocess.DEVNULL, text=True
+                    ).strip().split('\n')[0]
+                    
+                    ffprobe_path = subprocess.check_output(
+                        ['where', 'ffprobe'], stderr=subprocess.DEVNULL, text=True
+                    ).strip().split('\n')[0]
+                    
+                    try:
+                        ffplay_path = subprocess.check_output(
+                            ['where', 'ffplay'], stderr=subprocess.DEVNULL, text=True
+                        ).strip().split('\n')[0]
+                    except subprocess.CalledProcessError:
+                        ffplay_path = None
+                        
+                    return ffmpeg_path, ffprobe_path, ffplay_path
+                    
+                except subprocess.CalledProcessError:
+                    pass
+            
+            else:
+                ffmpeg_path = shutil.which('ffmpeg')
+                ffprobe_path = shutil.which('ffprobe')
+                ffplay_path = shutil.which('ffplay')
+                
+                if ffmpeg_path and ffprobe_path:
+                    return ffmpeg_path, ffprobe_path, ffplay_path
 
-        Returns:
-            str: Path to the base directory
-        """
-        base_dir = FFMPEG_CONFIGURATION[self.os_name]['base_dir'](self.home_dir)
-        os.makedirs(base_dir, exist_ok=True)
-        return base_dir
+            # STEP 2: Check in binary directory
+            console.print("[cyan]Checking for FFmpeg in binary directory...[/]")
+            config = FFMPEG_CONFIGURATION[self.os_name]
+            executables = [exe.format(arch=self.arch) for exe in config['executables']]
+            found_executables = []
 
-    def _check_existing_binaries(self) -> Tuple[Optional[str], Optional[str], Optional[str]]:
-        """
-        Check if FFmpeg binaries already exist in the base directory.
-        Enhanced to check both the binary directory and system paths on macOS.
-        """
-        config = FFMPEG_CONFIGURATION[self.os_name]
-        executables = config['executables']
-        found_executables = []
-
-        # For macOS, check both binary directory and system paths
-        if self.os_name == 'darwin':
-            potential_paths = [
-                '/usr/local/bin',
-                '/opt/homebrew/bin',
-                '/usr/bin',
-                self.base_dir
-            ]
-            
-            for executable in executables:
-                found = None
-                for path in potential_paths:
-                    full_path = os.path.join(path, executable)
-                    if os.path.exists(full_path) and os.access(full_path, os.X_OK):
-                        found = full_path
-                        break
-                found_executables.append(found)
-        else:
-
-            # Original behavior for other operating systems
             for executable in executables:
-                exe_paths = glob.glob(os.path.join(self.base_dir, executable))
-                found_executables.append(exe_paths[0] if exe_paths else None)
 
-        return tuple(found_executables) if len(found_executables) == 3 else (None, None, None)
+                # Check for exact match first
+                exe_paths = glob.glob(os.path.join(self.base_dir, executable))
+                if exe_paths:
+                    found_executables.append(exe_paths[0])
+                    
+                else:
+                    # Check for standard names
+                    if self.os_name == 'windows':
+                        if 'ffmpeg' in executable:
+                            standard_path = os.path.join(self.base_dir, 'ffmpeg.exe')
+                        elif 'ffprobe' in executable:
+                            standard_path = os.path.join(self.base_dir, 'ffprobe.exe')
+                        else:
+                            standard_path = None
+                    else:
+                        if 'ffmpeg' in executable:
+                            standard_path = os.path.join(self.base_dir, 'ffmpeg')
+                        elif 'ffprobe' in executable:
+                            standard_path = os.path.join(self.base_dir, 'ffprobe')
+                        else:
+                            standard_path = None
+                    
+                    if standard_path and os.path.exists(standard_path):
+                        found_executables.append(standard_path)
+                    else:
+                        found_executables.append(None)
+
+            # Return found executables if we have at least ffmpeg and ffprobe
+            if len(found_executables) >= 2 and found_executables[0] and found_executables[1]:
+                ffplay_path = found_executables[2] if len(found_executables) > 2 else None
+                return found_executables[0], found_executables[1], ffplay_path
+            
+            return (None, None, None)
+            
+        except Exception as e:
+            logging.error(f"Error checking existing binaries: {e}")
+            return (None, None, None)
 
     def _get_latest_version(self, repo: str) -> Optional[str]:
         """
@@ -253,7 +263,6 @@ class FFMPEGDownloader:
                     ffprobe_path = shutil.which('ffprobe')
 
                     if ffmpeg_path and ffprobe_path:
-                        console.print("[bold green]FFmpeg successfully installed via apt[/]")
                         return ffmpeg_path, ffprobe_path, None
                 else:
                     console.print("[bold yellow]Failed to install FFmpeg via apt. Proceeding with static download.[/]")
@@ -285,7 +294,6 @@ class FFMPEGDownloader:
                 # Extract the file
                 if self._extract_file(download_path, final_path):
                     successful_extractions.append(final_path)
-                    console.print(f"[bold green]Successfully installed {executable}[/]")
                 else:
                     console.print(f"[bold red]Failed to extract {executable}[/]")
 
@@ -304,71 +312,25 @@ class FFMPEGDownloader:
 def check_ffmpeg() -> Tuple[Optional[str], Optional[str], Optional[str]]:
     """
     Check for FFmpeg executables in the system and download them if not found.
-    Enhanced detection for macOS systems.
-
+    Order: system PATH (where/which) -> binary directory -> download
+    
     Returns:
-        Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay executables.
+        Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay
     """
     try:
-        system_platform = platform.system().lower()
+        # Create downloader instance to use its existing check method
+        downloader = FFMPEGDownloader()
         
-        # Special handling for macOS
-        if system_platform == 'darwin':
-
-            # Common installation paths on macOS
-            potential_paths = [
-                '/usr/local/bin',                               # Homebrew default
-                '/opt/homebrew/bin',                            # Apple Silicon Homebrew
-                '/usr/bin',                                     # System default
-                os.path.expanduser('~/Applications/binary'),    # Custom installation
-                '/Applications/binary'                          # Custom installation
-            ]
-            
-            for path in potential_paths:
-                ffmpeg_path = os.path.join(path, 'ffmpeg')
-                ffprobe_path = os.path.join(path, 'ffprobe')
-                ffplay_path = os.path.join(path, 'ffplay')
-                
-                if (os.path.exists(ffmpeg_path) and os.path.exists(ffprobe_path) and 
-                    os.access(ffmpeg_path, os.X_OK) and os.access(ffprobe_path, os.X_OK)):
-                    
-                    # Return found executables, with ffplay being optional
-                    ffplay_path = ffplay_path if os.path.exists(ffplay_path) else None
-                    return ffmpeg_path, ffprobe_path, ffplay_path
-
-        # Windows detection
-        elif system_platform == 'windows':
-            try:
-                ffmpeg_path = subprocess.check_output(
-                    ['where', 'ffmpeg'], stderr=subprocess.DEVNULL, text=True
-                ).strip().split('\n')[0]
-                
-                ffprobe_path = subprocess.check_output(
-                    ['where', 'ffprobe'], stderr=subprocess.DEVNULL, text=True
-                ).strip().split('\n')[0]
-                
-                ffplay_path = subprocess.check_output(
-                    ['where', 'ffplay'], stderr=subprocess.DEVNULL, text=True
-                ).strip().split('\n')[0]
-
-                return ffmpeg_path, ffprobe_path, ffplay_path
-            
-            except subprocess.CalledProcessError:
-                logging.warning("One or more FFmpeg binaries were not found with command where")
-
-        # Linux detection
-        else:
-            ffmpeg_path = shutil.which('ffmpeg')
-            ffprobe_path = shutil.which('ffprobe')
-            ffplay_path = shutil.which('ffplay')
-            
-            if ffmpeg_path and ffprobe_path:
-                return ffmpeg_path, ffprobe_path, ffplay_path
+        # STEP 1 & 2: Check existing binaries (system PATH + binary directory)
+        ffmpeg_path, ffprobe_path, ffplay_path = downloader._check_existing_binaries()
+        
+        # If found, return them
+        if ffmpeg_path and ffprobe_path:
+            return ffmpeg_path, ffprobe_path, ffplay_path
 
-        # If executables were not found, attempt to download FFmpeg
-        downloader = FFMPEGDownloader()
+        # STEP 3: Download if not found
         return downloader.download()
 
     except Exception as e:
         logging.error(f"Error checking or downloading FFmpeg executables: {e}")
-        return None, None, None
+        return None, None, None

StreamingCommunity/Util/logger.py

@@ -13,7 +13,6 @@ class Logger:
     _instance = None
     
     def __new__(cls):
-        # Singleton pattern to avoid multiple logger instances
         if cls._instance is None:
             cls._instance = super(Logger, cls).__new__(cls)
             cls._instance._initialized = False
@@ -24,10 +23,8 @@ class Logger:
         if getattr(self, '_initialized', False):
             return
         
-        # Fetch only the debug setting from config
-        self.debug_mode = config_manager.get_bool("DEFAULT", "debug")
-        
         # Configure root logger
+        self.debug_mode = config_manager.get_bool('DEFAULT', "debug")
         self.logger = logging.getLogger('')
         
         # Remove any existing handlers to avoid duplication
@@ -45,16 +42,14 @@ class Logger:
 
         else:
             self.logger.setLevel(logging.ERROR)
-        
-        # Configure console logging (terminal output) regardless of debug mode
-        self._configure_console_logging()
+            self._configure_console_logging()
         
         self._initialized = True
         
     def _configure_console_logging(self):
         """Configure console logging output to terminal."""
         console_handler = logging.StreamHandler()
-        console_handler.setLevel(logging.DEBUG if self.debug_mode else logging.ERROR)
+        console_handler.setLevel(logging.ERROR)
         formatter = logging.Formatter('[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
         console_handler.setFormatter(formatter)
         self.logger.addHandler(console_handler)

StreamingCommunity/Util/os.py

@@ -2,16 +2,13 @@
 
 import io
 import os
-import glob
-import sys
+import time
 import shutil
 import logging
+import socket
 import platform
 import inspect
-import subprocess
 import contextlib
-import importlib.metadata
-import socket
 
 
 # External library
@@ -22,8 +19,9 @@ from pathvalidate import sanitize_filename, sanitize_filepath
 
 
 # Internal utilities
-from .ffmpeg_installer import check_ffmpeg
-from .bento4_installer import check_mp4decrypt
+from .installer.ffmpeg_install import check_ffmpeg
+from .installer.bento4_install import check_mp4decrypt
+from .installer.device_install import check_wvd_path
 
 
 # Variable
@@ -243,7 +241,7 @@ class OsManager:
             return False
 
 
-class InternManager():
+class InternetManager():
     def format_file_size(self, size_bytes: float) -> str:
         """
         Formats a file size from bytes into a human-readable string representation.
@@ -305,144 +303,46 @@ class InternManager():
         except (socket.gaierror, socket.error):
             return False
 
+
 class OsSummary:
     def __init__(self):
         self.ffmpeg_path = None
         self.ffprobe_path = None
         self.ffplay_path = None
         self.mp4decrypt_path = None
+        self.wvd_path = None
+        self.init()
 
-    def get_binary_directory(self):
-        """Get the binary directory based on OS."""
-        system = platform.system().lower()
-        home = os.path.expanduser('~')
-
-        if system == 'windows':
-            return os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary')
-        elif system == 'darwin':
-            return os.path.join(home, 'Applications', 'binary')
-        else:  # linux
-            return os.path.join(home, '.local', 'bin', 'binary')
-
-    def check_ffmpeg_location(self, command: list) -> str:
-        """
-        Check if a specific executable (ffmpeg or ffprobe) is located using the given command.
-        Returns the path of the executable or None if not found.
-        """
-        try:
-            result = subprocess.check_output(command, text=True).strip()
-            return result.split('\n')[0] if result else None
-
-        except subprocess.CalledProcessError:
-            return None
-
-    def get_library_version(self, lib_name: str):
-        """
-        Retrieve the version of a Python library.
-
-        Args:
-            lib_name (str): The name of the Python library.
-
-        Returns:
-            str: The library name followed by its version, or `-not installed` if not found.
-        """
-        try:
-            version = importlib.metadata.version(lib_name)
-            return f"{lib_name}-{version}"
-
-        except importlib.metadata.PackageNotFoundError:
-            return f"{lib_name}-not installed"
-
-    def install_library(self, lib_name: str):
-        """
-        Install a Python library using pip.
-
-        Args:
-            lib_name (str): The name of the library to install.
-        """
-        try:
-            console.print(f"Installing {lib_name}...", style="bold yellow")
-            subprocess.check_call([sys.executable, "-m", "pip", "install", lib_name])
-            console.print(f"{lib_name} installed successfully!", style="bold green")
-
-        except subprocess.CalledProcessError as e:
-            console.print(f"Failed to install {lib_name}: {e}", style="bold red")
-            sys.exit(1)
-
-    def check_python_version(self):
-        """
-        Check if the installed Python is the official CPython distribution.
-        Exits with a message if not the official version.
-        """
-        python_implementation = platform.python_implementation()
-        python_version = platform.python_version()
-
-        if python_implementation != "CPython":
-            console.print(f"[bold red]Warning: You are using a non-official Python distribution: {python_implementation}.[/bold red]")
-            console.print("Please install the official Python from [bold blue]https://www.python.org[/bold blue] and try again.", style="bold yellow")
-            sys.exit(0)
-
-        console.print(f"[cyan]Python version: [bold red]{python_version}[/bold red]")
-
-    def get_system_summary(self):
-        self.check_python_version()
-
-        # FFmpeg detection
-        binary_dir = self.get_binary_directory()
-        system = platform.system().lower()
-        arch = platform.machine().lower()
-
-        # Map architecture names
-        arch_map = {
-            'amd64': 'x64',
-            'x86_64': 'x64',
-            'x64': 'x64',
-            'arm64': 'arm64',
-            'aarch64': 'arm64',
-            'armv7l': 'arm',
-            'i386': 'ia32',
-            'i686': 'ia32'
-        }
-        arch = arch_map.get(arch, arch)
-
-        # Check FFmpeg binaries
-        if os.path.exists(binary_dir):
-            ffmpeg_files = glob.glob(os.path.join(binary_dir, f'*ffmpeg*{arch}*'))
-            ffprobe_files = glob.glob(os.path.join(binary_dir, f'*ffprobe*{arch}*'))
+    def init(self):
 
-            if ffmpeg_files and ffprobe_files:
-                self.ffmpeg_path = ffmpeg_files[0]
-                self.ffprobe_path = ffprobe_files[0]
-
-                if system != 'windows':
-                    os.chmod(self.ffmpeg_path, 0o755)
-                    os.chmod(self.ffprobe_path, 0o755)
-            else:
-                self.ffmpeg_path, self.ffprobe_path, self.ffplay_path = check_ffmpeg()
-        else:
-            self.ffmpeg_path, self.ffprobe_path, self.ffplay_path = check_ffmpeg()
-
-        # Check mp4decrypt
+        # Check for binaries
+        self.ffmpeg_path, self.ffprobe_path, _ = check_ffmpeg()
         self.mp4decrypt_path = check_mp4decrypt()
-
-        if not self.ffmpeg_path or not self.ffprobe_path:
-            console.log("[red]Can't locate ffmpeg or ffprobe")
-            sys.exit(0)
-
-        if not self.mp4decrypt_path:
-            console.log("[yellow]Warning: mp4decrypt not found")
+        self.wvd_path = check_wvd_path()
+        
+        self._display_binary_paths()
+        time.sleep(0.3)
+
+    def _display_binary_paths(self):
+        """Display the paths of all detected binaries."""
+        paths = {
+            'ffmpeg': self.ffmpeg_path,
+            'ffprobe': self.ffprobe_path,
+            'mp4decrypt': self.mp4decrypt_path,
+            'wvd': self.wvd_path
+        }
         
-        ffmpeg_str = f"'{self.ffmpeg_path}'" if self.ffmpeg_path else "None"
-        ffprobe_str = f"'{self.ffprobe_path}'" if self.ffprobe_path else "None"
-        mp4decrypt_str = f"'{self.mp4decrypt_path}'" if self.mp4decrypt_path else "None"
-        wvd_path = get_wvd_path()
-        wvd_str = f"'{wvd_path}'" if wvd_path else "None"
+        path_strings = []
+        for name, path in paths.items():
+            path_str = f"'{path}'" if path else "None"
+            path_strings.append(f"[red]{name} [bold yellow]{path_str}[/bold yellow]")
         
-        console.print(f"[cyan]Path: [red]ffmpeg [bold yellow]{ffmpeg_str}[/bold yellow][white], [red]ffprobe [bold yellow]{ffprobe_str}[/bold yellow][white], [red]mp4decrypt [bold yellow]{mp4decrypt_str}[/bold yellow][white], [red]wvd [bold yellow]{wvd_str}[/bold yellow]")
+        console.print(f"[cyan]Path: {', [white]'.join(path_strings)}")
 
 
+# Initialize the os_summary, internet_manager, and os_manager when the module is imported
 os_manager = OsManager()
-internet_manager = InternManager()
+internet_manager = InternetManager()
 os_summary = OsSummary()
 
 
@@ -487,21 +387,5 @@ def get_mp4decrypt_path():
     return os_summary.mp4decrypt_path
 
 def get_wvd_path():
-    """
-    Searches the system's binary folder and returns the path of the first file ending with 'wvd'.
-    Returns None if not found.
-    """
-    system = platform.system().lower()
-    home = os.path.expanduser('~')
-    if system == 'windows':
-        binary_dir = os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary')
-    elif system == 'darwin':
-        binary_dir = os.path.join(home, 'Applications', 'binary')
-    else:
-        binary_dir = os.path.join(home, '.local', 'bin', 'binary')
-    if not os.path.exists(binary_dir):
-        return None
-    for file in os.listdir(binary_dir):
-        if file.lower().endswith('wvd'):
-            return os.path.join(binary_dir, file)
-    return None
+    """Returns the path of wvd."""
+    return os_summary.wvd_path

StreamingCommunity/run.py

@@ -24,7 +24,7 @@ from rich.prompt import Prompt
 from .global_search import global_search
 from StreamingCommunity.Util.message import start_message
 from StreamingCommunity.Util.config_json import config_manager
-from StreamingCommunity.Util.os import os_summary, internet_manager, os_manager
+from StreamingCommunity.Util.os import internet_manager, os_manager
 from StreamingCommunity.Util.logger import Logger
 from StreamingCommunity.Lib.TMBD import tmdb
 from StreamingCommunity.Upload.update import update as git_update
@@ -97,7 +97,6 @@ def load_search_functions() -> Dict[str, Tuple]:
 def initialize():
     """Initialize the application with system checks and setup."""
     start_message()
-    os_summary.get_system_summary()
     
     # Windows 7 terminal size fix
     if platform.system() == "Windows" and "7" in platform.version():
@@ -107,7 +106,7 @@ def initialize():
     if sys.version_info < (3, 7):
         console.log("[red]Install python version > 3.7.16")
         sys.exit(0)
-    
+
     # Show trending content
     if SHOW_TRENDING:
         print()