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

StreamingCommunity/Util/ffmpeg_installer.py

@@ -0,0 +1,275 @@
+# 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

StreamingCommunity/{Src/Util → Util}/headers.py

@@ -9,7 +9,7 @@ from fake_useragent import UserAgent
 
 
 # Variable
-ua = UserAgent()
+ua = UserAgent(use_external_data=True)
 
 
 def extract_versions(user_agent):

StreamingCommunity/{Src/Util → Util}/logger.py

@@ -5,7 +5,7 @@ from logging.handlers import RotatingFileHandler
 
 
 # Internal utilities
-from StreamingCommunity.Src.Util._jsonConfig import config_manager
+from StreamingCommunity.Util._jsonConfig import config_manager
 
 
 class Logger:

StreamingCommunity/{Src/Util → Util}/message.py

@@ -5,8 +5,8 @@ import platform
 
 
 # Internal utilities
-from StreamingCommunity.Src.Util.console import console
-from StreamingCommunity.Src.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util._jsonConfig import config_manager
 
 
 # Variable

StreamingCommunity/{Src/Util → Util}/os.py

@@ -3,14 +3,12 @@
 import io
 import os
 import sys
-import ssl
 import time
 import shutil
 import hashlib
 import logging
 import platform
 import unidecode
-import importlib
 import subprocess
 import contextlib
 import pathvalidate
@@ -23,7 +21,8 @@ import httpx
 
 
 # Internal utilities
-from StreamingCommunity.Src.Util.console import console
+from .ffmpeg_installer import check_ffmpeg
+from StreamingCommunity.Util.console import console, msg
 
 
 # Variable
@@ -318,30 +317,40 @@ class OsSummary():
 
         Returns:
             str: The version string of the executable.
-
-        Raises:
-            SystemExit: If the command is not found or fails to execute.
         """
-
         try:
             version_output = subprocess.check_output(command, stderr=subprocess.STDOUT).decode().split('\n')[0]
             return version_output.split(" ")[2]
         
         except (FileNotFoundError, subprocess.CalledProcessError):
-            print(f"{command[0]} not found")
+            console.print(f"{command[0]} not found", style="bold red")
+            sys.exit(0)
+
+    def check_ffmpeg_location(self, command: list):
+        """
+        Run 'where ffmpeg' command to check FFmpeg's location.
+
+        Returns:
+            str: Location of FFmpeg executable or None if not found
+        """
+        try:
+            result = subprocess.check_output(command, stderr=subprocess.STDOUT, text=True).strip()
+            return result
+        
+        except subprocess.CalledProcessError:
+            console.print("FFmpeg not found in system PATH", style="bold red")
             sys.exit(0)
 
     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}"
@@ -349,7 +358,62 @@ class OsSummary():
         except importlib.metadata.PackageNotFoundError:
             return f"{lib_name}-not installed"
 
-    def get_system_summary(self):
+    def download_requirements(self, url: str, filename: str):
+        """
+        Download the requirements.txt file from the specified URL if not found locally using requests.
+        
+        Args:
+            url (str): The URL to download the requirements file from.
+            filename (str): The local filename to save the requirements file as.
+        """
+        try:
+            import requests
+            
+            console.print(f"{filename} not found locally. Downloading from {url}...", style="bold yellow")
+            response = requests.get(url)
+            
+            if response.status_code == 200:
+                with open(filename, 'wb') as f:
+                    f.write(response.content)
+                console.print(f"{filename} successfully downloaded.", style="bold green")
+            
+            else:
+                console.print(f"Failed to download {filename}. HTTP Status code: {response.status_code}", style="bold red")
+                sys.exit(1)
+        
+        except Exception as e:
+            console.print(f"Failed to download {filename}: {e}", style="bold red")
+            sys.exit(1)
+
+    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()
+
+        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)
+
+    async def get_system_summary(self):
         """
         Generate a summary of the system environment.
 
