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

StreamingCommunity/Util/{bento4_installer.py → installer/bento4_install.py}

@@ -1,10 +1,11 @@
 # 18.07.25
 
 import os
-import platform
-import logging
 import shutil
 import zipfile
+import logging
+import subprocess
+from typing import Optional
 
 
 # External library
@@ -13,12 +14,15 @@ 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()
 
 BENTO4_CONFIGURATION = {
     'windows': {
-        'base_dir': lambda home: os.path.join(os.path.splitdrive(home)[0] + os.sep, 'binary'),
         'download_url': 'https://www.bok.net/Bento4/binaries/Bento4-SDK-{version}.{platform}.zip',
         'versions': {
             'x64': 'x86_64-microsoft-win32',
@@ -27,7 +31,6 @@ BENTO4_CONFIGURATION = {
         'executables': ['mp4decrypt.exe']
     },
     'darwin': {
-        'base_dir': lambda home: os.path.join(home, 'Applications', 'binary'),
         'download_url': 'https://www.bok.net/Bento4/binaries/Bento4-SDK-{version}.{platform}.zip',
         'versions': {
             'x64': 'universal-apple-macosx',
@@ -36,7 +39,6 @@ BENTO4_CONFIGURATION = {
         'executables': ['mp4decrypt']
     },
     'linux': {
-        'base_dir': lambda home: os.path.join(home, '.local', 'bin', 'binary'),
         'download_url': 'https://www.bok.net/Bento4/binaries/Bento4-SDK-{version}.{platform}.zip',
         'versions': {
             'x64': 'x86_64-unknown-linux',
@@ -50,26 +52,11 @@ BENTO4_CONFIGURATION = {
 
 class Bento4Downloader:
     def __init__(self):
-        self.os_name = platform.system().lower()
-        self.arch = self._detect_arch()
-        self.home_dir = os.path.expanduser('~')
-        self.base_dir = BENTO4_CONFIGURATION[self.os_name]['base_dir'](self.home_dir)
+        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()
         self.version = "1-6-0-641"  # Latest stable version as of Nov 2023
-        os.makedirs(self.base_dir, exist_ok=True)
-
-    def _detect_arch(self) -> str:
-        machine = platform.machine().lower()
-        arch_map = {
-            'amd64': 'x64', 
-            'x86_64': 'x64',
-            'x64': 'x64',
-            'arm64': 'arm64',
-            'aarch64': 'arm64',
-            'x86': 'x86',
-            'i386': 'x86',
-            'i686': 'x86'
-        }
-        return arch_map.get(machine, machine)
 
     def _download_file(self, url: str, destination: str) -> bool:
         try:
@@ -150,7 +137,6 @@ class Bento4Downloader:
                 os.remove(zip_path)
                 
                 if extracted_files:
-                    console.print("[bold green]Bento4 successfully installed[/]")
                     return extracted_files
                     
             raise Exception("Failed to install Bento4")
@@ -160,32 +146,58 @@ class Bento4Downloader:
             console.print(f"[bold red]Error downloading Bento4: {str(e)}[/]")
             return []
 
-def check_mp4decrypt() -> str:
-    """Check for mp4decrypt in the system and download if not found."""
+
+def check_mp4decrypt() -> Optional[str]:
+    """
+    Check for mp4decrypt in the system and download if not found.
+    Order: system PATH (where/which) -> binary directory -> download
+    
+    Returns:
+        Optional[str]: Path to mp4decrypt executable or None if not found/downloaded
+    """
     try:
-        # First check if mp4decrypt is in PATH
-        mp4decrypt = "mp4decrypt.exe" if platform.system().lower() == "windows" else "mp4decrypt"
-        mp4decrypt_path = shutil.which(mp4decrypt)
+        system_platform = binary_paths.system
         
-        if mp4decrypt_path:
-            return mp4decrypt_path
-
-        # If not found, check in binary directory
-        downloader = Bento4Downloader()
-        base_dir = downloader.base_dir
-        local_path = os.path.join(base_dir, mp4decrypt)
+        # STEP 1: Check system PATH
+        console.print("[cyan]Checking for mp4decrypt in system PATH...[/]")
+        mp4decrypt_name = "mp4decrypt.exe" if system_platform == "windows" else "mp4decrypt"
+        mp4decrypt_path = None
         
-        if os.path.exists(local_path):
+        if system_platform == 'windows':
+            try:
+                mp4decrypt_path = subprocess.check_output(
+                    ['where', mp4decrypt_name], stderr=subprocess.DEVNULL, text=True
+                ).strip().split('\n')[0]
+                
+                if mp4decrypt_path:
+                    logging.info("mp4decrypt found in Windows system PATH")
+                    return mp4decrypt_path
+                    
+            except subprocess.CalledProcessError:
+                logging.info("mp4decrypt not found in Windows system PATH")
+        
+        else:
+            mp4decrypt_path = shutil.which(mp4decrypt_name)
+            
+            if mp4decrypt_path:
+                logging.info("mp4decrypt found in system PATH")
+                return mp4decrypt_path
+
+        # STEP 2: Check in binary directory
+        console.print("[cyan]Checking for mp4decrypt in binary directory...[/]")
+        binary_dir = binary_paths.get_binary_directory()
+        local_path = os.path.join(binary_dir, mp4decrypt_name)
+        
+        if os.path.exists(local_path) and os.access(local_path, os.X_OK):
+            logging.info("mp4decrypt found in binary directory")
             return local_path
 
-        # Download if not found
+        # STEP 3: Download if not found
+        console.print("[cyan]mp4decrypt not found. Downloading...[/]")
+        downloader = Bento4Downloader()
         extracted_files = downloader.download()
         return extracted_files[0] if extracted_files else None
 
     except Exception as e:
         logging.error(f"Error checking or downloading mp4decrypt: {e}")
-        return None
-    
-    except Exception as e:
-        logging.error(f"Error checking or downloading mp4decrypt: {e}")
-        return None
+        return None

StreamingCommunity/Util/installer/binary_paths.py

@@ -0,0 +1,83 @@
+# 19.09.25
+
+import os
+import platform
+
+
+class BinaryPaths:
+    def __init__(self):
+        self.system = self._detect_system()
+        self.arch = self._detect_arch()
+        self.home_dir = os.path.expanduser('~')
+    
+    def _detect_system(self) -> str:
+        """
+        Detect and normalize the operating system name.
+        
+        Returns:
+            str: Normalized operating system name ('windows', 'darwin', or 'linux')
+        
+        Raises:
+            ValueError: If the operating system is not supported
+        """
+        system = platform.system().lower()
+        supported_systems = ['windows', 'darwin', 'linux']
+        
+        if system not in supported_systems:
+            raise ValueError(f"Unsupported operating system: {system}. Supported: {supported_systems}")
+        
+        return system
+    
+    def _detect_arch(self) -> str:
+        """
+        Detect and normalize the system architecture.
+        
+        Returns:
+            str: Normalized architecture name
+        """
+        machine = platform.machine().lower()
+        arch_map = {
+            'amd64': 'x64', 
+            'x86_64': 'x64',
+            'x64': 'x64',
+            'arm64': 'arm64',
+            'aarch64': 'arm64',
+            'armv7l': 'arm',
+            'i386': 'ia32',
+            'i686': 'ia32',
+            'x86': 'x86'
+        }
+        return arch_map.get(machine, machine)
+    
+    def get_binary_directory(self) -> str:
+        """
+        Get the binary directory path based on the operating system.
+        
+        Returns:
+            str: Path to the binary directory
+        """
+        if self.system == 'windows':
+            return os.path.join(os.path.splitdrive(self.home_dir)[0] + os.path.sep, 'binary')
+        
+        elif self.system == 'darwin':
+            return os.path.join(self.home_dir, 'Applications', 'binary')
+        
+        else:  # linux
+            return os.path.join(self.home_dir, '.local', 'bin', 'binary')
+    
+    def ensure_binary_directory(self, mode: int = 0o755) -> str:
+        """
+        Create the binary directory if it doesn't exist and return its path.
+        
+        Args:
+            mode (int, optional): Directory permissions. Defaults to 0o755.
+        
+        Returns:
+            str: Path to the binary directory
+        """
+        binary_dir = self.get_binary_directory()
+        os.makedirs(binary_dir, mode=mode, exist_ok=True)
+        return binary_dir
+
+
+binary_paths = BinaryPaths()

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