StreamingCommunity 2.5.6__py3-none-any.whl → 2.5.8__py3-none-any.whl

StreamingCommunity/Util/_jsonConfig.py

@@ -4,17 +4,18 @@ import os
 import sys
 import json
 import logging
+from pathlib import Path
 from typing import Any, List
 
 
 class ConfigManager:
-    def __init__(self, file_path: str = 'config.json') -> None:
+    def __init__(self, file_name: str = 'config.json') -> None:
         """Initialize the ConfigManager.
 
         Parameters:
             - file_path (str, optional): The path to the configuration file. Default is 'config.json'.
         """
-        self.file_path = file_path
+        self.file_path = Path(__file__).parent.parent.parent / file_name
         self.config = {}
         self.cache = {}
 
@@ -50,17 +51,17 @@ class ConfigManager:
     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)
@@ -68,7 +69,7 @@ class ConfigManager:
             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)
@@ -89,15 +90,15 @@ class ConfigManager:
 
         if cache_key in self.cache:
             return self.cache[cache_key]
-        
+
         if section in self.config and key in self.config[section]:
             value = self.config[section][key]
         else:
             raise ValueError(f"Key '{key}' not found in section '{section}'")
-        
+
         value = self._convert_to_data_type(value, data_type)
         self.cache[cache_key] = value
-        
+
         return value
 
     def _convert_to_data_type(self, value: str, data_type: type) -> Any:
@@ -120,7 +121,7 @@ class ConfigManager:
             return None
         else:
             return value
-        
+
     def get(self, section: str, key: str) -> Any:
         """Read a value from the configuration file.
 
@@ -144,7 +145,7 @@ class ConfigManager:
             int: The integer value.
         """
         return self.read_key(section, key, int)
-    
+
     def get_float(self, section: str, key: str) -> int:
         """Read an float value from the configuration file.
 
@@ -180,7 +181,7 @@ class ConfigManager:
             list: The list value.
         """
         return self.read_key(section, key, list)
-    
+
     def get_dict(self, section: str, key: str) -> dict:
         """Read a dictionary value from the configuration file.
 
@@ -220,7 +221,7 @@ class ConfigManager:
                 json.dump(self.config, f, indent=4)
         except Exception as e:
             print(f"Error writing configuration file: {e}")
-            
+
 
 # Initialize
 config_manager = ConfigManager()

StreamingCommunity/Util/ffmpeg_installer.py

@@ -4,8 +4,6 @@ import os
 import glob
 import gzip
 import shutil
-import tarfile
-import zipfile
 import logging
 import platform
 import subprocess
@@ -179,64 +177,59 @@ class FFMPEGDownloader:
                     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], Optional[str]]:
+    def _extract_file(self, gz_path: str, final_path: str) -> bool:
         """
-        Extract FFmpeg binaries from the downloaded archive and copy them to the base directory.
+        Extract a gzipped file and set proper permissions.
 
         Parameters:
-            archive_path (str): Path to the downloaded archive file
+            gz_path (str): Path to the gzipped file
+            final_path (str): Path where the extracted file should be saved
 
         Returns:
-            Tuple[Optional[str], Optional[str], Optional[str]]: Paths to the extracted ffmpeg, 
-            ffprobe, and ffplay executables. Returns None for each executable that couldn't be extracted.
+            bool: True if extraction was successful, False otherwise
         """
         try:
-            extraction_path = os.path.join(self.base_dir, 'temp_extract')
-            os.makedirs(extraction_path, exist_ok=True)
-
-            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'):
-                with tarfile.open(archive_path) as tar_ref:
-                    tar_ref.extractall(extraction_path)
-            elif archive_path.endswith('.gz'):
-                file_name = os.path.basename(archive_path)[:-3]  # Remove extension .gz
-                output_path = os.path.join(extraction_path, file_name)
-                with gzip.open(archive_path, 'rb') as f_in, open(output_path, 'wb') as f_out:
+            logging.info(f"Attempting to extract {gz_path} to {final_path}")
+            
+            # Check if source file exists and is readable
+            if not os.path.exists(gz_path):
+                logging.error(f"Source file {gz_path} does not exist")
+                return False
+                
+            if not os.access(gz_path, os.R_OK):
+                logging.error(f"Source file {gz_path} is not readable")
+                return False
+
+            # Extract the file
+            with gzip.open(gz_path, 'rb') as f_in:
+                # Test if the gzip file is valid
+                try:
+                    f_in.read(1)
+                    f_in.seek(0)
+                except Exception as e:
+                    logging.error(f"Invalid gzip file {gz_path}: {e}")
+                    return False
+
+                # Extract the file
+                with open(final_path, 'wb') as f_out:
                     shutil.copyfileobj(f_in, f_out)
-            else:
-                raise ValueError("Unsupported archive format")
-
-            config = FFMPEG_CONFIGURATION[self.os_name]
-            executables = config['executables']
-            found_paths = []
-
-            for executable in executables:
-                exe_paths = glob.glob(os.path.join(extraction_path, '**', executable), recursive=True)
-                if exe_paths:
-                    dest_path = os.path.join(self.base_dir, executable)
-                    shutil.copy2(exe_paths[0], dest_path)
-                    
-                    if self.os_name != 'windows':
-                        os.chmod(dest_path, 0o755)
-                    
-                    found_paths.append(dest_path)
-                else:
-                    found_paths.append(None)
 
-            shutil.rmtree(extraction_path, ignore_errors=True)
-            os.remove(archive_path)
-
-            return tuple(found_paths) if len(found_paths) == 3 else (None, None, None)
+            # Set executable permissions
+            os.chmod(final_path, 0o755)
+            logging.info(f"Successfully extracted {gz_path} to {final_path}")
+            
+            # Remove the gzip file
+            os.remove(gz_path)
+            return True
 
         except Exception as e:
-            logging.error(f"Extraction/copy error: {e}")
-            return None, None, None
+            logging.error(f"Extraction error for {gz_path}: {e}")
+            return False
 
     def download(self) -> Tuple[Optional[str], Optional[str], Optional[str]]:
         """
@@ -244,30 +237,43 @@ class FFMPEGDownloader:
 
         Returns:
             Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay executables.
-            Returns None for each executable that couldn't be downloaded or set up.
         """
         config = FFMPEG_CONFIGURATION[self.os_name]
         executables = [exe.format(arch=self.arch) for exe in config['executables']]
-        
+        successful_extractions = []
+
         for executable in executables:
-            download_url = f"https://github.com/eugeneware/ffmpeg-static/releases/latest/download/{executable}.gz"
-            download_path = os.path.join(self.base_dir, f"{executable}.gz")
-            final_path = os.path.join(self.base_dir, executable)
-            
-            console.print(f"[bold blue]Downloading {executable} from GitHub[/]")
-            if not self._download_file(download_url, download_path):
-                return None, None, None
-            
-            with gzip.open(download_path, 'rb') as f_in, open(final_path, 'wb') as f_out:
-                shutil.copyfileobj(f_in, f_out)
-            
-            os.chmod(final_path, 0o755)
-            os.remove(download_path)
-        
+            try:
+                download_url = f"https://github.com/eugeneware/ffmpeg-static/releases/latest/download/{executable}.gz"
+                download_path = os.path.join(self.base_dir, f"{executable}.gz")
+                final_path = os.path.join(self.base_dir, executable)
+                
+                # Log the current operation
+                logging.info(f"Processing {executable}")
+                console.print(f"[bold blue]Downloading {executable} from GitHub[/]")
+                
+                # Download the file
+                if not self._download_file(download_url, download_path):
+                    console.print(f"[bold red]Failed to download {executable}[/]")
+                    continue
+
+                # 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}[/]")
+
+            except Exception as e:
+                logging.error(f"Error processing {executable}: {e}")
+                console.print(f"[bold red]Error processing {executable}: {str(e)}[/]")
+                continue
+
+        # Return the results based on successful extractions
         return (
-            os.path.join(self.base_dir, executables[0]),
-            os.path.join(self.base_dir, executables[1]),
-            None
+            successful_extractions[0] if len(successful_extractions) > 0 else None,
+            successful_extractions[1] if len(successful_extractions) > 1 else None,
+            None  # ffplay is not included in the current implementation
         )
 
 def check_ffmpeg() -> Tuple[Optional[str], Optional[str], Optional[str]]:

StreamingCommunity/Util/headers.py

@@ -1,104 +1,24 @@
 # 4.04.24
 
-import re
-import sys
 import random
-from importlib.metadata import version, PackageNotFoundError
 
 
 # External library
-from fake_useragent import UserAgent
+import ua_generator
 
 
-# Variable
-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):
-    """
-    Extract browser versions from the user agent.
-
-    Parameters:
-        user_agent (str): User agent of the browser.
-
-    Returns:
-        list: List of browser versions.
-    """
-
-    # Patterns to extract versions from various user agents
-    patterns = {
-        'chrome': re.compile(r'Chrome/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
-        'firefox': re.compile(r'Firefox/(\d+)\.?(\d+)?\.?(\d+)?'),
-        'safari': re.compile(r'Version/(\d+)\.(\d+)\.(\d+) Safari/(\d+)\.(\d+)\.(\d+)'),
-        'edge': re.compile(r'Edg/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
-        'edgios': re.compile(r'EdgiOS/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
-        'crios': re.compile(r'CriOS/(\d+)\.(\d+)\.(\d+)\.(\d+)'),
-    }
-
-    for key, pattern in patterns.items():
-        match = pattern.search(user_agent)
-        if match:
-            return [match.group(i+1) for i in range(match.lastindex)]
-
-    # Fallback values if specific versions are not found
-    return ['99', '0', '0', '0']
-
-def get_platform(user_agent):
+def get_headers() -> str:
     """
