StreamingCommunity 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '2.3.0'
+__version__ = '2.4.0'
 __author__ = 'Lovi-0'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2024'

StreamingCommunity/Util/_jsonConfig.py

@@ -1,6 +1,7 @@
 # 29.01.24
 
 import os
+import sys
 import json
 import httpx
 import logging
@@ -22,34 +23,57 @@ class ConfigManager:
         """Read the configuration file."""
         try:
             logging.info(f"Reading file: {self.file_path}")
-            
-            # Check if file exist
+
+            # Check if file exists
             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
+
+            # Download config.json if it doesn't exist locally
             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}")
-        
+                self.download_requirements(
+                    'https://raw.githubusercontent.com/Lovi-0/StreamingCommunity/refs/heads/main/config.json',
+                    self.file_path
+                )
+
+                # Load the downloaded config.json into the config attribute
+                with open(self.file_path, 'r') as f:
+                    self.config = json.load(f)
+                logging.info("Configuration file downloaded and saved.")
+
+            logging.info("Configuration file processed successfully.")
+
         except Exception as e:
             logging.error(f"Error reading configuration file: {e}")
 
+    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
+            
+            logging.info(f"{filename} not found locally. Downloading from {url}...")
+            response = requests.get(url)
+            
+            if response.status_code == 200:
+                with open(filename, 'wb') as f:
+                    f.write(response.content)
+
+            else:
+                logging.error(f"Failed to download {filename}. HTTP Status code: {response.status_code}")
+                sys.exit(0)
+        
+        except Exception as e:
+            logging.error(f"Failed to download {filename}: {e}")
+            sys.exit(0)
+
     def read_key(self, section: str, key: str, data_type: type = str) -> Any:
         """Read a key from the configuration file.
 

StreamingCommunity/Util/ffmpeg_installer.py

@@ -19,6 +19,8 @@ from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeRe
 
 # Variable
 console = Console()
+
+# https://github.com/eugeneware/ffmpeg-static/releases
 FFMPEG_CONFIGURATION = {
     'windows': {
         'base_dir': lambda home: os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary'),
@@ -28,13 +30,13 @@ FFMPEG_CONFIGURATION = {
     },
     'darwin': {
         'base_dir': lambda home: os.path.join(home, 'Applications', 'binary'),
-        'download_url': 'https://evermeet.cx/ffmpeg/ffmpeg-{version}.zip',
+        'download_url': 'https://github.com/eugeneware/ffmpeg-static/releases/download/b{version}/ffmpeg-macOS-{arch}.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',
+        'download_url': 'https://github.com/eugeneware/ffmpeg-static/releases/download/b{version}/ffmpeg-linux-{arch}.tar.xz',
         'file_extension': '.tar.xz',
         'executables': ['ffmpeg', 'ffprobe', 'ffplay']
     }
@@ -150,19 +152,26 @@ class FFMPEGDownloader:
 
     def _get_latest_version(self) -> Optional[str]:
         """
-        Get the latest FFmpeg version from the official website.
+        Get the latest FFmpeg version from the GitHub releases page.
 
         Returns:
-            Optional[str]: The latest version string, or None if retrieval fails
+            Optional[str]: The latest version string, or None if retrieval fails.
 
         Raises:
