StreamingCommunity 3.2.7__py3-none-any.whl → 3.2.9__py3-none-any.whl

StreamingCommunity/Lib/M3U8/__init__.py

@@ -3,4 +3,12 @@
 from .decryptor import M3U8_Decryption
 from .estimator import M3U8_Ts_Estimator
 from .parser import M3U8_Parser, M3U8_Codec
-from .url_fixer import M3U8_UrlFix
+from .url_fixer import M3U8_UrlFix
+
+__all__ = [
+    "M3U8_Decryption",
+    "M3U8_Ts_Estimator",
+    "M3U8_Parser",
+    "M3U8_Codec",
+    "M3U8_UrlFix"
+]

StreamingCommunity/Lib/M3U8/decryptor.py

@@ -1,7 +1,6 @@
 # 03.04.24
 
 import sys
-import time
 import logging
 import importlib.util
 
@@ -10,18 +9,23 @@ import importlib.util
 from rich.console import Console
 
 
+# Cryptodome imports 
+from Cryptodome.Cipher import AES
+from Cryptodome.Util.Padding import unpad
+
+
 # Check if Cryptodome module is installed
 console = Console()
 crypto_spec = importlib.util.find_spec("Cryptodome")
 crypto_installed = crypto_spec is not None
 
+
 if not crypto_installed:
     console.log("[red]pycryptodomex non è installato. Per favore installalo. Leggi readme.md [Requirement].")
     sys.exit(0)
 
-logging.info("[cyan]Decrypy use: Cryptodomex")
-from Cryptodome.Cipher import AES
-from Cryptodome.Util.Padding import unpad
+
+logging.info("[cyan]Decryption use: Cryptodomex")
 
 
 

StreamingCommunity/Lib/M3U8/estimator.py

@@ -121,12 +121,6 @@ class M3U8_Ts_Estimator:
             number_file_total_size = file_total_size.split(' ')[0]
             units_file_total_size = file_total_size.split(' ')[1]
             
-            # Reduce lock contention by acquiring data with minimal synchronization
-            retry_count = 0
-            if self.segments_instance:
-                with self.segments_instance.active_retries_lock:
-                    retry_count = self.segments_instance.active_retries
-            
             # Get speed data outside of any locks
             speed_data = ["N/A", ""]
             with self.lock:

StreamingCommunity/Lib/M3U8/parser.py

@@ -485,7 +485,7 @@ class M3U8_Parser:
         try:
             for playlist in m3u8_obj.playlists:
 
-                there_is_codec = not playlist.stream_info.codecs is None
+                there_is_codec = playlist.stream_info.codecs is not None
                 logging.info(f"There is coded: {there_is_codec}")
 
                 if there_is_codec:

StreamingCommunity/Lib/M3U8/url_fixer.py

