StreamingCommunity 2.6.1__py3-none-any.whl → 2.8.0__py3-none-any.whl

StreamingCommunity/Util/config_json.py

@@ -0,0 +1,435 @@
+# 29.01.24
+
+import os
+import sys
+import json
+import logging
+import requests
+from typing import Any, List
+
+
+# External library
+from rich.console import Console
+
+
+# Variable
+console = Console()
+download_site_data = True
+validate_github_config = True
+
+
+class ConfigManager:
+    def __init__(self, file_name: str = 'config.json') -> None:
+        """Initialize the ConfigManager.
+
+        Parameters:
+            - file_name (str, optional): The name of the configuration file. Default is 'config.json'.
+        """
+        if getattr(sys, 'frozen', False):
+            base_path = os.path.join(".")
+        else:
+            base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+            
+        self.file_path = os.path.join(base_path, file_name)
+        self.domains_path = os.path.join(base_path, 'domains.json')
+        self.config = {}
+        self.configSite = {}
+        self.cache = {}
+        self.reference_config_url = 'https://raw.githubusercontent.com/Arrowar/StreamingCommunity/refs/heads/main/config.json'
+        
+        # Read initial config to get use_api setting
+        self._read_initial_config()
+        
+        # Validate and update config before proceeding (if enabled)
+        if validate_github_config:
+            self._validate_and_update_config()
+        
+        console.print(f"[bold cyan]ConfigManager initialized:[/bold cyan] [green]{self.file_path}[/green]")
+
+    def _read_initial_config(self) -> None:
+        """Read initial configuration to get use_api setting."""
+        try:
+            if os.path.exists(self.file_path):
+                with open(self.file_path, 'r') as f:
+                    self.config = json.load(f)
+
+                self.use_api = self.config.get('DEFAULT', {}).get('use_api', True)
+                console.print(f"[bold cyan]API usage setting:[/bold cyan] [{'green' if self.use_api else 'yellow'}]{self.use_api}[/{'green' if self.use_api else 'yellow'}]")
+                console.print(f"[bold cyan]Download site data:[/bold cyan] [{'green' if download_site_data else 'yellow'}]{download_site_data}[/{'green' if download_site_data else 'yellow'}]")
+                console.print(f"[bold cyan]Validate GitHub config:[/bold cyan] [{'green' if validate_github_config else 'yellow'}]{validate_github_config}[/{'green' if validate_github_config else 'yellow'}]")
+
+            else:
+                self.use_api = True
+                console.print("[bold yellow]Configuration file not found. Using default API setting: True[/bold yellow]")
+                console.print(f"[bold yellow]Download site data: {download_site_data}[/bold yellow]")
+                console.print(f"[bold yellow]Validate GitHub config: {validate_github_config}[/bold yellow]")
+
+        except Exception as e:
+            self.use_api = True
+            console.print("[bold red]Error reading API setting. Using default: True[/bold red]")
+
+    def _validate_and_update_config(self) -> None:
+        """Validate local config against reference config and update missing keys."""
+        try:
+            # Load local config if exists
+            local_config = {}
+            if os.path.exists(self.file_path):
+                with open(self.file_path, 'r') as f:
+                    local_config = json.load(f)
+                console.print(f"[bold cyan]Local configuration loaded:[/bold cyan] [green]{len(local_config)} keys found[/green]")
+
+            # Download reference config
+            console.print(f"[bold cyan]Downloading reference config from:[/bold cyan] [green]{self.reference_config_url}[/green]")
+            response = requests.get(self.reference_config_url, timeout=10)
+
+            if not response.ok:
+                raise Exception(f"Failed to download reference config. Status code: {response.status_code}")
+            
+            reference_config = response.json()
+            console.print(f"[bold cyan]Reference config downloaded:[/bold cyan] [green]{len(reference_config)} keys available[/green]")
+
+            # Compare and update missing keys
+            merged_config = self._deep_merge_configs(local_config, reference_config)
+            
+            if merged_config != local_config:
+                added_keys = self._get_added_keys(local_config, merged_config)
+
+                # Save the merged config
+                with open(self.file_path, 'w') as f:
+                    json.dump(merged_config, f, indent=4)
+                console.print(f"[bold green]Configuration updated with {len(added_keys)} new keys:[/bold green] {', '.join(added_keys[:5])}{' and more...' if len(added_keys) > 5 else ''}")
+
+            else:
+                console.print("[bold green]Configuration is up to date.[/bold green]")
+
+            self.config = merged_config
+
+        except Exception as e:
+            console.print(f"[bold red]Configuration validation error:[/bold red] {str(e)}")
+
+            if not self.config:
+                console.print("[bold yellow]Falling back to reference configuration...[/bold yellow]")
+                self.download_requirements(self.reference_config_url, self.file_path)
+
+                with open(self.file_path, 'r') as f:
+                    self.config = json.load(f)
+
+                console.print(f"[bold green]Reference config loaded successfully with {len(self.config)} keys[/bold green]")
+
+    def _get_added_keys(self, old_config: dict, new_config: dict, prefix="") -> list:
+        """
+        Get list of keys added in the new config compared to old config.
+        
+        Args:
+            old_config (dict): The original configuration
+            new_config (dict): The new configuration
+            prefix (str): Key prefix for nested keys
+            
+        Returns:
+            list: List of added key names
+        """
+        added_keys = []
+        
+        for key, value in new_config.items():
+            full_key = f"{prefix}.{key}" if prefix else key
+            
+            if key not in old_config:
+                added_keys.append(full_key)
+            elif isinstance(value, dict) and isinstance(old_config.get(key), dict):
+                added_keys.extend(self._get_added_keys(old_config[key], value, full_key))
+                
+        return added_keys
+
+    def _deep_merge_configs(self, local_config: dict, reference_config: dict) -> dict:
+        """
+        Recursively merge reference config into local config, preserving local values.
+        
+        Args:
+            local_config (dict): The local configuration
+            reference_config (dict): The reference configuration
+            
+        Returns:
+            dict: Merged configuration
+        """
+        merged = local_config.copy()
+        
+        for key, value in reference_config.items():
+            if key not in merged:
+                merged[key] = value
+            elif isinstance(value, dict) and isinstance(merged[key], dict):
+                merged[key] = self._deep_merge_configs(merged[key], value)
+                
+        return merged
+
+    def read_config(self) -> None:
+        """Read the configuration file."""
+        try:
+            logging.info(f"Reading file: {self.file_path}")
+
+            # Check if file exists
+            if os.path.exists(self.file_path):
+                with open(self.file_path, 'r') as f:
+                    self.config = json.load(f)
+                console.print(f"[bold green]Configuration loaded:[/bold green] {len(self.config)} keys, {sum(1 for _ in json.dumps(self.config))} bytes")
+
+            else:
+                console.print(f"[bold yellow]Configuration file not found at:[/bold yellow] {self.file_path}")
+                console.print(f"[bold cyan]Downloading from:[/bold cyan] {self.reference_config_url}")
+                self.download_requirements(self.reference_config_url, 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)
+                console.print(f"[bold green]Configuration downloaded and saved:[/bold green] {len(self.config)} keys")
+
+            # Read API setting again in case it was updated in the downloaded config
+            self.use_api = self.config.get('DEFAULT', {}).get('use_api', self.use_api)
+
+            # Update site configuration separately if enabled
+            if download_site_data:
+                self.update_site_config()
+            else:
+                console.print("[bold yellow]Site data download is disabled[/bold yellow]")
+
+            console.print("[bold cyan]Configuration processing complete[/bold cyan]")
+
+        except Exception as e:
+            logging.error(f"Error reading configuration file: {e}")
+            console.print(f"[bold red]Failed to read configuration:[/bold red] {str(e)}")
+
+    def download_requirements(self, url: str, filename: str) -> None:
+        """
+        Download a file from the specified URL if not found locally using requests.
+
+        Args:
+            url (str): The URL to download the file from.
+            filename (str): The local filename to save the file as.
+        """
+        try:
+            logging.info(f"Downloading {filename} from {url}...")
+            console.print(f"[bold cyan]Downloading file:[/bold cyan] {os.path.basename(filename)}")
+            response = requests.get(url, timeout=10)
+
+            if response.status_code == 200:
+                with open(filename, 'wb') as f:
+                    f.write(response.content)
+                file_size = len(response.content) / 1024
+                console.print(f"[bold green]Download successful:[/bold green] {os.path.basename(filename)} ({file_size:.2f} KB)")
+                
+            else:
+                error_msg = f"HTTP Status: {response.status_code}, Response: {response.text[:100]}"
+                console.print(f"[bold red]Download failed:[/bold red] {error_msg}")
+                logging.error(f"Failed to download {filename}. {error_msg}")
+                sys.exit(0)
+
+        except Exception as e:
+            console.print(f"[bold red]Download error:[/bold red] {str(e)}")
+            logging.error(f"Failed to download {filename}: {e}")
+            sys.exit(0)
+
+    def update_site_config(self) -> None:
+        """Fetch and update the site configuration with data from the API or local file."""
+        if self.use_api:
+            headers = {
+                "apikey": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inp2Zm5ncG94d3Jnc3duenl0YWRoIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDAxNTIxNjMsImV4cCI6MjA1NTcyODE2M30.FNTCCMwi0QaKjOu8gtZsT5yQttUW8QiDDGXmzkn89QE",
+                "Authorization": f"Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Inp2Zm5ncG94d3Jnc3duenl0YWRoIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDAxNTIxNjMsImV4cCI6MjA1NTcyODE2M30.FNTCCMwi0QaKjOu8gtZsT5yQttUW8QiDDGXmzkn89QE",
+                "Content-Type": "application/json"
+            }
+
+            try:
+                console.print("[bold cyan]Fetching site data from API...[/bold cyan]")
+                response = requests.get("https://zvfngpoxwrgswnzytadh.supabase.co/rest/v1/public", headers=headers, timeout=10)
+
+                if response.ok:
+                    data = response.json()
+                    if data and len(data) > 0:
+                        self.configSite = data[0]['data']
+                        
+                        # Display available sites and their domains
+                        site_count = len(self.configSite) if isinstance(self.configSite, dict) else 0
+                        console.print(f"[bold green]Site data fetched:[/bold green] {site_count} streaming services available")
+                        
+                        # List a few sites as examples
+                        if site_count > 0:
+                            examples = list(self.configSite.items())[:3]
+                            sites_info = []
+                            for site, info in examples:
+                                sites_info.append(f"[cyan]{site}[/cyan]: {info.get('full_url', 'N/A')}")
+                            
+                            console.print("[bold cyan]Sample sites:[/bold cyan]")
+                            for info in sites_info:
+                                console.print(f"  {info}")
+                            
+                            if site_count > 3:
+                                console.print(f"  ... and {site_count - 3} more")
+                                
+                    else:
+                        console.print("[bold yellow]API returned empty data set[/bold yellow]")
+                else:
+                    console.print(f"[bold red]API request failed:[/bold red] HTTP {response.status_code}, {response.text[:100]}")
+
+            except Exception as e:
+                console.print(f"[bold red]API connection error:[/bold red] {str(e)}")
+        else:
+            try:
+                if os.path.exists(self.domains_path):
+                    console.print(f"[bold cyan]Reading domains from:[/bold cyan] {self.domains_path}")
+                    with open(self.domains_path, 'r') as f:
+                        self.configSite = json.load(f)
+                    
+                else:
+                    error_msg = f"domains.json not found at {self.domains_path} and API usage is disabled"
+                    console.print(f"[bold red]Configuration error:[/bold red] {error_msg}")
+                    raise FileNotFoundError(error_msg)
+
+            except Exception as e:
+                console.print(f"[bold red]Domains file error:[/bold red] {str(e)}")
+                raise
+            
+    def read_key(self, section: str, key: str, data_type: type = str, from_site: bool = False) -> Any:
+        """Read a key from the configuration.
+
+        Parameters:
+            - section (str): The section in the configuration.
+            - key (str): The key to be read.
+            - data_type (type, optional): The expected data type of the key's value. Default is str.
+            - from_site (bool, optional): Whether to read from site config. Default is False.
+
+        Returns:
+            The value of the key converted to the specified data type.
+        """
+        cache_key = f"{'site' if from_site else 'config'}.{section}.{key}"
+        logging.info(f"Read key: {cache_key}")
+
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+
+        config_source = self.configSite if from_site else self.config
+        
+        if section in config_source and key in config_source[section]:
+            value = config_source[section][key]
+        else:
+            raise ValueError(f"Key '{key}' not found in section '{section}' of {'site' if from_site else 'main'} config")
+
+        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:
+        """Convert the value to the specified data type.
+
+        Parameters:
+            - value (str): The value to be converted.
+            - data_type (type): The expected data type.
+
+        Returns:
+            The value converted to the specified data type.
+        """
+        if data_type == int:
+            return int(value)
+        elif data_type == bool:
+            return bool(value)
+        elif data_type == list:
+            return value if isinstance(value, list) else [item.strip() for item in value.split(',')]
+        elif data_type == type(None):
+            return None
+        else:
+            return value
+
+    # Main config getters
+    def get(self, section: str, key: str) -> Any:
+        """Read a value from the main configuration."""
+        return self.read_key(section, key)
+
+    def get_int(self, section: str, key: str) -> int:
+        """Read an integer value from the main configuration."""
+        return self.read_key(section, key, int)
+
+    def get_float(self, section: str, key: str) -> float:
+        """Read a float value from the main configuration."""
+        return self.read_key(section, key, float)
+
+    def get_bool(self, section: str, key: str) -> bool:
+        """Read a boolean value from the main configuration."""
+        return self.read_key(section, key, bool)
+
+    def get_list(self, section: str, key: str) -> List[str]:
+        """Read a list value from the main configuration."""
+        return self.read_key(section, key, list)
+
+    def get_dict(self, section: str, key: str) -> dict:
+        """Read a dictionary value from the main configuration."""
+        return self.read_key(section, key, dict)
+
+    # Site config getters
+    def get_site(self, section: str, key: str) -> Any:
+        """Read a value from the site configuration."""
+        return self.read_key(section, key, from_site=True)
+
+    def get_site_int(self, section: str, key: str) -> int:
+        """Read an integer value from the site configuration."""
+        return self.read_key(section, key, int, from_site=True)
+
+    def get_site_float(self, section: str, key: str) -> float:
+        """Read a float value from the site configuration."""
+        return self.read_key(section, key, float, from_site=True)
+
+    def get_site_bool(self, section: str, key: str) -> bool:
+        """Read a boolean value from the site configuration."""
+        return self.read_key(section, key, bool, from_site=True)
+
+    def get_site_list(self, section: str, key: str) -> List[str]:
+        """Read a list value from the site configuration."""
+        return self.read_key(section, key, list, from_site=True)
+
+    def get_site_dict(self, section: str, key: str) -> dict:
+        """Read a dictionary value from the site configuration."""
+        return self.read_key(section, key, dict, from_site=True)
+
+    def set_key(self, section: str, key: str, value: Any, to_site: bool = False) -> None:
+        """Set a key in the configuration.
+
+        Parameters:
+            - section (str): The section in the configuration.
+            - key (str): The key to be set.
+            - value (Any): The value to be associated with the key.
+            - to_site (bool, optional): Whether to set in site config. Default is False.
+        """
+        try:
+            config_target = self.configSite if to_site else self.config
+            
+            if section not in config_target:
+                config_target[section] = {}
+
+            config_target[section][key] = value
+            cache_key = f"{'site' if to_site else 'config'}.{section}.{key}"
+            self.cache[cache_key] = value
+
+        except Exception as e:
+            print(f"Error setting key '{key}' in section '{section}' of {'site' if to_site else 'main'} config: {e}")
+
+    def write_config(self) -> None:
+        """Write the main configuration to the file."""
+        try:
+            with open(self.file_path, 'w') as f:
+                json.dump(self.config, f, indent=4)
+        except Exception as e:
+            print(f"Error writing configuration file: {e}")
+
+
+config_manager = ConfigManager()
+config_manager.read_config()
+
+
+import sys
+
+def get_use_large_bar():
+    """
+    Determines whether the large bar feature should be enabled.
+
+    Returns:
+        bool: True if running on a PC (Windows, macOS, Linux),
+              False if running on Android or iOS.
+    """
+    return not any(platform in sys.platform for platform in ("android", "ios"))

