StreamingCommunity 2.9.3__py3-none-any.whl → 2.9.5__py3-none-any.whl

StreamingCommunity/Api/Template/config_loader.py

@@ -31,10 +31,6 @@ class SiteConstant:
     def ROOT_PATH(self):
         return config_manager.get('OUT_FOLDER', 'root_path')
     
-    @property
-    def DOMAIN_NOW(self):
-        return config_manager.get_site(self.SITE_NAME, 'domain')
-    
     @property
     def FULL_URL(self):
         return config_manager.get_site(self.SITE_NAME, 'full_url').rstrip('/')

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -438,13 +438,13 @@ class HLS_Downloader:
                 return response
             
             if GET_ONLY_LINK:
-                console.print(f"URL: {self.m3u8_url}[/bold red]")
+                console.print(f"URL: [bold red]{self.m3u8_url}[/bold red]")
                 return {
                     'path': None,
                     'url': self.m3u8_url,
                     'is_master': getattr(self.m3u8_manager, 'is_master', None),
                     'msg': None,
-                    'error': error_msg,
+                    'error': None,
                     'stopped': True
                 }
 

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -37,7 +37,7 @@ from ...M3U8 import (
 # Config
 TQDM_DELAY_WORKER = config_manager.get_float('M3U8_DOWNLOAD', 'tqdm_delay')
 REQUEST_MAX_RETRY = config_manager.get_int('REQUESTS', 'max_retry')
-REQUEST_VERIFY = config_manager.get_int('REQUESTS', 'verify')
+REQUEST_VERIFY = config_manager.get_bool('REQUESTS', 'verify')
 DEFAULT_VIDEO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_video_workser')
 DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_workser')
 MAX_TIMEOOUT = config_manager.get_int("REQUESTS", "timeout")

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -30,7 +30,7 @@ from ...FFmpeg import print_duration_table
 
 
 # Config
-REQUEST_VERIFY = config_manager.get_int('REQUESTS', 'verify')
+REQUEST_VERIFY = config_manager.get_bool('REQUESTS', 'verify')
 GET_ONLY_LINK = config_manager.get_bool('M3U8_PARSER', 'get_only_link')
 REQUEST_TIMEOUT = config_manager.get_float('REQUESTS', 'timeout')
 TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
@@ -110,11 +110,12 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
     interrupt_handler = InterruptHandler()
     original_handler = signal.signal(signal.SIGINT, partial(signal_handler, interrupt_handler=interrupt_handler, original_handler=signal.getsignal(signal.SIGINT)))
 
+    # Ensure the output directory exists
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
     try:
-        transport = httpx.HTTPTransport(verify=REQUEST_VERIFY, http2=True)
-        
-        with httpx.Client(transport=transport, timeout=httpx.Timeout(60)) as client:
-            with client.stream("GET", url, headers=headers, timeout=REQUEST_TIMEOUT) as response:
+        with httpx.Client() as client:
+            with client.stream("GET", url, headers=headers) as response:
                 response.raise_for_status()
                 total = int(response.headers.get('content-length', 0))
                 
@@ -122,6 +123,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                     console.print("[bold red]No video stream found.[/bold red]")
                     return None, False
 
+                # Create a fancy progress bar
                 progress_bar = tqdm(
                     total=total,
                     ascii='░▒█',
@@ -134,7 +136,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                     unit_scale=True,
                     desc='Downloading',
                     mininterval=0.05,
-                    file=sys.stdout                         # Using file=sys.stdout to force in-place updates because sys.stderr may not support carriage returns in this environment.
+                    file=sys.stdout                         # Using file=sys.stdout to force in-place updates because sys.stderr may not support carriage returns in this environment.  
                 )
 
                 downloaded = 0

StreamingCommunity/Lib/M3U8/estimator.py

@@ -119,15 +119,15 @@ class M3U8_Ts_Estimator:
                 
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.WHITE}< {Colors.RED}{units_file_total_size}"
-                    f"{Colors.WHITE} {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
+                    f"{Colors.WHITE}, {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
                     f"{Colors.WHITE}, {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
                 
             else:
                 retry_count = self.segments_instance.active_retries if self.segments_instance else 0
                 progress_str = (
-                    f"{Colors.GREEN}{number_file_total_size} {Colors.WHITE}< {Colors.RED}{units_file_total_size}"
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
                     f"{Colors.WHITE}, {Colors.GREEN}CRR {Colors.RED}{retry_count} "
                 )
             

