StreamingCommunity 3.3.2__py3-none-any.whl → 3.3.5__py3-none-any.whl

StreamingCommunity/Util/installer/device_install.py

@@ -0,0 +1,133 @@
+# 18.07.25
+
+import os
+import struct
+import logging
+from typing import Optional
+
+
+# External library
+from rich.console import Console
+
+
+# Internal utilities
+from .binary_paths import binary_paths
+
+
+# Variable
+console = Console()
+
+
+class DeviceDownloader:
+    def __init__(self):
+        self.base_dir = binary_paths.ensure_binary_directory()
+
+    def extract_png_chunk(self, png_with_wvd: str, out_wvd_path: str) -> bool:
+        """Extract WVD data"""
+        try:
+            with open(png_with_wvd, "rb") as f: 
+                data = f.read()
+            pos = 8
+            
+            while pos < len(data):
+                length = struct.unpack(">I", data[pos:pos+4])[0]
+                chunk_type = data[pos+4:pos+8]
+                chunk_data = data[pos+8:pos+8+length]
+
+                if chunk_type == b"stEg":
+                    with open(out_wvd_path, "wb") as f: 
+                        f.write(chunk_data)
+                    return True
+                
+                pos += 12 + length
+            
+            return False
+            
+        except Exception as e:
+            logging.error(f"Error extracting PNG chunk: {e}")
+            return False
+
+    def _check_existing_wvd(self) -> Optional[str]:
+        """Check for existing WVD files in binary directory."""
+        try:
+            console.print("[cyan]Checking for existing device.wvd files...")
+            if not os.path.exists(self.base_dir):
+                return None
+
+            # Look for any .wvd file first
+            for file in os.listdir(self.base_dir):
+                if file.lower().endswith('.wvd'):
+                    wvd_path = os.path.join(self.base_dir, file)
+                    if os.path.exists(wvd_path) and os.path.getsize(wvd_path) > 0:
+                        logging.info(f"Found existing .wvd file: {file}")
+                        return wvd_path
+                
+            return None
+            
+        except Exception as e:
+            logging.error(f"Error checking existing WVD files: {e}")
+            return None
+
+    def _find_png_recursively(self, start_dir: str = ".") -> Optional[str]:
+        """Find crunchyroll_etp_rt.png recursively starting from start_dir."""
+        target_filename = "crunchyroll_etp_rt.png"
+        
+        try:
+            for root, dirs, files in os.walk(start_dir):
+                if target_filename in files:
+                    png_path = os.path.join(root, target_filename)
+                    logging.info(f"Found PNG file at: {png_path}")
+                    return png_path
+                    
+            logging.warning(f"PNG file '{target_filename}' not found in '{start_dir}' and subdirectories")
+            return None
+            
+        except Exception as e:
+            logging.error(f"Error during recursive PNG search: {e}")
+            return None
+
+    def download(self) -> Optional[str]:
+        """
+        Main method to extract WVD file from PNG.
+        """
+        try:
+            png_path = self._find_png_recursively()
+            if not png_path:
+                logging.error("PNG file not found, cannot extract device.wvd")
+                return None
+
+            device_wvd_path = os.path.join(self.base_dir, 'device.wvd')
+            
+            if self.extract_png_chunk(png_path, device_wvd_path):
+                if os.path.exists(device_wvd_path) and os.path.getsize(device_wvd_path) > 0:
+                    logging.info("Successfully extracted device.wvd from PNG")
+                    return device_wvd_path
+                else:
+                    logging.error("Extraction completed but resulting file is invalid")
+                    return None
+            else:
+                logging.error("Failed to extract device.wvd from PNG")
+                return None
+                
+        except Exception as e:
+            logging.error(f"Error during WVD extraction: {e}")
+            return None
+
+
+def check_wvd_path() -> Optional[str]:
+    """
+    Check for device.wvd file in binary directory and extract from PNG if not found.
+    """
+    try:
+        downloader = DeviceDownloader()
+        
+        existing_wvd = downloader._check_existing_wvd()
+        if existing_wvd:
+            return existing_wvd
+        
+        logging.info("device.wvd not found, attempting extraction from PNG")
+        return downloader.download()
+
+    except Exception as e:
+        logging.error(f"Error checking for device.wvd: {e}")
+        return None