@@ -33,7 +33,7 @@ class M3U8_UrlFix:
         Returns:
             str: The full URL for the specified resource.
         """
-        if self.url_playlist == None:
+        if self.url_playlist is None:
             logging.error("[M3U8_UrlFix] Cant generate full url, playlist not present")
             raise
 

StreamingCommunity/Lib/TMBD/__init__.py

@@ -1,4 +1,9 @@
 # 17.09.24
 
 from .tmdb import tmdb
-from .obj_tmbd import Json_film
+from .obj_tmbd import Json_film
+
+__all__ = [
+    "tmdb",
+    "Json_film"
+]

StreamingCommunity/TelegramHelp/config.json

@@ -2,10 +2,8 @@
     "DEFAULT": {
         "debug": false,
         "show_message": true,
-        "clean_console": true,
         "show_trending": true,
         "use_api": true,
-        "not_close": false,
         "telegram_bot": true,
         "download_site_data": true,
         "validate_github_config": true
@@ -45,9 +43,7 @@
         "use_acodec": true,
         "use_bitrate": true,
         "use_gpu": false,
-        "default_preset": "ultrafast"
-    },
-    "M3U8_PARSER": {
+        "default_preset": "ultrafast",
         "force_resolution": "Best"
     },
     "REQUESTS": {

StreamingCommunity/TelegramHelp/telegram_bot.py

@@ -9,7 +9,6 @@ import uuid
 import json
 import threading
 import subprocess
-import threading
 from typing import Optional
 
 # External libraries
@@ -305,7 +304,7 @@ class TelegramBot:
 
     def handle_get_id(self, message):
         if not self.is_authorized(message.from_user.id):
-            print(f" Non sei autorizzato.")
+            print(" Non sei autorizzato.")
             self.bot.send_message(message.chat.id, " Non sei autorizzato.")
             return
 
@@ -384,7 +383,7 @@ class TelegramBot:
 
     def handle_list_scripts(self, message):
         if not self.is_authorized(message.from_user.id):
-            print(f" Non sei autorizzato.")
+            print(" Non sei autorizzato.")
             self.bot.send_message(message.chat.id, " Non sei autorizzato.")
             return
 
@@ -395,7 +394,7 @@ class TelegramBot:
             scripts_data = []
 
         if not scripts_data:
-            print(f" Nessuno script registrato.")
+            print(" Nessuno script registrato.")
             self.bot.send_message(message.chat.id, " Nessuno script registrato.")
             return
 
@@ -437,7 +436,7 @@ class TelegramBot:
 
     def handle_stop_script(self, message):
         if not self.is_authorized(message.from_user.id):
-            print(f" Non sei autorizzato.")
+            print(" Non sei autorizzato.")
             self.bot.send_message(message.chat.id, " Non sei autorizzato.")
             return
 
@@ -452,7 +451,7 @@ 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(" Nessuno script attivo da fermare.")
                 self.bot.send_message(
                     message.chat.id, " Nessuno script attivo da fermare."
                 )
@@ -526,7 +525,7 @@ class TelegramBot:
     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(" ID mancante nel comando. Usa: /screen <ID>")
             self.bot.send_message(
                 message.chat.id, " ID mancante nel comando. Usa: /screen <ID>"
             )
@@ -557,9 +556,9 @@ class TelegramBot:
             return
 
         if not os.path.exists(temp_file):
-            print(f" Impossibile catturare l'output della screen.")
+            print(" Impossibile catturare l'output della screen.")
             self.bot.send_message(
-                message.chat.id, f" Impossibile catturare l'output della screen."
+                message.chat.id, " Impossibile catturare l'output della screen."
             )
             return
 
@@ -669,7 +668,7 @@ class TelegramBot:
                 return response
             time.sleep(1)
 
-        print(f" Timeout: nessuna risposta ricevuta.")
+        print(" 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.request_manager.clear_file()

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '3.2.7'
+__version__ = '3.2.9'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
-__copyright__ = 'Copyright 2025'
+__copyright__ = 'Copyright 2025'

StreamingCommunity/Util/config_json.py

@@ -18,8 +18,6 @@ from StreamingCommunity.Util.headers import get_userAgent
 
 # Variable
 console = Console()
-download_site_data = True
-validate_github_config = True
 
 
 class ConfigManager:
@@ -54,8 +52,7 @@ class ConfigManager:
         self.configSite = {}
         self.cache = {}
 
-        self.use_api = False
-        self.download_site_data = False
+        self.fetch_domain_online = True
         self.validate_github_config = False
         
         console.print(f"[bold cyan]Initializing ConfigManager:[/bold cyan] [green]{self.file_path}[/green]")
@@ -67,7 +64,7 @@ class ConfigManager:
         """Load the configuration and initialize all settings."""
         if not os.path.exists(self.file_path):
             console.print(f"[bold red]WARNING: Configuration file not found:[/bold red] {self.file_path}")
-            console.print(f"[bold yellow]Attempting to download from reference repository...[/bold yellow]")
+            console.print("[bold yellow]Attempting to download from reference repository...[/bold yellow]")
             self._download_reference_config()
         
         # Load the configuration file
@@ -85,11 +82,8 @@ class ConfigManager:
             else:
                 console.print("[bold yellow]GitHub validation disabled[/bold yellow]")
                 
-            # Load site data if requested
-            if self.download_site_data:
-                self._load_site_data()
-            else:
-                console.print("[bold yellow]Site data download disabled[/bold yellow]")
+            # Load site data based on fetch_domain_online setting
+            self._load_site_data()
                 
         except json.JSONDecodeError as e:
             console.print(f"[bold red]Error parsing JSON:[/bold red] {str(e)}")
@@ -119,18 +113,11 @@ class ConfigManager:
         """Update internal settings from loaded configurations."""
         default_section = self.config.get('DEFAULT', {})
         
-        # Save local values in temporary variables
-        temp_use_api = default_section.get('use_api', False)
-        temp_download_site_data = default_section.get('download_site_data', False)
-        temp_validate_github_config = default_section.get('validate_github_config', False)
-        
-        # Update settings with found values (False by default)
-        self.use_api = temp_use_api
-        self.download_site_data = temp_download_site_data
-        self.validate_github_config = temp_validate_github_config
+        # Get fetch_domain_online setting (True by default)
+        self.fetch_domain_online = default_section.get('fetch_domain_online', True)
+        self.validate_github_config = default_section.get('validate_github_config', False)
         
-        console.print(f"[bold cyan]API Usage:[/bold cyan] [{'green' if self.use_api else 'yellow'}]{self.use_api}[/{'green' if self.use_api else 'yellow'}]")
-        console.print(f"[bold cyan]Site data download:[/bold cyan] [{'green' if self.download_site_data else 'yellow'}]{self.download_site_data}[/{'green' if self.download_site_data else 'yellow'}]")
+        console.print(f"[bold cyan]Fetch domains online:[/bold cyan] [{'green' if self.fetch_domain_online else 'yellow'}]{self.fetch_domain_online}[/{'green' if self.fetch_domain_online else 'yellow'}]")
         console.print(f"[bold cyan]GitHub configuration validation:[/bold cyan] [{'green' if self.validate_github_config else 'yellow'}]{self.validate_github_config}[/{'green' if self.validate_github_config else 'yellow'}]")
     
     def _download_reference_config(self) -> None:
@@ -159,7 +146,7 @@ class ConfigManager:
         """Validate the local configuration against the reference one and update missing keys."""
         try:
             # Download the reference configuration
-            console.print(f"[bold cyan]Validating configuration with GitHub...[/bold cyan]")
+            console.print("[bold cyan]Validating configuration with GitHub...[/bold cyan]")
             response = requests.get(self.reference_config_url, timeout=8, headers={'User-Agent': get_userAgent()})
             
             if not response.ok:
@@ -242,11 +229,9 @@ class ConfigManager:
                     # Make sure control keys maintain local values
                     merged_section = self._deep_merge_configs(merged[key], value)
                     
-                    # Preserve local values for the three critical settings
-                    if 'use_api' in merged[key]:
-                        merged_section['use_api'] = merged[key]['use_api']
-                    if 'download_site_data' in merged[key]:
-                        merged_section['download_site_data'] = merged[key]['download_site_data']
+                    # Preserve local values for critical settings
+                    if 'fetch_domain_online' in merged[key]:
+                        merged_section['fetch_domain_online'] = merged[key]['fetch_domain_online']
                     if 'validate_github_config' in merged[key]:
                         merged_section['validate_github_config'] = merged[key]['validate_github_config']
                     
@@ -259,28 +244,31 @@ class ConfigManager:
         return merged
     
     def _load_site_data(self) -> None:
-        """Load site data from API or local file."""
-        if self.use_api:
-            self._load_site_data_from_api()
+        """Load site data based on fetch_domain_online setting."""
+        if self.fetch_domain_online:
+            self._load_site_data_online()
         else:
             self._load_site_data_from_file()
     
-    def _load_site_data_from_api(self) -> None:
-        """Load site data from GitHub."""
+    def _load_site_data_online(self) -> None:
+        """Load site data from GitHub and update local domains.json file."""
         domains_github_url = "https://raw.githubusercontent.com/Arrowar/StreamingCommunity/refs/heads/main/.github/.domain/domains.json"
         headers = {
             "User-Agent": get_userAgent()
         }
         
         try:
-            console.print("[bold cyan]Retrieving site data from GitHub:[/bold cyan]")
+            console.print("[bold cyan]Fetching domains from GitHub:[/bold cyan]")
             response = requests.get(domains_github_url, timeout=8, headers=headers)
 
             if response.ok:
                 self.configSite = response.json()
                 
+                # Determine which file to save to
+                self._save_domains_to_appropriate_location()
+                
                 site_count = len(self.configSite) if isinstance(self.configSite, dict) else 0
-                console.print(f"[bold green]Site data loaded from GitHub:[/bold green] {site_count} streaming services found.")
+                console.print(f"[bold green]Domains loaded from GitHub:[/bold green] {site_count} streaming services found.")
                 
             else:
                 console.print(f"[bold red]GitHub request failed:[/bold red] HTTP {response.status_code}, {response.text[:100]}")
@@ -294,42 +282,129 @@ class ConfigManager:
             console.print(f"[bold red]GitHub connection error:[/bold red] {str(e)}")
             self._handle_site_data_fallback()
     
+    def _save_domains_to_appropriate_location(self) -> None:
+        """Save domains to the appropriate location based on existing files."""
+        if getattr(sys, 'frozen', False):
+            # If the application is frozen (e.g., PyInstaller)
+            base_path = os.path.dirname(sys.executable)
+        else:
+            # Use the current working directory where the script is executed
+            base_path = os.getcwd()
+            
+        # Check for GitHub structure first
+        github_domains_path = os.path.join(base_path, '.github', '.domain', 'domains.json')
+        
+        try:
+            if os.path.exists(github_domains_path):
+
+                # Update existing GitHub structure file
+                with open(github_domains_path, 'w', encoding='utf-8') as f:
+                    json.dump(self.configSite, f, indent=4, ensure_ascii=False)
+                console.print(f"[bold green]Domains updated in GitHub structure:[/bold green] {github_domains_path}")
+                
+            elif not os.path.exists(self.domains_path):
+
+                # Save to root only if it doesn't exist and GitHub structure doesn't exist
+                with open(self.domains_path, 'w', encoding='utf-8') as f:
+                    json.dump(self.configSite, f, indent=4, ensure_ascii=False)
+                console.print(f"[bold green]Domains saved to:[/bold green] {self.domains_path}")
+                
+            else:
+
+                # Root file exists, don't overwrite it
+                console.print(f"[bold yellow]Local domains.json already exists, not overwriting:[/bold yellow] {self.domains_path}")
+                console.print("[bold yellow]Tip: Delete the file if you want to recreate it from GitHub[/bold yellow]")
+                
+        except Exception as save_error:
+            console.print(f"[bold yellow]Warning: Could not save domains to file:[/bold yellow] {str(save_error)}")
+
+            # Try to save to root as fallback only if it doesn't exist
+            if not os.path.exists(self.domains_path):
+                try:
+                    with open(self.domains_path, 'w', encoding='utf-8') as f:
+                        json.dump(self.configSite, f, indent=4, ensure_ascii=False)
+                    console.print(f"[bold green]Domains saved to fallback location:[/bold green] {self.domains_path}")
+                except Exception as fallback_error:
+                    console.print(f"[bold red]Failed to save to fallback location:[/bold red] {str(fallback_error)}")
+    
     def _load_site_data_from_file(self) -> None:
-        """Load site data from local file."""
+        """Load site data from local domains.json file."""
         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:
+            # Determine the base path
+            if getattr(sys, 'frozen', False):
+
+                # If the application is frozen (e.g., PyInstaller)
+                base_path = os.path.dirname(sys.executable)
+            else:
+
+                # Use the current working directory where the script is executed
+                base_path = os.getcwd()
+            
+            # Check for GitHub structure first
+            github_domains_path = os.path.join(base_path, '.github', '.domain', 'domains.json')
+            
+            if os.path.exists(github_domains_path):
+                console.print(f"[bold cyan]Reading domains from GitHub structure:[/bold cyan] {github_domains_path}")
+                with open(github_domains_path, 'r', encoding='utf-8') as f:
+                    self.configSite = json.load(f)
+                
+                site_count = len(self.configSite) if isinstance(self.configSite, dict) else 0
+                console.print(f"[bold green]Domains loaded from GitHub structure:[/bold green] {site_count} streaming services")
+                
+            elif os.path.exists(self.domains_path):
+                console.print(f"[bold cyan]Reading domains from root:[/bold cyan] {self.domains_path}")
+                with open(self.domains_path, 'r', encoding='utf-8') as f:
                     self.configSite = json.load(f)
                 
                 site_count = len(self.configSite) if isinstance(self.configSite, dict) else 0
-                console.print(f"[bold green]Site data loaded from file:[/bold green] {site_count} streaming services")
+                console.print(f"[bold green]Domains loaded from root file:[/bold green] {site_count} streaming services")
 
             else:
-                error_msg = f"domains.json not found at {self.domains_path} and API usage is disabled"
+                error_msg = f"domains.json not found in GitHub structure ({github_domains_path}) or root ({self.domains_path}) and fetch_domain_online is disabled"
                 console.print(f"[bold red]Configuration error:[/bold red] {error_msg}")
-                self._handle_site_data_fallback()
+                console.print("[bold yellow]Tip: Set 'fetch_domain_online' to true to download domains from GitHub[/bold yellow]")
+                self.configSite = {}
         
         except Exception as e:
-            console.print(f"[bold red]Domain file error:[/bold red] {str(e)}")
-            self._handle_site_data_fallback()
+            console.print(f"[bold red]Local domain file error:[/bold red] {str(e)}")
+            self.configSite = {}
     
     def _handle_site_data_fallback(self) -> None:
         """Handle site data fallback in case of error."""
-        if self.use_api and os.path.exists(self.domains_path):
-            console.print("[bold yellow]Attempting fallback to local domains.json file...[/bold yellow]")
-
+        # Determine the base path
+        if getattr(sys, 'frozen', False):
+            
+            # If the application is frozen (e.g., PyInstaller)
+            base_path = os.path.dirname(sys.executable)
+        else:
+            # Use the current working directory where the script is executed
+            base_path = os.getcwd()
+        
+        # Check for GitHub structure first
+        github_domains_path = os.path.join(base_path, '.github', '.domain', 'domains.json')
+        
+        if os.path.exists(github_domains_path):
+            console.print("[bold yellow]Attempting fallback to GitHub structure domains.json file...[/bold yellow]")
             try:
-                with open(self.domains_path, 'r') as f:
+                with open(github_domains_path, 'r', encoding='utf-8') as f:
                     self.configSite = json.load(f)
-                console.print("[bold green]Fallback to local data successful[/bold green]")
+                console.print("[bold green]Fallback to GitHub structure successful[/bold green]")
+                return
             except Exception as fallback_error:
-                console.print(f"[bold red]Fallback also failed:[/bold red] {str(fallback_error)}")
-                self.configSite = {}
-        else:
-
-            # Initialize with an empty dictionary if there are no alternatives
-            self.configSite = {}
+                console.print(f"[bold red]GitHub structure fallback failed:[/bold red] {str(fallback_error)}")
+        
+        if os.path.exists(self.domains_path):
+            console.print("[bold yellow]Attempting fallback to root domains.json file...[/bold yellow]")
+            try:
+                with open(self.domains_path, 'r', encoding='utf-8') as f:
+                    self.configSite = json.load(f)
+                console.print("[bold green]Fallback to root domains successful[/bold green]")
+                return
+            except Exception as fallback_error:
+                console.print(f"[bold red]Root domains fallback failed:[/bold red] {str(fallback_error)}")
+        
+        console.print("[bold red]No local domains.json file available for fallback[/bold red]")
+        self.configSite = {}
     
     def download_file(self, url: str, filename: str) -> None:
         """
@@ -412,23 +487,28 @@ class ConfigManager:
             Any: Converted value
         """
         try:
-            if data_type == int:
+            if data_type is int:
                 return int(value)
-            elif data_type == float:
+            
+            elif data_type is float:
                 return float(value)
-            elif data_type == bool:
+            
+            elif data_type is bool:
                 if isinstance(value, str):
                     return value.lower() in ("yes", "true", "t", "1")
                 return bool(value)
-            elif data_type == list:
+            
+            elif data_type is list:
                 if isinstance(value, list):
                     return value
                 if isinstance(value, str):
                     return [item.strip() for item in value.split(',')]
                 return [value]
-            elif data_type == dict:
+
+            elif data_type is dict:
                 if isinstance(value, dict):
                     return value
+                
                 raise ValueError(f"Cannot convert {type(value).__name__} to dict")
             else:
                 return value