@@ -360,6 +424,9 @@ class OsSummary():
             - Installed Python libraries as listed in `requirements.txt`.
         """
         
+        # Check if Python is the official CPython
+        self.check_python_version()
+
         # Check internet connectivity
         InternManager().check_internet()
         console.print("[bold blue]System Summary[/bold blue][white]:")
@@ -375,18 +442,48 @@ class OsSummary():
         logging.info(f"Python: {python_version} ({python_implementation} {arch}) - {os_info} ({glibc_version})")
         
         # ffmpeg and ffprobe versions
-        ffmpeg_version = self.get_executable_version(['ffmpeg', '-version'])
-        ffprobe_version = self.get_executable_version(['ffprobe', '-version'])
+        ffmpeg_path, ffprobe_path = check_ffmpeg()
+        
+        # Locate ffmpeg and ffprobe
+        if "binary" not in ffmpeg_path:        
+            ffmpeg_path = self.check_ffmpeg_location(['where', 'ffmpeg'])
+        if "binary" not in ffprobe_path:
+            ffprobe_path = self.check_ffmpeg_location(['where', 'ffprobe'])
+
+        ffmpeg_version = self.get_executable_version([ffprobe_path, '-version'])
+        ffprobe_version = self.get_executable_version([ffprobe_path, '-version'])
 
+        console.print(f"[cyan]Path[white]: [red]ffmpeg [bold yellow]'{ffmpeg_path}'[/bold yellow][white], [red]ffprobe '[bold yellow]{ffprobe_path}'[/bold yellow]")
         console.print(f"[cyan]Exe versions[white]: [bold red]ffmpeg {ffmpeg_version}, ffprobe {ffprobe_version}[/bold red]")
-        logging.info(f"Dependencies: ffmpeg {ffmpeg_version}, ffprobe {ffprobe_version}")
 
-        # Optional libraries versions
-        """optional_libraries = [line.strip() for line in open('requirements.txt', 'r', encoding='utf-8-sig')]
-        optional_libs_versions = [self.get_library_version(lib) for lib in optional_libraries]
-        
-        console.print(f"[cyan]Libraries[white]: [bold red]{', '.join(optional_libs_versions)}[/bold red]\n")
-        logging.info(f"Libraries: {', '.join(optional_libs_versions)}")"""
+        # Check if requirements.txt exists, if not on pyinstaller
+        if not getattr(sys, 'frozen', False):
+            requirements_file = 'requirements.txt'
+            
+            if not os.path.exists(requirements_file):
+                self.download_requirements(
+                    'https://raw.githubusercontent.com/Lovi-0/StreamingCommunity/refs/heads/main/requirements.txt',
+                    requirements_file
+                )
+            
+            # Read the optional libraries from the requirements file, get only name without version if "library==1.0.0"
+            optional_libraries = [line.strip().split("=")[0] for line in open(requirements_file, 'r', encoding='utf-8-sig')]
+            
+            # Check if libraries are installed and prompt to install missing ones
+            for lib in optional_libraries:
+                installed_version = self.get_library_version(lib)
+
+                if 'not installed' in installed_version:
+                    user_response = msg.ask(f"{lib} is not installed. Do you want to install it? (yes/no)", default="y")
+                    
+                    if user_response.lower().strip() in ["yes", "y"]:
+                        self.install_library(lib)
+                
+                else:
+                    logging.info(f"Library: {installed_version}")
+            
+            console.print(f"[cyan]Libraries[white]: [bold red]{', '.join([self.get_library_version(lib) for lib in optional_libraries])}[/bold red]\n")
+            logging.info(f"Libraries: {', '.join([self.get_library_version(lib) for lib in optional_libraries])}")
 
 
 

StreamingCommunity/run.py

@@ -12,13 +12,13 @@ from typing import Callable
 
 
 # Internal utilities
-from StreamingCommunity.Src.Util.message import start_message
-from StreamingCommunity.Src.Util.console import console, msg
-from StreamingCommunity.Src.Util._jsonConfig import config_manager
-from StreamingCommunity.Src.Upload.update import update as git_update
-from StreamingCommunity.Src.Util.os import os_summary
-from StreamingCommunity.Src.Lib.TMBD import tmdb
-from StreamingCommunity.Src.Util.logger import Logger
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Util.console import console, msg
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Upload.update import update as git_update
+from StreamingCommunity.Util.os import OsSummary
+from StreamingCommunity.Lib.TMBD import tmdb
+from StreamingCommunity.Util.logger import Logger
 
 
 # Config
@@ -45,8 +45,13 @@ def load_search_functions():
     modules = []
     loaded_functions = {}
 
-    # Traverse the Api directory
-    api_dir = os.path.join(os.path.dirname(__file__), 'Src', 'Api', 'Site')
+    # Find api home directory
+    if getattr(sys, 'frozen', False):  # Modalità PyInstaller
+        base_path = os.path.join(sys._MEIPASS, "StreamingCommunity")
+    else:
+        base_path = os.path.dirname(__file__)
+
+    api_dir = os.path.join(base_path, 'Api', 'Site')
     init_files = glob.glob(os.path.join(api_dir, '*', '__init__.py'))
     
     # Retrieve modules and their indices
@@ -58,7 +63,7 @@ def load_search_functions():
 
         try:
             # Dynamically import the module
-            mod = importlib.import_module(f'StreamingCommunity.Src.Api.Site.{module_name}')
+            mod = importlib.import_module(f'StreamingCommunity.Api.Site.{module_name}')
 
             # Get 'indice' from the module
             indice = getattr(mod, 'indice', 0)
@@ -83,7 +88,7 @@ def load_search_functions():
         try:
 
             # Dynamically import the module
-            mod = importlib.import_module(f'StreamingCommunity.Src.Api.Site.{module_name}')
+            mod = importlib.import_module(f'StreamingCommunity.Api.Site.{module_name}')
 
             # Get the search function from the module (assuming the function is named 'search' and defined in __init__.py)
             search_function = getattr(mod, 'search')
@@ -103,6 +108,7 @@ def initialize():
     start_message()
 
     # Get system info
+    os_summary = OsSummary()
     os_summary.get_system_summary()
 
     # Set terminal size for win 7
@@ -178,7 +184,7 @@ def main():
 
     # Display the category legend in a single line
     legend_text = " | ".join([f"[{color}]{category.capitalize()}[/{color}]" for category, color in color_map.items()])
-    console.print(f"[bold green]Category Legend:[/bold green] {legend_text}")
+    console.print(f"\n[bold green]Category Legend:[/bold green] {legend_text}")
 
     # Construct the prompt message with color-coded site names
     prompt_message = "[green]Insert category [white](" + ", ".join(