StreamingCommunity/Upload/version.py

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

StreamingCommunity/Util/config_json.py

@@ -196,6 +196,7 @@ class ConfigManager:
         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)}")
+            sys.exit(0)
 
     def download_requirements(self, url: str, filename: str) -> None:
         """
@@ -255,14 +256,7 @@ class ConfigManager:
                             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:
@@ -421,9 +415,6 @@ class ConfigManager:
 config_manager = ConfigManager()
 config_manager.read_config()
 
-
-import sys
-
 def get_use_large_bar():
     """
     Determines whether the large bar feature should be enabled.

StreamingCommunity/Util/table.py

@@ -147,9 +147,14 @@ class TVShowManager:
                 if not force_int_input:
                     prompt_msg = ("\n[cyan]Insert media index [yellow](e.g., 1), [red]* [cyan]to download all media, "
                                 "[yellow](e.g., 1-2) [cyan]for a range of media, or [yellow](e.g., 3-*) [cyan]to download from a specific index to the end")
+                    telegram_msg = "Menu di selezione degli episodi: \n\n" \
+                                   "- Inserisci il numero dell'episodio (ad esempio, 1)\n" \
+                                   "- Inserisci * per scaricare tutti gli episodi\n" \
+                                   "- Inserisci un intervallo di episodi (ad esempio, 1-2) per scaricare da un episodio all'altro\n" \
+                                   "- Inserisci (ad esempio, 3-*) per scaricare dall'episodio specificato fino alla fine della serie"
                     
                     if is_telegram:
-                        key = bot.ask("select_title_episode", prompt_msg, None)
+                        key = bot.ask("select_title_episode", telegram_msg, None)
                     else:
                         key = Prompt.ask(prompt_msg)
                 else:
@@ -183,9 +188,14 @@ class TVShowManager:
                 if not force_int_input:
                     prompt_msg = ("\n[cyan]Insert media index [yellow](e.g., 1), [red]* [cyan]to download all media, "
                                 "[yellow](e.g., 1-2) [cyan]for a range of media, or [yellow](e.g., 3-*) [cyan]to download from a specific index to the end")
+                    telegram_msg = "Menu di selezione degli episodi: \n\n" \
+                                   "- Inserisci il numero dell'episodio (ad esempio, 1)\n" \
+                                   "- Inserisci * per scaricare tutti gli episodi\n" \
+                                   "- Inserisci un intervallo di episodi (ad esempio, 1-2) per scaricare da un episodio all'altro\n" \
+                                   "- Inserisci (ad esempio, 3-*) per scaricare dall'episodio specificato fino alla fine della serie"
                     
                     if is_telegram:
-                        key = bot.ask("select_title_episode", prompt_msg, None)
+                        key = bot.ask("select_title_episode", telegram_msg, None)
                     else:
                         key = Prompt.ask(prompt_msg)
                 else:

StreamingCommunity/__init__.py

@@ -0,0 +1,6 @@
+# 11.03.25
+
+from .run import main
+from .Lib.Downloader.HLS.downloader import HLS_Downloader
+from .Lib.Downloader.MP4.downloader import MP4_downloader
+from .Lib.Downloader.TOR.downloader import TOR_downloader

StreamingCommunity/global_search.py

