StreamingCommunity 2.7.0__py3-none-any.whl → 2.9.0__py3-none-any.whl

StreamingCommunity/TelegramHelp/telegram_bot.py

@@ -113,7 +113,7 @@ class TelegramRequestManager:
                 return False
 
         except (FileNotFoundError, json.JSONDecodeError) as e:
-            print(f"⚠️ save_response - errore: {e}")
+            print(f" save_response - errore: {e}")
             return False
 
     def get_response(self) -> Optional[str]:
@@ -142,7 +142,7 @@ class TelegramRequestManager:
             return True
 
         except Exception as e:
-            print(f"⚠️ clear_file - errore: {e}")
+            print(f" clear_file - errore: {e}")
             return False
 
 # Funzione per caricare variabili da un file .env
@@ -230,20 +230,20 @@ class TelegramBot:
                                     ["screen", "-S", script["screen_id"], "-X", "quit"]
                                 )
                                 print(
-                                    f"✅ La sessione screen con ID {script['screen_id']} è stata fermata automaticamente."
+                                    f" La sessione screen con ID {script['screen_id']} è stata fermata automaticamente."
                                 )
                             except subprocess.CalledProcessError:
                                 print(
-                                    f"⚠️ Impossibile fermare la sessione screen con ID {script['screen_id']}."
+                                    f" Impossibile fermare la sessione screen con ID {script['screen_id']}."
                                 )
                             print(
-                                f"⚠️ Lo script con ID {script['screen_id']} ha superato i 10 minuti e verrà rimosso."
+                                f" Lo script con ID {script['screen_id']} ha superato i 10 minuti e verrà rimosso."
                             )
                         else:
                             scripts_data_to_save.append(script)
                     else:
                         print(
-                            f"⚠️ La sessione screen con ID {script['screen_id']} non esiste più e verrà rimossa."
+                            f" La sessione screen con ID {script['screen_id']} non esiste più e verrà rimossa."
                         )
 
                 # Salva la lista aggiornata, senza gli script scaduti o le screen non esistenti
@@ -305,8 +305,8 @@ class TelegramBot:
 
     def handle_get_id(self, message):
         if not self.is_authorized(message.from_user.id):
-            print(f"❌ Non sei autorizzato.")
-            self.bot.send_message(message.chat.id, "❌ Non sei autorizzato.")
+            print(f" Non sei autorizzato.")
+            self.bot.send_message(message.chat.id, " Non sei autorizzato.")
             return
 
         print(f"Il tuo ID utente è: `{message.from_user.id}`")
@@ -318,8 +318,8 @@ class TelegramBot:
 
     def handle_start_script(self, message):
         if not self.is_authorized(message.from_user.id):
-            print(f"❌ Non sei autorizzato. {message.from_user.id}")
-            self.bot.send_message(message.chat.id, "❌ Non sei autorizzato.")
+            print(f" Non sei autorizzato. {message.from_user.id}")
+            self.bot.send_message(message.chat.id, " Non sei autorizzato.")
             return
 
         screen_id = str(uuid.uuid4())[:8]
@@ -335,10 +335,10 @@ class TelegramBot:
                     "utf-8"
                 )
                 if screen_id in existing_screens:
-                    print(f"⚠️ Lo script con ID {screen_id} è già in esecuzione.")
+                    print(f" Lo script con ID {screen_id} è già in esecuzione.")
                     self.bot.send_message(
                         message.chat.id,
-                        f"⚠️ Lo script con ID {screen_id} è già in esecuzione.",
+                        f" Lo script con ID {screen_id} è già in esecuzione.",
                     )
                     return
             except subprocess.CalledProcessError:
@@ -384,8 +384,8 @@ class TelegramBot:
 
     def handle_list_scripts(self, message):
         if not self.is_authorized(message.from_user.id):
-            print(f"❌ Non sei autorizzato.")
-            self.bot.send_message(message.chat.id, "❌ Non sei autorizzato.")
+            print(f" Non sei autorizzato.")
+            self.bot.send_message(message.chat.id, " Non sei autorizzato.")
             return
 
         try:
@@ -395,12 +395,12 @@ class TelegramBot:
             scripts_data = []
 
         if not scripts_data:
-            print(f"⚠️ Nessuno script registrato.")
-            self.bot.send_message(message.chat.id, "⚠️ Nessuno script registrato.")
+            print(f" Nessuno script registrato.")
+            self.bot.send_message(message.chat.id, " Nessuno script registrato.")
             return
 
         current_time = time.time()
-        msg = ["🖥️ **Script Registrati:**\n"]
+        msg = [" **Script Registrati:**\n"]
 
         for script in scripts_data:
             # Calcola la durata
@@ -414,12 +414,12 @@ class TelegramBot:
             duration_str = f"{int(hours)}h {int(minutes)}m {int(seconds)}s"
 
             # Icona stato