StreamingCommunity/Util/installer/ffmpeg_install.py

@@ -51,38 +51,91 @@ class FFMPEGDownloader:
 
     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.
+        Check if FFmpeg binaries already exist.
+        Order: system PATH (where/which) -> binary directory
+        
+        Returns:
+            Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, ffplay
         """
-        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
-            ]
+        try:
+
+            # 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
+
+            # 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 = []
+
             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]:
         """
@@ -210,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.[/]")
@@ -242,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}[/]")
 
@@ -261,69 +312,23 @@ 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 = binary_paths.system
+        # 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
-                binary_paths.get_binary_directory(),            # 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:

StreamingCommunity/Util/os.py

@@ -2,17 +2,13 @@
 
 import io
 import os
-import glob
-import sys
+import time
 import shutil
-import struct
 import logging
 import socket
 import platform
 import inspect
-import subprocess
 import contextlib
-import importlib.metadata
 
 
 # External library
@@ -25,7 +21,7 @@ from pathvalidate import sanitize_filename, sanitize_filepath
 # Internal utilities
 from .installer.ffmpeg_install import check_ffmpeg
 from .installer.bento4_install import check_mp4decrypt
-from .installer.binary_paths import binary_paths
+from .installer.device_install import check_wvd_path
 
 
 # Variable
@@ -245,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.
@@ -314,83 +310,18 @@ class OsSummary:
         self.ffprobe_path = None
         self.ffplay_path = None
         self.mp4decrypt_path = None
-
-    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)
+        self.wvd_path = None
+        self.init()
 
     def init(self):
 
-        # Initialize binary paths and check for existing binaries
-        binary_dir = binary_paths.get_binary_directory()
-        arch = binary_paths.arch
-
-        # Check for existing FFmpeg binaries in binary directory
-        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}*'))
-
-            if ffmpeg_files and ffprobe_files:
-                self.ffmpeg_path = ffmpeg_files[0]
-                self.ffprobe_path = ffprobe_files[0]
-            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()
-
-        # Validate required binaries
-        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."""
@@ -398,7 +329,7 @@ class OsSummary:
             'ffmpeg': self.ffmpeg_path,
             'ffprobe': self.ffprobe_path,
             'mp4decrypt': self.mp4decrypt_path,
-            'wvd': get_wvd_path()
+            'wvd': self.wvd_path
         }
         
         path_strings = []
@@ -409,8 +340,9 @@ class OsSummary:
         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()
 
 
@@ -419,29 +351,6 @@ def suppress_output():
     with contextlib.redirect_stdout(io.StringIO()):
         yield
 
-def extract_png_chunk(png_with_wvd, out_wvd_path):
-    with open(png_with_wvd, "rb") as f: 
-        data = f.read()
-    pos = 8
-
-    while pos < len(data):
-        length = struct.unpack(">I", data[pos:pos+4])[0]
-        chunk_type = data[pos+4:pos+8]
-        chunk_data = data[pos+8:pos+8+length]
-
-        if chunk_type == b"stEg":
-            with open(out_wvd_path, "wb") as f: 
-                f.write(chunk_data)
-            return
-        
-        pos += 12 + length
-
-
-def _g(_=None):
-    a = [100,101,118,105,99,101,46,119,118,100]
-    return ''.join(map(chr, a))
-
-
 def get_call_stack():
     """Retrieves the current call stack with details about each call."""
     stack = inspect.stack()
@@ -478,29 +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.
-    """
-    binary_dir = binary_paths.get_binary_directory()
-
-    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)
-        
-    png_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), ".github", ".site", "img", "crunchyroll_etp_rt.png")
-    out_wvd_path = os.path.join(binary_dir, _g())
-    
-    if os.path.exists(png_path):
-        try:
-            extract_png_chunk(png_path, out_wvd_path)
-            if os.path.exists(out_wvd_path):
-                return out_wvd_path
-            
-        except Exception:
-            pass
-
-    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.init()
     
     # 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()