@@ -0,0 +1,315 @@
+# 17.03.25
+
+import os
+import sys
+import time
+import glob
+import logging
+import importlib
+
+
+# External library
+from rich.console import Console
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.progress import Progress
+
+
+# Internal utilities
+from StreamingCommunity.Util.message import start_message
+
+
+# Variable
+console = Console()
+msg = Prompt()
+
+
+# !!! DA METTERE IN COMUNE CON QUELLA DI RUN
+def load_search_functions():
+    modules = []
+    loaded_functions = {}
+    excluded_sites = set()
+
+    # Find api home directory
+    if getattr(sys, 'frozen', False):  # Modalità PyInstaller
+        base_path = os.path.join(sys._MEIPASS, "StreamingCommunity")
+    else:
+        base_path = os.path.dirname(__file__)
+
+    api_dir = os.path.join(base_path, 'Api', 'Site')
+    init_files = glob.glob(os.path.join(api_dir, '*', '__init__.py'))
+
+    # Retrieve modules and their indices
+    for init_file in init_files:
+
+        # Get folder name as module name
+        module_name = os.path.basename(os.path.dirname(init_file))
+
+        # Se il modulo è nella lista da escludere, saltalo
+        if module_name in excluded_sites:
+            continue
+
+        logging.info(f"Load module name: {module_name}")
+
+        try:
+            # Dynamically import the module
+            mod = importlib.import_module(f'StreamingCommunity.Api.Site.{module_name}')
+
+            # Get 'indice' from the module
+            indice = getattr(mod, 'indice', 0)
+            is_deprecate = bool(getattr(mod, '_deprecate', True))
+            use_for = getattr(mod, '_useFor', 'other')
+
+            if not is_deprecate:
+                modules.append((module_name, indice, use_for))
+
+        except Exception as e:
+            console.print(f"[red]Failed to import module {module_name}: {str(e)}")
+
+    # Sort modules by 'indice'
+    modules.sort(key=lambda x: x[1])
+
+    # Load search functions in the sorted order
+    for module_name, _, use_for in modules:
+
+        # Construct a unique alias for the module
+        module_alias = f'{module_name}_search'
+
+        try:
+
+            # Dynamically import the module
+            mod = importlib.import_module(f'StreamingCommunity.Api.Site.{module_name}')
+
+            # Get the search function from the module (assuming the function is named 'search' and defined in __init__.py)
+            search_function = getattr(mod, 'search')
+
+            # Add the function to the loaded functions dictionary
+            loaded_functions[module_alias] = (search_function, use_for)
+
+        except Exception as e:
+            console.print(f"[red]Failed to load search function from module {module_name}: {str(e)}")
+
+    return loaded_functions
+
+def global_search(search_terms: str = None, selected_sites: list = None):
+    """
+    Perform a search across multiple sites based on selection.
+    
+    Parameters:
+        search_terms (str, optional): The terms to search for. If None, will prompt the user.
+        selected_sites (list, optional): List of site aliases to search. If None, will search all sites.
+    
+    Returns:
+        dict: Consolidated search results from all searched sites.
+    """
+    search_functions = load_search_functions()
+    all_results = {}
+    
+    if search_terms is None:
+        search_terms = msg.ask("\n[purple]Enter search terms for global search: ").strip()
+    
+    # Organize sites by category for better display
+    sites_by_category = {}
+    for alias, (func, category) in search_functions.items():
+        if category not in sites_by_category:
+            sites_by_category[category] = []
+        sites_by_category[category].append((alias, func))
+    
+    # If no sites are specifically selected, prompt the user
+    if selected_sites is None:
+        console.print("\n[bold green]Select sites to search:[/bold green]")
+        console.print("[bold cyan]1.[/bold cyan] Search all sites")
+        console.print("[bold cyan]2.[/bold cyan] Search by category")
+        console.print("[bold cyan]3.[/bold cyan] Select specific sites")
+        
+        choice = msg.ask("[green]Enter your choice (1-3)", choices=["1", "2", "3"], default="1")
+        
+        if choice == "1":
+            # Search all sites
+            selected_sites = list(search_functions.keys())
+
+        elif choice == "2":
+            # Search by category
+            console.print("\n[bold green]Select categories to search:[/bold green]")
+            for i, category in enumerate(sites_by_category.keys(), 1):
+                console.print(f"[bold cyan]{i}.[/bold cyan] {category.capitalize()}")
+            
+            category_choices = msg.ask("[green]Enter category numbers separated by commas", default="1")
+            selected_categories = [list(sites_by_category.keys())[int(c.strip())-1] for c in category_choices.split(",")]
+            
+            selected_sites = []
+            for category in selected_categories:
+                for alias, _ in sites_by_category.get(category, []):
+                    selected_sites.append(alias)
+
+        else:
+            # Select specific sites
+            console.print("\n[bold green]Select specific sites to search:[/bold green]")
+            
+            for i, (alias, _) in enumerate(search_functions.items(), 1):
+                site_name = alias.split("_")[0].capitalize()
+                console.print(f"[bold cyan]{i}.[/bold cyan] {site_name}")
+            
+            site_choices = msg.ask("[green]Enter site numbers separated by commas", default="1")
+            selected_indices = [int(c.strip())-1 for c in site_choices.split(",")]
+            selected_sites = [list(search_functions.keys())[i] for i in selected_indices if i < len(search_functions)]
+    
+    # Display progress information
+    console.print(f"\n[bold green]Searching for:[/bold green] [yellow]{search_terms}[/yellow]")
+    console.print(f"[bold green]Searching across:[/bold green] {len(selected_sites)} sites")
+    
+    with Progress() as progress:
+        search_task = progress.add_task("[cyan]Searching...", total=len(selected_sites))
+        
+        # Search each selected site
+        for alias in selected_sites:
+            site_name = alias.split("_")[0].capitalize()
+            progress.update(search_task, description=f"[cyan]Searching {site_name}...")
+            
+            func, _ = search_functions[alias]
+            try:
+                # Call the search function with get_onlyDatabase=True to get database object
+                database = func(search_terms, get_onlyDatabase=True)
+                
+                # Check if database has media_list attribute and it's not empty
+                if database and hasattr(database, 'media_list') and len(database.media_list) > 0:
+                    # Store media_list items with additional source information
+                    all_results[alias] = []
+                    for element in database.media_list:
+                        # Convert element to dictionary if it's an object
+                        if hasattr(element, '__dict__'):
+                            item_dict = element.__dict__.copy()
+                        else:
+                            item_dict = {}  # Fallback for non-object items
+                        
+                        # Add source information
+                        item_dict['source'] = site_name
+                        item_dict['source_alias'] = alias
+                        all_results[alias].append(item_dict)
+                        
+                    console.print(f"[green]Found {len(database.media_list)} results from {site_name}")
+
+            except Exception as e:
+                console.print(f"[bold red]Error searching {site_name}:[/bold red] {str(e)}")
+            
+            progress.update(search_task, advance=1)
+    
+    # Display the consolidated results
+    if all_results:
+        all_media_items = []
+        for alias, results in all_results.items():
+            for item in results:
+                all_media_items.append(item)
+        
+        # Display consolidated results
+        display_consolidated_results(all_media_items, search_terms)
+        
+        # Allow user to select an item
+        selected_item = select_from_consolidated_results(all_media_items)
+        if selected_item:
+            # Process the selected item - download or further actions
+            process_selected_item(selected_item, search_functions)
+
+    else:
+        console.print(f"\n[bold red]No results found for:[/bold red] [yellow]{search_terms}[/yellow]")
+
+        # Optionally offer to search again or return to main menu
+        if msg.ask("[green]Search again? (y/n)", choices=["y", "n"], default="y") == "y":
+            global_search()
+    
+    return all_results
+
+def display_consolidated_results(all_media_items, search_terms):
+    """
+    Display consolidated search results from multiple sites.
+    
+    Parameters:
+        all_media_items (list): List of media items from all searched sites.
+        search_terms (str): The search terms used.
+    """    
+    time.sleep(1)
+    start_message()
+
+    console.print(f"\n[bold green]Search results for:[/bold green] [yellow]{search_terms}[/yellow] \n")
+    
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Title", min_width=20)
+    table.add_column("Type", width=15)
+    table.add_column("Source", width=25)
+    
+    for i, item in enumerate(all_media_items, 1):
+
+        # Extract values from item dict, with fallbacks if keys don't exist
+        title = item.get('title', item.get('name', 'Unknown'))
+        media_type = item.get('type', item.get('media_type', 'Unknown'))
+        source = item.get('source', 'Unknown')
+        
+        table.add_row(
+            str(i),
+            str(title),
+            str(media_type),
+            str(source),
+        )
+    
+    console.print(table)
+
+def select_from_consolidated_results(all_media_items):
+    """
+    Allow user to select an item from consolidated results.
+    
+    Parameters:
+        all_media_items (list): List of media items from all searched sites.
+    
+    Returns:
+        dict: The selected media item or None if no selection was made.
+    """
+    if not all_media_items:
+        return None
+    
+    max_index = len(all_media_items)
+    choice = msg.ask(
+        f"[green]Select item # (1-{max_index}) or 0 to cancel",
+        choices=[str(i) for i in range(max_index + 1)],
+        default="1",
+        show_choices=False
+    )
+    
+    if choice == "0":
+        return None
+    
+    return all_media_items[int(choice) - 1]
+
+def process_selected_item(selected_item, search_functions):
+    """
+    Process the selected item - download the media using the appropriate site API.
+    
+    Parameters:
+        selected_item (dict): The selected media item.
+        search_functions (dict): Dictionary of search functions by alias.
+    """
+    source_alias = selected_item.get('source_alias')
+    if not source_alias or source_alias not in search_functions:
+        console.print("[bold red]Error: Cannot process this item - source information missing.[/bold red]")
+        return
+    
+    # Get the appropriate search function for this source
+    func, _ = search_functions[source_alias]
+    
+    console.print(f"\n[bold green]Processing selection from:[/bold green] {selected_item.get('source')}")
+    
+    # Extract necessary information to pass to the site's search function
+    item_id = selected_item.get('id', selected_item.get('media_id'))
+    item_type = selected_item.get('type', selected_item.get('media_type', 'unknown'))
+    item_title = selected_item.get('title', selected_item.get('name', 'Unknown'))
+    
+    if item_id:
+        console.print(f"[bold green]Selected item:[/bold green] {item_title} (ID: {item_id}, Type: {item_type})")
+        
+        # Call the site's search function with direct_item parameter to process download
+        try:
+            func(direct_item=selected_item)
+        except Exception as e:
+            console.print(f"[bold red]Error processing download:[/bold red] {str(e)}")
+    else:
+        console.print("[bold red]Error: Item ID not found.[/bold red]")