-            requests.exceptions.RequestException: If there are network-related errors
+            requests.exceptions.RequestException: If there are network-related errors.
         """
         try:
-            version_url = 'https://www.gyan.dev/ffmpeg/builds/release-version'
-            return requests.get(version_url).text.strip()
+            # Use GitHub API to fetch the latest release
+            response = requests.get(
+                'https://api.github.com/repos/eugeneware/ffmpeg-static/releases/latest'
+            )
+            response.raise_for_status()
+            latest_release = response.json()
+
+            # Extract the tag name or version from the release
+            return latest_release.get('tag_name')
         except Exception as e:
-            logging.error(f"Unable to get version: {e}")
+            logging.error(f"Unable to get version from GitHub: {e}")
             return None
 
     def _download_file(self, url: str, destination: str) -> bool:
@@ -324,14 +333,22 @@ def check_ffmpeg() -> Tuple[Optional[str], Optional[str], Optional[str]]:
         # Windows detection
         elif system_platform == 'windows':
             try:
-                ffmpeg_path = subprocess.check_output(['where', 'ffmpeg'], text=True).strip().split('\n')[0]
-                ffprobe_path = subprocess.check_output(['where', 'ffprobe'], text=True).strip().split('\n')[0]
-                ffplay_path = subprocess.check_output(['where', 'ffplay'], text=True).strip().split('\n')[0]
+                ffmpeg_path = subprocess.check_output(
+                    ['where', 'ffmpeg'], stderr=subprocess.DEVNULL, text=True
+                ).strip().split('\n')[0]
                 
-                if ffmpeg_path and ffprobe_path:
-                    return ffmpeg_path, ffprobe_path, ffplay_path
+                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:
-                pass
+                logging.warning("One or more FFmpeg binaries were not found with command where")
 
         # Linux detection
         else:

StreamingCommunity/Util/headers.py

@@ -1,7 +1,9 @@
 # 4.04.24
 
 import re
+import sys
 import random
+from importlib.metadata import version, PackageNotFoundError
 
 
 # External library
@@ -9,7 +11,18 @@ from fake_useragent import UserAgent
 
 
 # Variable
-ua = UserAgent(use_external_data=True)
+try:
+    ua_version = version('fake-useragent')
+except PackageNotFoundError:
+    ua_version = None
+
+if not getattr(sys, 'frozen', False):
+    if ua_version == '1.1.3':
+        ua = UserAgent(use_external_data=True)
+    else:
+        ua = UserAgent()
+else:
+    ua = UserAgent()
 
 
 def extract_versions(user_agent):
@@ -144,4 +157,4 @@ def get_headers() -> str:
     """
     
     # Get a random user agent string from the user agent rotator
-    return str(ua.chrome)
+    return str(ua.chrome)

StreamingCommunity/Util/logger.py

@@ -1,5 +1,6 @@
 # 26.03.24
 
+import os
 import logging
 from logging.handlers import RotatingFileHandler
 
@@ -26,6 +27,7 @@ class Logger:
 
             # Configure file logging if debug mode and logging to file are both enabled
             if self.log_to_file:
+                self.remove_existing_log_file()
                 self.configure_file_logging()
         else:
 