-            status_icons = {"running": "🟢", "stopped": "🔴", "completed": "⚪"}
+            status_icons = {"running": "", "stopped": "", "completed": ""}
 
             # Costruisci riga
             line = (
                 f"• ID: `{script['screen_id']}`\n"
-                f"• Stato: {status_icons.get(script['status'], '⚫')}\n"
+                f"• Stato: {status_icons.get(script['status'], '')}\n"
                 f"• Stop: `/stop {script['screen_id']}`\n"
                 f"• Screen: `/screen {script['screen_id']}`\n"
                 f"• Durata: {duration_str}\n"
@@ -437,8 +437,8 @@ class TelegramBot:
 
     def handle_stop_script(self, message):
         if not self.is_authorized(message.from_user.id):
-            print(f"❌ Non sei autorizzato.")
-            self.bot.send_message(message.chat.id, "❌ Non sei autorizzato.")
+            print(f" Non sei autorizzato.")
+            self.bot.send_message(message.chat.id, " Non sei autorizzato.")
             return
 
         parts = message.text.split()
@@ -452,15 +452,15 @@ class TelegramBot:
             running_scripts = [s for s in scripts_data if s["status"] == "running"]
 
             if not running_scripts:
-                print(f"⚠️ Nessuno script attivo da fermare.")
+                print(f" Nessuno script attivo da fermare.")
                 self.bot.send_message(
-                    message.chat.id, "⚠️ Nessuno script attivo da fermare."
+                    message.chat.id, " Nessuno script attivo da fermare."
                 )
                 return
 
-            msg = "🖥️ **Script Attivi:**\n"
+            msg = " **Script Attivi:**\n"
             for script in running_scripts:
-                msg += f"🔹 `/stop {script['screen_id']}` per fermarlo\n"
+                msg += f" `/stop {script['screen_id']}` per fermarlo\n"
 
             print(f"{msg}")
             self.bot.send_message(message.chat.id, msg, parse_mode="Markdown")
@@ -481,10 +481,10 @@ class TelegramBot:
 
             if len(new_scripts_data) == len(scripts_data):
                 # Nessun elemento rimosso, quindi ID non trovato
-                print(f"⚠️ Nessuno script attivo con ID `{screen_id}`.")
+                print(f" Nessuno script attivo con ID `{screen_id}`.")
                 self.bot.send_message(
                     message.chat.id,
-                    f"⚠️ Nessuno script attivo con ID `{screen_id}`.",
+                    f" Nessuno script attivo con ID `{screen_id}`.",
                     parse_mode="Markdown",
                 )
                 return
@@ -492,14 +492,14 @@ class TelegramBot:
             # Terminare la sessione screen
             try:
                 subprocess.check_output(["screen", "-S", screen_id, "-X", "quit"])
-                print(f"✅ La sessione screen con ID {screen_id} è stata fermata.")
+                print(f" La sessione screen con ID {screen_id} è stata fermata.")
             except subprocess.CalledProcessError:
                 print(
-                    f"⚠️ Impossibile fermare la sessione screen con ID `{screen_id}`."
+                    f" Impossibile fermare la sessione screen con ID `{screen_id}`."
                 )
                 self.bot.send_message(
                     message.chat.id,
-                    f"⚠️ Impossibile fermare la sessione screen con ID `{screen_id}`.",
+                    f" Impossibile fermare la sessione screen con ID `{screen_id}`.",
                     parse_mode="Markdown",
                 )
                 return
@@ -508,27 +508,27 @@ class TelegramBot:
             with open("../../scripts.json", "w") as f:
                 json.dump(new_scripts_data, f, indent=4)
 
-            print(f"✅ Script `{screen_id}` terminato con successo!")
+            print(f" Script `{screen_id}` terminato con successo!")
             self.bot.send_message(
                 message.chat.id,
-                f"✅ Script `{screen_id}` terminato con successo!",
+                f" Script `{screen_id}` terminato con successo!",
                 parse_mode="Markdown",
             )
 
     def handle_response(self, message):
         text = message.text
         if self.request_manager.save_response(text):
-            print(f"📥 Risposta salvata correttamente per il tipo {text}")
+            print(f" Risposta salvata correttamente per il tipo {text}")
         else:
-            print("⚠️ Nessuna richiesta attiva.")
-            self.bot.reply_to(message, "❌ Nessuna richiesta attiva.")
+            print(" Nessuna richiesta attiva.")
+            self.bot.reply_to(message, " Nessuna richiesta attiva.")
 
     def handle_screen_status(self, message):
         command_parts = message.text.split()
         if len(command_parts) < 2:
-            print(f"⚠️ ID mancante nel comando. Usa: /screen <ID>")
+            print(f" ID mancante nel comando. Usa: /screen <ID>")
             self.bot.send_message(
-                message.chat.id, "⚠️ ID mancante nel comando. Usa: /screen <ID>"
+                message.chat.id, " ID mancante nel comando. Usa: /screen <ID>"
             )
             return
 
@@ -539,8 +539,8 @@ class TelegramBot:
             # Verifica se lo screen con l'ID specificato esiste
             existing_screens = subprocess.check_output(["screen", "-list"]).decode('utf-8')
             if screen_id not in existing_screens:
-                print(f"⚠️ La sessione screen con ID {screen_id} non esiste.")
-                self.bot.send_message(message.chat.id, f"⚠️ La sessione screen con ID {screen_id} non esiste.")
+                print(f" La sessione screen con ID {screen_id} non esiste.")
+                self.bot.send_message(message.chat.id, f" La sessione screen con ID {screen_id} non esiste.")
                 return
 
             # Cattura l'output della screen
@@ -549,17 +549,17 @@ class TelegramBot:
                 check=True,
             )
         except subprocess.CalledProcessError as e:
-            print(f"❌ Errore durante la cattura dell'output della screen: {e}")
+            print(f" Errore durante la cattura dell'output della screen: {e}")
             self.bot.send_message(
                 message.chat.id,
-                f"❌ Errore durante la cattura dell'output della screen: {e}",
+                f" Errore durante la cattura dell'output della screen: {e}",
             )
             return
 
         if not os.path.exists(temp_file):
-            print(f"❌ Impossibile catturare l'output della screen.")
+            print(f" Impossibile catturare l'output della screen.")
             self.bot.send_message(
-                message.chat.id, f"❌ Impossibile catturare l'output della screen."
+                message.chat.id, f" Impossibile catturare l'output della screen."
             )
             return
 
@@ -594,18 +594,18 @@ class TelegramBot:
                 cleaned_output = re.sub(r'segments\.py:\d+', '', cleaned_output)
 
             # Invia l'output pulito
-            print(f"📄 Output della screen {screen_id}:\n{cleaned_output}")
+            print(f" Output della screen {screen_id}:\n{cleaned_output}")
             self._send_long_message(
-                message.chat.id, f"📄 Output della screen {screen_id}:\n{cleaned_output}"
+                message.chat.id, f" Output della screen {screen_id}:\n{cleaned_output}"
             )
 
         except Exception as e:
             print(
-                f"❌ Errore durante la lettura o l'invio dell'output della screen: {e}"
+                f" Errore durante la lettura o l'invio dell'output della screen: {e}"
             )
             self.bot.send_message(
                 message.chat.id,
-                f"❌ Errore durante la lettura o l'invio dell'output della screen: {e}",
+                f" Errore durante la lettura o l'invio dell'output della screen: {e}",
             )
 
         # Cancella il file temporaneo
@@ -665,14 +665,14 @@ class TelegramBot:
                 return response
             time.sleep(1)
 
-        print(f"⚠️ Timeout: nessuna risposta ricevuta.")
+        print(f" Timeout: nessuna risposta ricevuta.")
         for chat_id in self.authorized_users:  # Manda a tutti gli ID autorizzati
-            self.bot.send_message(chat_id, "⚠️ Timeout: nessuna risposta ricevuta.")
+            self.bot.send_message(chat_id, " Timeout: nessuna risposta ricevuta.")
         self.request_manager.clear_file()
         return None
 
     def run(self):
-        print("🚀 Avvio del bot...")
+        print(" Avvio del bot...")
         with open("../../scripts.json", "w") as f:
             json.dump([], f)
         self.bot.infinity_polling()

StreamingCommunity/Upload/update.py

@@ -7,12 +7,12 @@ import time
 
 # External library
 import httpx
+from rich.console import Console
 
 
 # Internal utilities
 from .version import __version__, __author__, __title__
-from StreamingCommunity.Util.console import console
-from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.headers import get_userAgent
 
 
@@ -22,6 +22,7 @@ if getattr(sys, 'frozen', False):  # Modalità PyInstaller
     base_path = os.path.join(sys._MEIPASS, "StreamingCommunity")
 else:
     base_path = os.path.dirname(__file__)
+console = Console()
 
 
 def update():

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '2.7.0'
+__version__ = '2.9.0'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2024'

StreamingCommunity/Util/color.py

@@ -17,4 +17,4 @@ class Colors:
     LIGHT_MAGENTA = "\033[95m"
     LIGHT_CYAN = "\033[96m"
     WHITE = "\033[97m"
-    RESET = "\033[0m"
+    RESET = "\033[0m"

StreamingCommunity/Util/{_jsonConfig.py → config_json.py}

@@ -14,6 +14,8 @@ from rich.console import Console
 
 # Variable
 console = Console()
+download_site_data = True
+validate_github_config = True
 
 
 class ConfigManager:
@@ -35,11 +37,36 @@ class ConfigManager:
         self.cache = {}
         self.reference_config_url = 'https://raw.githubusercontent.com/Arrowar/StreamingCommunity/refs/heads/main/config.json'
         
-        # Validate and update config before proceeding
-        self._validate_and_update_config()
+        # Read initial config to get use_api setting
         self._read_initial_config()
         
-        console.print(f"[bold cyan]📂 Configuration file path:[/bold cyan] [green]{self.file_path}[/green]")
+        # 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."""
@@ -49,36 +76,70 @@ class ConfigManager:
             if os.path.exists(self.file_path):
                 with open(self.file_path, 'r') as f:
                     local_config = json.load(f)
-                console.print("[bold cyan]📖 Local configuration found.[/bold cyan]")
+                console.print(f"[bold cyan]Local configuration loaded:[/bold cyan] [green]{len(local_config)} keys found[/green]")
 
             # Download reference config
-            console.print("[bold cyan]🌍 Downloading reference configuration...[/bold cyan]")
-            response = requests.get(self.reference_config_url)
-            if response.status_code != 200:
+            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("[bold green]✅ Configuration updated with missing keys.[/bold green]")
+                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]")
+                console.print("[bold green]Configuration is up to date.[/bold green]")
 
             self.config = merged_config
 
         except Exception as e:
-            console.print(f"[bold red]❌ Error validating configuration: {e}[/bold red]")
+            console.print(f"[bold red]Configuration validation error:[/bold red] {str(e)}")
+
             if not self.config:
-                # If validation failed and we have no config, download the reference 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.
@@ -100,47 +161,41 @@ class ConfigManager:
                 
         return merged
 
-    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)
-            else:
-                self.use_api = True  # Default to True if config file doesn't exist
-                console.print("[bold yellow]⚠️ Configuration file not found. Using default settings.[/bold yellow]")
-
-        except Exception as e:
-            self.use_api = True  # Default to True in case of error
-            logging.error(f"❌ Error reading initial configuration: {e}")
-
     def read_config(self) -> None:
         """Read the configuration file."""
         try:
-            logging.info(f"📖 Reading file: {self.file_path}")
+            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("[bold green]✅ Configuration file loaded successfully.[/bold green]")
+                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("[bold yellow]⚠️ Configuration file not found. Downloading...[/bold yellow]")
+                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("[bold green]✅ Configuration file downloaded and saved.[/bold green]")
+                console.print(f"[bold green]Configuration downloaded and saved:[/bold green] {len(self.config)} keys")
 
-            # Update site configuration separately
-            self.update_site_config()
+            # 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)
 
-            console.print("[bold cyan]🔧 Configuration file processing complete.[/bold cyan]")
+            # 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}")
+            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:
         """
@@ -151,20 +206,25 @@ class ConfigManager:
             filename (str): The local filename to save the file as.
         """
         try:
-            logging.info(f"🌍 Downloading {filename} from {url}...")
-            response = requests.get(url)
+            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)
-                console.print(f"[bold green]✅ Successfully downloaded {filename}.[/bold green]")
+                file_size = len(response.content) / 1024
+                console.print(f"[bold green]Download successful:[/bold green] {os.path.basename(filename)} ({file_size:.2f} KB)")
                 
             else:
-                logging.error(f"❌ Failed to download {filename}. HTTP Status code: {response.status_code}")
+                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:
-            logging.error(f"❌ Failed to download {filename}: {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:
@@ -177,33 +237,55 @@ class ConfigManager:
             }
 
             try:
-                console.print("[bold cyan]🌍 Fetching SITE data from API...[/bold cyan]")
-                response = requests.get("https://zvfngpoxwrgswnzytadh.supabase.co/rest/v1/public", headers=headers)
-
-                if response.status_code == 200:
-                    self.configSite = response.json()[0]['data']
-                    console.print("[bold green]✅ SITE data successfully fetched.[/bold green]")
+                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]❌ Failed to fetch SITE data. HTTP Status code: {response.status_code}[/bold red]")
+                    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]❌ Error fetching SITE data: {e}[/bold red]")
+                console.print(f"[bold red]API connection error:[/bold red] {str(e)}")
         else:
             try:
                 if os.path.exists(self.domains_path):
-                    console.print("[bold cyan]📖 Reading domains from local file...[/bold cyan]")
+                    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)
-                    console.print("[bold green]✅ Domains loaded successfully from local file.[/bold green]")
+                    
                 else:
-                    error_msg = "❌ domains.json not found and API usage is disabled"
-                    console.print(f"[bold red]{error_msg}[/bold red]")
+                    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]❌ Error reading domains file: {e}[/bold red]")
+                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.
 
@@ -336,6 +418,18 @@ class ConfigManager:
             print(f"Error writing configuration file: {e}")
 
 
-# Initialize
 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"))