StreamingCommunity/run.py

@@ -18,6 +18,7 @@ from rich.prompt import Prompt
 
 
 # Internal utilities
+from .global_search import global_search
 from StreamingCommunity.Util.message import start_message
 from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.os import os_summary
@@ -54,6 +55,7 @@ def run_function(func: Callable[..., None], close_console: bool = False, search_
         func(search_terms)
 
 
+# !!! DA METTERE IN COMUNE CON QUELLA DI GLOBAL
 def load_search_functions():
     modules = []
     loaded_functions = {}
@@ -237,6 +239,11 @@ def main(script_id = 0):
         '--specific_list_subtitles', type=str, help='Comma-separated list of specific subtitle languages to download (e.g., eng,spa).'
     )
 
+    # Add global search option
+    parser.add_argument(
+        '--global', action='store_true', help='Perform a global search across multiple sites.'
+    )
+
     # Add arguments for search functions
     color_map = {
         "anime": "red",
@@ -253,6 +260,7 @@ def main(script_id = 0):
         parser.add_argument(f'-{short_option}', f'--{long_option}', action='store_true', help=f'Search for {alias.split("_")[0]} on streaming platforms.')
 
     parser.add_argument('-s', '--search', default=None, help='Search terms')
+    
     # Parse command-line arguments
     args = parser.parse_args()
 
@@ -280,6 +288,11 @@ def main(script_id = 0):
 
     config_manager.write_config()
 
+    # Check if global search is requested
+    if getattr(args, 'global'):
+        global_search(search_terms)
+        return
+
     # Map command-line arguments to functions
     arg_to_function = {alias: func for alias, (func, _) in search_functions.items()}
 
@@ -295,13 +308,18 @@ def main(script_id = 0):
     # Create dynamic prompt message and choices
     choice_labels = {str(i): (alias.split("_")[0].capitalize(), use_for) for i, (alias, (_, use_for)) in enumerate(search_functions.items())}
 
+    # Add global search option to the menu
+    #global_search_key = str(len(choice_labels))
+    #choice_labels[global_search_key] = ("Global Search", "all")
+    #input_to_function[global_search_key] = global_search
+
     # Display the category legend in a single line
     legend_text = " | ".join([f"[{color}]{category.capitalize()}[/{color}]" for category, color in color_map.items()])
     console.print(f"\n[bold green]Category Legend:[/bold green] {legend_text}")
 
     # Construct the prompt message with color-coded site names
     prompt_message = "[green]Insert category [white](" + ", ".join(
-        [f"{key}: [{color_map[label[1]]}]{label[0]}[/{color_map[label[1]]}]" for key, label in choice_labels.items()]
+        [f"{key}: [{color_map.get(label[1], 'white')}]{label[0]}[/{color_map.get(label[1], 'white')}]" for key, label in choice_labels.items()]
     ) + "[white])"
 
     if TELEGRAM_BOT:
@@ -330,10 +348,16 @@ def main(script_id = 0):
 
     # Run the corresponding function based on user input
     if category in input_to_function:
-        run_function(input_to_function[category], search_terms = args.search)
+        """if category == global_search_key:
+            # Run global search
+            run_function(input_to_function[category], search_terms=search_terms)
+        
+        else:"""
+        
+        # Run normal site-specific search
+        run_function(input_to_function[category], search_terms=search_terms)
         
     else:
-
         if TELEGRAM_BOT:
             bot.send_message(f"Categoria non valida", None)