StreamingCommunity/Util/headers.py

@@ -7,43 +7,14 @@ import random
 import ua_generator
 
 
-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
+# Variable
+ua =  ua_generator.generate(device='desktop', browser=('chrome', 'edge'))
+
+
+def get_userAgent() -> str:
     user_agent =  ua_generator.generate().text
     return user_agent
 
 
-def random_headers(referer: str = None):
-    """
-    Generate random HTTP headers to simulate human-like behavior.
-
-    Returns:
-        dict: Generated HTTP headers.
-    """
-    ua = ua_generator.generate()
-
-    headers = {
-        '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',
-        'Connection': 'keep-alive',
-        'Upgrade-Insecure-Requests': '1',
-        'Sec-Fetch-Dest': 'document',
-        'Sec-Fetch-Mode': 'navigate',
-        'Sec-Fetch-Site': 'none',
-        'Sec-Fetch-User': '?1',
-    }
-
-    if referer:
-        headers['Origin'] = referer
-        headers['Referer'] = referer
-    
-    return headers
+def get_headers() -> dict:
+    return ua.headers.get()

StreamingCommunity/Util/logger.py

@@ -6,57 +6,87 @@ from logging.handlers import RotatingFileHandler
 
 
 # Internal utilities
-from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.config_json import config_manager
 
 
 class Logger:
+    _instance = None
+    
+    def __new__(cls):
+        # Singleton pattern to avoid multiple logger instances
+        if cls._instance is None:
+            cls._instance = super(Logger, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+        
     def __init__(self):
-
-        # Fetching configuration values
-        self.DEBUG_MODE = config_manager.get_bool("DEFAULT", "debug")
-        self.log_to_file = config_manager.get_bool("DEFAULT", "log_to_file")
-        self.log_file = config_manager.get("DEFAULT", "log_file") if self.log_to_file else None
-
+        # Initialize only once
+        if getattr(self, '_initialized', False):
+            return
+        
+        # Fetch only the debug setting from config
+        self.debug_mode = config_manager.get_bool("DEFAULT", "debug")
+        
+        # Configure root logger
+        self.logger = logging.getLogger('')
+        
+        # Remove any existing handlers to avoid duplication
+        for handler in self.logger.handlers[:]:
+            self.logger.removeHandler(handler)
+        
+        # Reduce logging level for external libraries
         logging.getLogger("httpx").setLevel(logging.WARNING)
         logging.getLogger("httpcore").setLevel(logging.WARNING)
-
         
-        # Setting logging level based on DEBUG_MODE
-        if self.DEBUG_MODE:
-            logging.getLogger('root').setLevel(logging.DEBUG)
+        # Set logging level based on debug_mode
+        if self.debug_mode:
+            self.logger.setLevel(logging.DEBUG)
+            self._configure_console_log_file()
 
-            # 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:
-
-            # If DEBUG_MODE is False, set logging level to ERROR
-            logging.getLogger('root').setLevel(logging.ERROR)
-
-        # Configure console logging
-        self.configure_logging()
-
-    def configure_logging(self):
-        """
-        Configure console logging.
-        """
-        logging.basicConfig(level=logging.DEBUG, format='[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
-
-    def configure_file_logging(self):
-        """
-        Configure file logging if enabled.
-        """
-
-        file_handler = RotatingFileHandler(self.log_file, maxBytes=10*1024*1024, backupCount=5)
-        file_handler.setLevel(logging.DEBUG)
+            self.logger.setLevel(logging.ERROR)
+        
+        # Configure console logging (terminal output) regardless of debug mode
+        self._configure_console_logging()
+        
+        self._initialized = True
+        
+    def _configure_console_logging(self):
+        """Configure console logging output to terminal."""
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.DEBUG if self.debug_mode else logging.ERROR)
         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):