@@ -51,3 +53,10 @@ class Logger:
         formatter = logging.Formatter('[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
         file_handler.setFormatter(formatter)
         logging.getLogger('').addHandler(file_handler)
+
+    def remove_existing_log_file(self):
+        """
+        Remove the log file if it already exists.
+        """
+        if os.path.exists(self.log_file):
+            os.remove(self.log_file)

StreamingCommunity/Util/os.py

@@ -8,16 +8,16 @@ import shutil
 import hashlib
 import logging
 import platform
-import unidecode
 import subprocess
 import contextlib
-import pathvalidate
 import urllib.request
 import importlib.metadata
 
 
 # External library
 import httpx
+from unidecode import unidecode
+from pathvalidate import sanitize_filename, sanitize_filepath
 
 
 # Internal utilities
@@ -25,172 +25,133 @@ from .ffmpeg_installer import check_ffmpeg
 from StreamingCommunity.Util.console import console, msg
 
 
-# Variable
-OS_CONFIGURATIONS = {
-    'windows': {
-        'max_length': 255,
-        'invalid_chars': '<>:"/\\|?*',
-        'reserved_names': [
-            "CON", "PRN", "AUX", "NUL",
-            "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
-            "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"
-        ],
-        'max_path': 255
-    },
-    'darwin': {
-        'max_length': 4096,
-        'invalid_chars': '/:',
-        'reserved_names': [],
-        'hidden_file_restriction': True
-    },
-    'linux': {
-        'max_length': 4096,
-        'invalid_chars': '/\0',
-        'reserved_names': []
-    }
-}
-
-
 
 class OsManager:
     def __init__(self):
         self.system = self._detect_system()
-        self.config = OS_CONFIGURATIONS.get(self.system, {})
+        self.max_length = self._get_max_length()
 
     def _detect_system(self) -> str:
         """Detect and normalize operating system name."""
         system = platform.system().lower()
+        if system not in ['windows', 'darwin', 'linux']:
+            raise ValueError(f"Unsupported operating system: {system}")
+        return system
 
-        if system in OS_CONFIGURATIONS:
-            return system
-        
-        raise ValueError(f"Unsupported operating system: {system}")
+    def _get_max_length(self) -> int:
+        """Get max filename length based on OS."""
+        return 255 if self.system == 'windows' else 4096
 
     def _normalize_windows_path(self, path: str) -> str:
-        """
-        Normalize Windows paths to handle drive letters correctly.
-        
-        Args:
-            path (str): Original path that might contain a drive letter.
-            
-        Returns:
-            str: Properly normalized absolute path.
-        """
-        if self.system != 'windows':
+        """Normalize Windows paths."""
+        if not path or self.system != 'windows':
             return path
-            
-        # Check if path starts with a drive letter
+
+        # Preserve network paths (UNC and IP-based)
+        if path.startswith('\\\\') or path.startswith('//'):
+            return path.replace('/', '\\')
+
+        # Handle drive letters
         if len(path) >= 2 and path[1] == ':':
             drive = path[0:2]
-            rest = path[2:].lstrip(os.sep)
-            # Ensure proper absolute path format
-            return os.path.join(drive + os.sep, rest)
-        return path
-    
-    def _process_filename(self, filename: str) -> str:
-        """
-        Comprehensively process filename with cross-platform considerations.
-        
-        Args:
-            filename (str): Original filename.
-        
-        Returns:
-            str: Processed filename.
-        """
-        name, ext = os.path.splitext(filename)
-        
-        # Handle length restrictions
-        if len(name) > self.config['max_length']:
-            name = self._truncate_filename(name)
-        
-        # Reconstruct filename
-        processed_filename = name + ext
-        
-        return processed_filename
+            rest = path[2:].replace('/', '\\').lstrip('\\')
+            return f"{drive}\\{rest}"
 
-    def _truncate_filename(self, name: str) -> str:
-        """
-        Truncate filename based on OS-specific rules.
-        
-        Args:
-            name (str): Original filename.
+        return path.replace('/', '\\')
+
+    def _normalize_mac_path(self, path: str) -> str:
+        """Normalize macOS paths."""
+        if not path or self.system != 'darwin':
+            return path
+
+        # Convert Windows separators to Unix
+        normalized = path.replace('\\', '/')
         
-        Returns:
-            str: Truncated filename.
-        """
-        logging.info("_truncate_filename: ", name)
+        # Ensure absolute paths start with /
+        if normalized.startswith('/'):
+            return os.path.normpath(normalized)
 
-        if self.system == 'windows':
-            return name[:self.config['max_length'] - 3] + '___'
-        elif self.system == 'darwin':
-            return name[:self.config['max_length']]
-        elif self.system == 'linux':
-            return name[:self.config['max_length'] - 2] + '___'
+        return normalized
 
     def get_sanitize_file(self, filename: str) -> str:
-        """
-        Sanitize filename using pathvalidate with unidecode.
-        
-        Args:
-            filename (str): Original filename.
-        
-        Returns:
-            str: Sanitized filename.
-        """
+        """Sanitize filename."""
+        if not filename:
+            return filename
 
-        # Decode unicode characters and sanitize
-        decoded_filename = unidecode.unidecode(filename)
-        sanitized_filename = pathvalidate.sanitize_filename(decoded_filename)
+        # Decode and sanitize
+        decoded = unidecode(filename)
+        sanitized = sanitize_filename(decoded)
         
-        # Truncate if necessary based on OS configuration
-        name, ext = os.path.splitext(sanitized_filename)
-        if len(name) > self.config['max_length']:
-            name = self._truncate_filename(name)
+        # Split name and extension
+        name, ext = os.path.splitext(sanitized)
         
-        result = name + ext
-        return result
-
-    def get_sanitize_path(self, path: str) -> str:
-        """
-        Sanitize folder path using pathvalidate with unidecode.
+        # Calculate available length for name considering the '...' and extension
+        max_name_length = self.max_length - len('...') - len(ext)
         
-        Args:
-            path (str): Original folder path.
+        # Truncate name if it exceeds the max name length
+        if len(name) > max_name_length:
+            name = name[:max_name_length] + '...'
         
-        Returns:
-            str: Sanitized folder path.
-        """
+        # Ensure the final file name includes the extension
+        return name + ext
 
-        # Normalize path for Windows drive letters first
-        path = self._normalize_windows_path(path)
+    def get_sanitize_path(self, path: str) -> str:
+        """Sanitize complete path."""
+        if not path:
+            return path
 
-        # Decode unicode characters and sanitize
-        decoded_path = unidecode.unidecode(path)
-        sanitized_path = pathvalidate.sanitize_filepath(decoded_path)
-        
-        # Split path and process each component
-        path_components = os.path.normpath(sanitized_path).split(os.sep)
+        # Decode unicode characters
+        decoded = unidecode(path)
         
-        # Handle Windows drive letter specially
-        if self.system == 'windows' and len(path_components[0]) == 2 and path_components[0][1] == ':':
-            drive = path_components.pop(0)
-            processed_components = [drive + os.sep]
+        # Basic path sanitization
+        sanitized = sanitize_filepath(decoded)
 
+        if self.system == 'windows':
+            # Handle network paths (UNC or IP-based)
+            if path.startswith('\\\\') or path.startswith('//'):
+                parts = path.replace('/', '\\').split('\\')
+                # Keep server/IP and share name as is
+                sanitized_parts = parts[:4]
+                # Sanitize remaining parts
+                if len(parts) > 4:
+                    sanitized_parts.extend([
+                        self.get_sanitize_file(part)
+                        for part in parts[4:]
+                        if part
+                    ])
+                return '\\'.join(sanitized_parts)
+            
+            # Handle drive letters
+            elif len(path) >= 2 and path[1] == ':':
+                drive = path[:2]
+                rest = path[2:].lstrip('\\').lstrip('/')
+                path_parts = [drive] + [
+                    self.get_sanitize_file(part)
+                    for part in rest.replace('/', '\\').split('\\')
+                    if part
+                ]
+                return '\\'.join(path_parts)
+                
+            # Regular path
+            else:
+                parts = path.replace('/', '\\').split('\\')
+                return '\\'.join(p for p in parts if p)
         else:
-            processed_components = []
+            # Handle Unix-like paths (Linux and macOS)
+            is_absolute = path.startswith('/')
+            parts = path.replace('\\', '/').split('/')
+            sanitized_parts = [
+                self.get_sanitize_file(part)
+                for part in parts
+                if part
+            ]
+            
+            result = '/'.join(sanitized_parts)
+            if is_absolute:
+                result = '/' + result
+                
+            return result
         
-        # Process remaining components
-        for component in path_components:
-            if component:  # Skip empty components
-                if len(component) > self.config['max_length']:
-                    component = self._truncate_filename(component)
-                    
-                processed_components.append(component)
-
-        # Join with proper separator and normalize
-        result = os.path.normpath(os.path.join(*processed_components))
-        return result
-
     def create_path(self, path: str, mode: int = 0o755) -> bool:
         """
         Create directory path with specified permissions.
@@ -272,6 +233,7 @@ class OsManager:
             logging.error(f"An error occurred while checking file existence: {e}")
             return False
 
+
 class InternManager():
 
     def format_file_size(self, size_bytes: float) -> str:

StreamingCommunity/Util/table.py

@@ -174,12 +174,12 @@ class TVShowManager:
                     
                 else:
                     choices = [str(i) for i in range(0, max_int_input)]
-                    choices.extend(["q", "", "back"])
+                    choices.extend(["q", "quit", "b", "back"])
 
                     key = Prompt.ask("[cyan]Insert media [red]index", choices=choices, show_choices=False)
                 last_command = key
 
-                if key.lower() == "q":
+                if key.lower() == "q" or key.lower() == "quit":
                     break
 
                 elif key == "":
@@ -188,7 +188,7 @@ class TVShowManager:
                     if self.slice_end > total_items:
                         self.slice_end = total_items
 
-                elif key.lower() == "back" and research_func:
+                elif (key.lower() == "b" or key.lower() == "back") and research_func:
                     self.run_back_command(research_func)
 
                 else:
@@ -205,19 +205,19 @@ class TVShowManager:
 
                 else:
                     choices = [str(i) for i in range(0, max_int_input)]
-                    choices.extend(["q", "", "back"])
+                    choices.extend(["q", "quit", "b", "back"])
 
                     key = Prompt.ask("[cyan]Insert media [red]index", choices=choices, show_choices=False)
                 last_command = key
 
-                if key.lower() == "q":
+                if key.lower() == "q" or key.lower() == "quit":
                     break
 
                 elif key == "":
                     self.slice_start = 0
                     self.slice_end = self.step
 
-                elif key.lower() == "back" and research_func:
+                elif (key.lower() == "b" or key.lower() == "back") and research_func:
                     self.run_back_command(research_func)
 
                 else: