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

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

StreamingCommunity/Util/os.py

@@ -13,6 +13,7 @@ import subprocess
 import contextlib
 import urllib.request
 import importlib.metadata
+from pathlib import Path
 
 
 # External library
@@ -67,7 +68,7 @@ class OsManager:
 
         # Convert Windows separators to Unix
         normalized = path.replace('\\', '/')
-        
+
         # Ensure absolute paths start with /
         if normalized.startswith('/'):
             return os.path.normpath(normalized)
@@ -82,17 +83,17 @@ class OsManager:
         # Decode and sanitize
         decoded = unidecode(filename)
         sanitized = sanitize_filename(decoded)
-        
+
         # Split name and extension
         name, ext = os.path.splitext(sanitized)
-        
+
         # Calculate available length for name considering the '...' and extension
         max_name_length = self.max_length - len('...') - len(ext)
-        
+
         # Truncate name if it exceeds the max name length
         if len(name) > max_name_length:
             name = name[:max_name_length] + '...'
-        
+
         # Ensure the final file name includes the extension
         return name + ext
 
@@ -103,7 +104,7 @@ class OsManager:
 
         # Decode unicode characters
         decoded = unidecode(path)
-        
+
         # Basic path sanitization
         sanitized = sanitize_filepath(decoded)
 
@@ -121,7 +122,7 @@ class OsManager:
                         if part
                     ])
                 return '\\'.join(sanitized_parts)
-            
+
             # Handle drive letters
             elif len(path) >= 2 and path[1] == ':':
                 drive = path[:2]
@@ -132,7 +133,7 @@ class OsManager:
                     if part
                 ]
                 return '\\'.join(path_parts)
-                
+
             # Regular path
             else:
                 parts = path.replace('/', '\\').split('\\')
@@ -146,21 +147,21 @@ class OsManager:
                 for part in parts
                 if part
             ]
-            
+
             result = '/'.join(sanitized_parts)
             if is_absolute:
                 result = '/' + result
-                
+
             return result
-        
+
     def create_path(self, path: str, mode: int = 0o755) -> bool:
         """
         Create directory path with specified permissions.
-        
+
         Args:
             path (str): Path to create.
             mode (int, optional): Directory permissions. Defaults to 0o755.
-        
+
         Returns:
             bool: True if path created successfully, False otherwise.
         """
@@ -168,7 +169,7 @@ class OsManager:
             sanitized_path = self.get_sanitize_path(path)
             os.makedirs(sanitized_path, mode=mode, exist_ok=True)
             return True
-        
+
         except Exception as e:
             logging.error(f"Path creation error: {e}")
             return False
@@ -176,21 +177,21 @@ class OsManager:
     def remove_folder(self, folder_path: str) -> bool:
         """
         Safely remove a folder.
-        
+
         Args:
             folder_path (str): Path of directory to remove.
-        
+
         Returns:
             bool: Removal status.
         """
         try:
             shutil.rmtree(folder_path)
             return True
-        
+
         except OSError as e:
             logging.error(f"Folder removal error: {e}")
             return False
-    
+
     def remove_files_except_one(self, folder_path: str, keep_file: str) -> None:
         """
         Delete all files in a folder except for one specified file.
@@ -201,21 +202,27 @@ class OsManager:
         """
 
         try:
-            # List all files in the folder
-            files_in_folder = os.listdir(folder_path)
+            # First, try to make all files writable
+            for root, dirs, files in os.walk(self.temp_dir):
+                for dir_name in dirs:
+                    dir_path = os.path.join(root, dir_name)
+                    os.chmod(dir_path, 0o755)  # rwxr-xr-x
+                for file_name in files:
+                    file_path = os.path.join(root, file_name)
+                    os.chmod(file_path, 0o644)  # rw-r--r--
             
-            # Iterate over each file in the folder
-            for file_name in files_in_folder:
-                file_path = os.path.join(folder_path, file_name)
+            # Then remove the directory tree
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+            
+            # If directory still exists after rmtree, try force remove
+            if os.path.exists(self.temp_dir):
+                import subprocess
+                subprocess.run(['rm', '-rf', self.temp_dir], check=True)
                 