+        console_handler.setFormatter(formatter)
+        self.logger.addHandler(console_handler)
+            
+    def _configure_console_log_file(self):
+        """Create a console.log file only when debug mode is enabled."""
+        console_log_path = "console.log"
+        try:
+            # Remove existing file if present
+            if os.path.exists(console_log_path):
+                os.remove(console_log_path)
+                
+            # Create handler for console.log
+            console_file_handler = RotatingFileHandler(
+                console_log_path,
+                maxBytes=5*1024*1024,  # 5 MB
+                backupCount=3
+            )
+            console_file_handler.setLevel(logging.DEBUG)
+            formatter = logging.Formatter('[%(filename)s:%(lineno)s - %(funcName)20s() ] %(asctime)s - %(levelname)s - %(message)s')
+            console_file_handler.setFormatter(formatter)
+            self.logger.addHandler(console_file_handler)
+            
+        except Exception as e:
+            print(f"Error creating console.log: {e}")
+            
+    @staticmethod
+    def get_logger(name=None):
         """
-        Remove the log file if it already exists.
+        Get a specific logger for a module/component.
+        If name is None, returns the root logger.
         """
-        if os.path.exists(self.log_file):
-            os.remove(self.log_file)
+        # Ensure Logger instance is initialized
+        Logger()
+        return logging.getLogger(name)

StreamingCommunity/Util/message.py

@@ -3,12 +3,17 @@
 import os
 import platform
 
+
+# External library
+from rich.console import Console
+
+
 # Internal utilities
-from StreamingCommunity.Util.console import console
-from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.config_json import config_manager
 
 
 # Variable
+console = Console()
 CLEAN = config_manager.get_bool('DEFAULT', 'clean_console')
 SHOW = config_manager.get_bool('DEFAULT', 'show_message')
 
@@ -33,4 +38,4 @@ def start_message():
 
         # Print a decorative separator line using asterisks
         separator = "_" * (console.width - 2)  # Ridotto di 2 per il padding
-        console.print(f"[cyan]{separator}[/cyan]\n")
+        console.print(f"[cyan]{separator}[/cyan]\n")