-    Determine the device platform from the user agent.
-
-    Parameters:
-        user_agent (str): User agent of the browser.
+    Generate a random user agent to use in HTTP requests.
 
     Returns:
-        str: Device platform.
-    """
-    if 'Windows' in user_agent:
-        return '"Windows"'
-    elif 'Mac OS X' in user_agent:
-        return '"macOS"'
-    elif 'Android' in user_agent:
-        return '"Android"'
-    elif 'iPhone' in user_agent or 'iPad' in user_agent:
-        return '"iOS"'
-    elif 'Linux' in user_agent:
-        return '"Linux"'
-    return '"Unknown"'
-
-def get_model(user_agent):
+        - str: A random user agent string.
     """
-    Determine the device model from the user agent.
+    
+    # Get a random user agent string from the user agent rotator
+    user_agent =  ua_generator.generate().text
+    return user_agent
 
-    Parameters:
-        user_agent (str): User agent of the browser.
-
-    Returns:
-        str: Device model.
-    """
-    if 'iPhone' in user_agent:
-        return '"iPhone"'
-    elif 'iPad' in user_agent:
-        return '"iPad"'
-    elif 'Android' in user_agent:
-        return '"Android"'
-    elif 'Windows' in user_agent:
-        return '"PC"'
-    elif 'Mac OS X' in user_agent:
-        return '"Mac"'
-    elif 'Linux' in user_agent:
-        return '"Linux"'
-    return '"Unknown"'
 
 def random_headers(referer: str = None):
     """
@@ -107,26 +27,10 @@ def random_headers(referer: str = None):
     Returns:
         dict: Generated HTTP headers.
     """
-    user_agent = ua.random
-    versions = extract_versions(user_agent)
-    platform = get_platform(user_agent)
-    model = get_model(user_agent)
-    is_mobile = 'Mobi' in user_agent or 'Android' in user_agent
-
-    # Generate sec-ch-ua string based on the browser
-    if 'Chrome' in user_agent or 'CriOS' in user_agent:
-        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Chromium";v="{versions[0]}", "Google Chrome";v="{versions[0]}"'
-    elif 'Edg' in user_agent or 'EdgiOS' in user_agent:
-        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Chromium";v="{versions[0]}", "Microsoft Edge";v="{versions[0]}"'
-    elif 'Firefox' in user_agent:
-        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Firefox";v="{versions[0]}"'
-    elif 'Safari' in user_agent:
-        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}", "Safari";v="{versions[0]}"'
-    else:
-        sec_ch_ua = f'" Not;A Brand";v="{versions[0]}"'
+    ua = ua_generator.generate()
 
     headers = {
-        'User-Agent': user_agent,
+        'User-Agent': ua.text,
         'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
         'Accept-Language': random.choice(['en-US', 'en-GB', 'fr-FR', 'es-ES', 'de-DE']),
         'Accept-Encoding': 'gzip, deflate, br',
@@ -136,25 +40,10 @@ def random_headers(referer: str = None):
         'Sec-Fetch-Mode': 'navigate',
         'Sec-Fetch-Site': 'none',
         'Sec-Fetch-User': '?1',
-        'sec-ch-ua-mobile': '?1' if is_mobile else '?0',
-        'sec-ch-ua-platform': platform,
-        'sec-ch-ua': sec_ch_ua,
-        'sec-ch-ua-model': model
     }
 
     if referer:
         headers['Origin'] = referer
         headers['Referer'] = referer
     
-    return headers
-
-def get_headers() -> str:
-    """
-    Generate a random user agent to use in HTTP requests.
-
-    Returns:
-        - str: A random user agent string.
-    """
-    
-    # Get a random user agent string from the user agent rotator
-    return str(ua.chrome)
+    return headers