-                # Check if the file is not the one to keep and is a regular file
-                if file_name != keep_file and os.path.isfile(file_path):
-                    os.remove(file_path)  # Delete the file
-
         except Exception as e:
-            logging.error(f"An error occurred: {e}")
-            raise
-    
+            logging.error(f"Failed to cleanup temporary directory: {str(e)}")
+            pass
+
     def check_file(self, file_path: str) -> bool:
         """
         Check if a file exists at the given file path.
@@ -229,7 +236,7 @@ class OsManager:
         try:
             logging.info(f"Check if file exists: {file_path}")
             return os.path.exists(file_path)
-            
+
         except Exception as e:
             logging.error(f"An error occurred while checking file existence: {e}")
             return False
@@ -280,12 +287,12 @@ class InternManager():
     def check_internet():
         while True:
             try:
-                httpx.get("https://www.google.com", timeout=15)
+                httpx.get("https://www.google.com", timeout=5)
                 break
 
-            except urllib.error.URLError:
+            except Exception as e:
                 console.log("[bold red]Internet is not available. Waiting...[/bold red]")
-                time.sleep(5)
+                time.sleep(2)
 
 
 class OsSummary:
@@ -299,7 +306,7 @@ class OsSummary:
         """Get the binary directory based on OS."""
         system = platform.system().lower()
         home = os.path.expanduser('~')
-        
+
         if system == 'windows':
             return os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary')
         elif system == 'darwin':
@@ -315,41 +322,41 @@ class OsSummary:
         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 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)
@@ -357,7 +364,7 @@ class OsSummary:
             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)
@@ -373,7 +380,7 @@ class OsSummary:
             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)
@@ -400,7 +407,7 @@ class OsSummary:
         arch = platform.machine()
         os_info = platform.platform()
         glibc_version = 'glibc ' + '.'.join(map(str, platform.libc_ver()[1]))
-        
+
         console.print(f"[cyan]Python[white]: [bold red]{python_version} ({python_implementation} {arch}) - {os_info} ({glibc_version})[/bold red]")
         logging.info(f"Python: {python_version} ({python_implementation} {arch}) - {os_info} ({glibc_version})")
 
@@ -408,10 +415,10 @@ class OsSummary:
         binary_dir = self.get_binary_directory()
         system = platform.system().lower()
         arch = platform.machine().lower()
-        
+
         # Map architecture names
         arch_map = {
-            'amd64': 'x64', 
+            'amd64': 'x64',
             'x86_64': 'x64',
             'x64': 'x64',
             'arm64': 'arm64',
@@ -424,15 +431,15 @@ class OsSummary:
 
         # Check binary directory
         if os.path.exists(binary_dir):
-            
+
             # Search for any file containing 'ffmpeg' and the architecture
             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]
-                
+
                 # Set executable permissions if needed
                 if system != 'windows':
                     os.chmod(self.ffmpeg_path, 0o755)
@@ -451,15 +458,17 @@ class OsSummary:
         # Handle requirements.txt
         if not getattr(sys, 'frozen', False):
             requirements_file = 'requirements.txt'
-            
+
+            requirements_file = Path(__file__).parent.parent.parent / requirements_file
+
             if not os.path.exists(requirements_file):
                 self.download_requirements(
                     'https://raw.githubusercontent.com/Arrowar/StreamingCommunity/refs/heads/main/requirements.txt',
                     requirements_file
                 )
-            
+
             optional_libraries = [line.strip().split("=")[0] for line in open(requirements_file, 'r', encoding='utf-8-sig')]
-            
+
             for lib in optional_libraries:
                 installed_version = self.get_library_version(lib.split("<")[0])
                 if 'not installed' in installed_version:
@@ -468,7 +477,7 @@ class OsSummary:
                         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])}")
 
@@ -495,6 +504,6 @@ def compute_sha1_hash(input_string: str) -> str:
     """
     # Compute the SHA-1 hash
     hashed_string = hashlib.sha1(input_string.encode()).hexdigest()
-    
+
     # Return the hashed string
     return hashed_string