StreamingCommunity 3.3.9__py3-none-any.whl → 3.4.2__py3-none-any.whl

StreamingCommunity/Api/Template/Util/manage_ep.py

@@ -1,6 +1,7 @@
 # 19.06.24
 
 import sys
+import time
 import logging
 from typing import List
 
@@ -209,6 +210,71 @@ def validate_episode_selection(list_episode_select: List[int], episodes_count: i
             list_episode_select = list(map(int, input_episodes.split(',')))
 
 
+def display_seasons_list(seasons_manager) -> str:
+    """
+    Display seasons list and handle user input.
+
+    Parameters:
+        - seasons_manager: Manager object containing seasons information.
+
+    Returns:
+        last_command (str): Last command entered by the user.
+    """
+    if len(seasons_manager.seasons) == 1:
+        console.print("\n[green]Only one season available, selecting it automatically[/green]")
+        time.sleep(1)
+        return "1"
+    
+    # Set up table for displaying seasons
+    table_show_manager = TVShowManager()
+
+    # Check if 'type' and 'id' attributes exist in the first season
+    has_type = hasattr(seasons_manager.seasons[0], 'type') and (seasons_manager.seasons[0].type) is not None and str(seasons_manager.seasons[0].type) != ''
+    has_id = hasattr(seasons_manager.seasons[0], 'id') and (seasons_manager.seasons[0].id) is not None and str(seasons_manager.seasons[0].id) != ''
+
+    # Add columns to the table
+    column_info = {
+        "Index": {'color': 'red'},
+        "Name": {'color': 'yellow'}
+    }
+
+    if has_type:
+        column_info["Type"] = {'color': 'magenta'}
+    
+    if has_id:
+        column_info["ID"] = {'color': 'cyan'}
+
+    table_show_manager.add_column(column_info)
+
+    # Populate the table with seasons information
+    for i, season in enumerate(seasons_manager.seasons):
+        season_name = season.name if hasattr(season, 'name') else 'N/A'
+        season_info = {
+            'Index': str(i + 1),
+            'Name': season_name
+        }
+
+        # Add 'Type' and 'ID' if they exist
+        if has_type:
+            season_type = season.type if hasattr(season, 'type') else 'N/A'
+            season_info['Type'] = season_type
+        
+        if has_id:
+            season_id = season.id if hasattr(season, 'id') else 'N/A'
+            season_info['ID'] = season_id
+
+        table_show_manager.add_tv_show(season_info)
+
+    # Run the table and handle user input
+    last_command = table_show_manager.run()
+
+    if last_command in ("q", "quit"):
+        console.print("\n[red]Quit ...")
+        sys.exit(0)
+
+    return last_command
+
+
 def display_episodes_list(episodes_manager) -> str:
     """
     Display episodes list and handle user input.

StreamingCommunity/Api/Template/config_loader.py

@@ -56,13 +56,6 @@ class SiteConstant:
             base_path = os.path.join(base_path, self.SITE_NAME)
         return os.path.join(base_path, config_manager.get('OUT_FOLDER', 'anime_folder_name'))
     
-    @property
-    def COOKIE(self):
-        try:
-            return config_manager.get_dict('SITE_EXTRA', self.SITE_NAME)
-        except KeyError:
-            return None
-    
     @property
     def TELEGRAM_BOT(self):
         return config_manager.get_bool('DEFAULT', 'telegram_bot')

StreamingCommunity/Lib/Downloader/DASH/decrypt.py

@@ -3,25 +3,30 @@
 import os
 import subprocess
 import logging
+import threading
+import time
 
 
 # External libraries
 from rich.console import Console
+from tqdm import tqdm
 
 
 # Internal utilities
 from StreamingCommunity.Util.os import get_mp4decrypt_path
+from StreamingCommunity.Util.color import Colors
 
 # Variable
 console = Console()
 
 
 # NOTE!: SAREBBE MEGLIO FARLO PER OGNI FILE DURANTE IL DOWNLOAD ... MA PER ORA LO LASCIO COSI
-def decrypt_with_mp4decrypt(encrypted_path, kid, key, output_path=None, cleanup=True):
+def decrypt_with_mp4decrypt(type, encrypted_path, kid, key, output_path=None, cleanup=True):
     """
     Decrypt an mp4/m4s file using mp4decrypt.
 
     Args:
+        type (str): Type of file ('video' or 'audio').
         encrypted_path (str): Path to encrypted file.
         kid (str): Hexadecimal KID.
         key (str): Hexadecimal key.
@@ -48,15 +53,63 @@ def decrypt_with_mp4decrypt(encrypted_path, kid, key, output_path=None, cleanup=
     if not output_path:
         output_path = os.path.splitext(encrypted_path)[0] + "_decrypted.mp4"
 
+    # Get file size for progress tracking
+    file_size = os.path.getsize(encrypted_path)
+    
     key_format = f"{kid.lower()}:{key.lower()}"
     cmd = [get_mp4decrypt_path(), "--key", key_format, encrypted_path, output_path]
     logging.info(f"Running command: {' '.join(cmd)}")
 
+    # Create progress bar with custom format
+    bar_format = (
+        f"{Colors.YELLOW}DECRYPT{Colors.CYAN} {type}{Colors.WHITE}: "
+        f"{Colors.MAGENTA}{{bar:40}} "
+        f"{Colors.LIGHT_GREEN}{{n_fmt}}{Colors.WHITE}/{Colors.CYAN}{{total_fmt}} "
+        f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
+        f"{Colors.WHITE}{{postfix}}"
+    )
+    
+    progress_bar = tqdm(
+        total=100,
+        bar_format=bar_format,
+        unit="",
+        ncols=150
+    )
+    
+    def monitor_output_file():
+        """Monitor output file growth and update progress bar."""
+        last_size = 0
+        while True:
+            if os.path.exists(output_path):
+                current_size = os.path.getsize(output_path)
+                if current_size > 0:
+                    progress_percent = min(int((current_size / file_size) * 100), 100)
+                    progress_bar.n = progress_percent
+                    progress_bar.refresh()
+                    
+                    if current_size == last_size and current_size > 0:
+                        # File stopped growing, likely finished
+                        break
+                    
+                    last_size = current_size
+            
+            time.sleep(0.1)
+    
+    # Start monitoring thread
+    monitor_thread = threading.Thread(target=monitor_output_file, daemon=True)
+    monitor_thread.start()
+
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
     except Exception as e:
+        progress_bar.close()
         console.print(f"[bold red] mp4decrypt execution failed: {e}[/bold red]")
         return None
+    
+    # Ensure progress bar reaches 100%
+    progress_bar.n = 100
+    progress_bar.refresh()
+    progress_bar.close()
 
     if result.returncode == 0 and os.path.exists(output_path):
 

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -1,19 +1,19 @@
 # 25.07.25
 
 import os
-import time
 import shutil
+import logging
+from typing import Optional, Dict
 
 
 # External libraries
 from rich.console import Console
-from rich.panel import Panel
 from rich.table import Table
 
 
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
-from StreamingCommunity.Util.os import os_manager, internet_manager
+from StreamingCommunity.Util.os import os_manager, internet_manager, get_wvd_path
 from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Util.headers import get_userAgent
 
@@ -32,11 +32,11 @@ from ...FFmpeg import print_duration_table, join_audios, join_video, join_subtit
 # Config
 DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_audio')
 DOWNLOAD_SPECIFIC_SUBTITLE = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_subtitles')
-ENABLE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'download_subtitle')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 FILTER_CUSTOM_REOLUTION = str(config_manager.get('M3U8_CONVERSION', 'force_resolution')).strip().lower()
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
 RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
+EXTENSION_OUTPUT = config_manager.get("M3U8_CONVERSION", "extension")
 
 
 # Variable
@@ -44,18 +44,17 @@ console = Console()
 
 
 class DASH_Downloader:
-    def __init__(self, cdm_device, license_url, mpd_url, mpd_sub_list: list = None, output_path: str = None):
+    def __init__(self, license_url, mpd_url, mpd_sub_list: list = None, output_path: str = None):
         """
         Initialize the DASH Downloader with necessary parameters.
 
         Parameters:
-            - cdm_device (str): Path to the CDM device for decryption.
             - license_url (str): URL to obtain the license for decryption.
             - mpd_url (str): URL of the MPD manifest file.
             - mpd_sub_list (list): List of subtitle dicts with keys: 'language', 'url', 'format'.
             - output_path (str): Path to save the final output file.
         """
-        self.cdm_device = cdm_device
+        self.cdm_device = get_wvd_path()
         self.license_url = license_url
         self.mpd_url = mpd_url
         self.mpd_sub_list = mpd_sub_list or []
@@ -75,6 +74,10 @@ class DASH_Downloader:
         self.error = None
         self.stopped = False
         self.output_file = None
+        
+        # For progress tracking
+        self.current_downloader: Optional[MPD_Segments] = None
+        self.current_download_type: Optional[str] = None
 
     def _setup_temp_dirs(self):
         """
@@ -196,49 +199,28 @@ class DASH_Downloader:
         Download subtitle files based on configuration with retry mechanism.
         Returns True if successful or if no subtitles to download, False on critical error.
         """
-        if not ENABLE_SUBTITLE or not self.selected_subs:
-            return True
-        
-        headers = {'User-Agent': get_userAgent()}
-        client = create_client(headers=headers)
+        client = create_client(headers={'User-Agent': get_userAgent()})
         
         for sub in self.selected_subs:
-            language = sub.get('language', 'unknown')
-            url = sub.get('url')
-            fmt = sub.get('format', 'vtt')
-            
-            if not url:
-                console.print(f"[yellow]Warning: No URL for subtitle {language}[/yellow]")
-                continue
-            
-            # Retry mechanism for downloading subtitles
-            success = False
-            for attempt in range(RETRY_LIMIT):
-                try:
-                    # Download subtitle
-                    response = client.get(url)
-                    response.raise_for_status()
-                    
-                    # Save subtitle file
-                    sub_filename = f"{language}.{fmt}"
-                    sub_path = os.path.join(self.subs_dir, sub_filename)
-                    
-                    with open(sub_path, 'wb') as f:
-                        f.write(response.content)
-                    
-                    success = True
-                    break
+            try:
+                language = sub.get('language', 'unknown')
+                fmt = sub.get('format', 'vtt')
+
+                # Download subtitle
+                response = client.get(sub.get('url'))
+                response.raise_for_status()
+                
+                # Save subtitle file and make request
+                sub_filename = f"{language}.{fmt}"
+                sub_path = os.path.join(self.subs_dir, sub_filename)
+                
+                with open(sub_path, 'wb') as f:
+                    f.write(response.content)
                     
-                except Exception as e:
-                    if attempt < RETRY_LIMIT - 1:
-                        console.print(f"[yellow]Attempt {attempt + 1}/{RETRY_LIMIT} failed for subtitle {language}: {e}. Retrying...[/yellow]")
-                        time.sleep(1.5 ** attempt)
-                    else:
-                        console.print(f"[yellow]Warning: Failed to download subtitle {language} after {RETRY_LIMIT} attempts: {e}[/yellow]")
+            except Exception as e:
+                console.print(f"[red]Error downloading subtitle {language}: {e}[/red]")
+                return False
             
-            if not success:
-                continue
-        
         return True
 
     def download_and_decrypt(self, custom_headers=None, custom_payload=None):
@@ -256,7 +238,6 @@ class DASH_Downloader:
 
         # Fetch keys immediately after obtaining PSSH
         if not self.parser.pssh:
-            console.print("[red]No PSSH found: segments are not encrypted, skipping decryption.")
             self.download_segments(clear=True)
             return True
 
@@ -293,6 +274,10 @@ class DASH_Downloader:
                     pssh=self.parser.pssh
                 )
 
+                # Set current downloader for progress tracking
+                self.current_downloader = video_downloader
+                self.current_download_type = 'video'
+
                 try:
                     result = video_downloader.download_streams(description="Video")
                     
@@ -312,11 +297,15 @@ class DASH_Downloader:
                 except Exception as ex:
                     self.error = str(ex)
                     return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
 
                 # Decrypt video
                 decrypted_path = os.path.join(self.decrypted_dir, "video.mp4")
                 result_path = decrypt_with_mp4decrypt(
-                    encrypted_path, KID, KEY, output_path=decrypted_path
+                    "Video", encrypted_path, KID, KEY, output_path=decrypted_path
                 )
 
                 if not result_path:
@@ -345,6 +334,10 @@ class DASH_Downloader:
                     limit_segments=video_segments_count if video_segments_count > 0 else None
                 )
 
+                # Set current downloader for progress tracking
+                self.current_downloader = audio_downloader
+                self.current_download_type = f"audio_{audio_language}"
+
                 try:
                     result = audio_downloader.download_streams(description=f"Audio {audio_language}")
 
@@ -361,11 +354,15 @@ class DASH_Downloader:
                 except Exception as ex:
                     self.error = str(ex)
                     return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
 
                 # Decrypt audio
                 decrypted_path = os.path.join(self.decrypted_dir, "audio.mp4")
                 result_path = decrypt_with_mp4decrypt(
-                    encrypted_path, KID, KEY, output_path=decrypted_path
+                    f"Audio {audio_language}", encrypted_path, KID, KEY, output_path=decrypted_path
                 )
 
                 if not result_path:
@@ -381,9 +378,126 @@ class DASH_Downloader:
         return True
 
     def download_segments(self, clear=False):
-        # Download segments and concatenate them
-        # clear=True: no decryption needed
-        pass
+        """
+        Download video/audio segments without decryption (for clear content).
+        
+        Parameters:
+            clear (bool): If True, content is not encrypted and doesn't need decryption
+        """
+        if not clear:
+            console.print("[yellow]Warning: download_segments called with clear=False[/yellow]")
+            return False
+        
+        video_segments_count = 0
+        
+        # Download subtitles
+        self.download_subtitles()
+        
+        # Download video
+        video_rep = self.get_representation_by_type("video")
+        if video_rep:
+            encrypted_path = os.path.join(self.encrypted_dir, f"{video_rep['id']}_encrypted.m4s")
+            
+            # If m4s file doesn't exist, start downloading
+            if not os.path.exists(encrypted_path):
+                video_downloader = MPD_Segments(
+                    tmp_folder=self.encrypted_dir,
+                    representation=video_rep,
+                    pssh=self.parser.pssh
+                )
+                
+                # Set current downloader for progress tracking
+                self.current_downloader = video_downloader
+                self.current_download_type = 'video'
+                
+                try:
+                    result = video_downloader.download_streams(description="Video")
+                    
+                    # Store the video segment count for limiting audio
+                    video_segments_count = video_downloader.get_segments_count()
+                    
+                    # Check for interruption or failure
+                    if result.get("stopped"):
+                        self.stopped = True
+                        self.error = "Download interrupted"
+                        return False
+                    
+                    if result.get("nFailed", 0) > 0:
+                        self.error = f"Failed segments: {result['nFailed']}"
+                        return False
+                    
+                except Exception as ex:
+                    self.error = str(ex)
+                    console.print(f"[red]Error downloading video: {ex}[/red]")
+                    return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
+            
+            # NO DECRYPTION: just copy/move to decrypted folder
+            decrypted_path = os.path.join(self.decrypted_dir, "video.mp4")
+            if os.path.exists(encrypted_path) and not os.path.exists(decrypted_path):
+                shutil.copy2(encrypted_path, decrypted_path)
+
+        else:
+            self.error = "No video found"
+            console.print(f"[red]{self.error}[/red]")
+            return False
+        
+        # Download audio with segment limiting
+        audio_rep = self.get_representation_by_type("audio")
+        if audio_rep:
+            encrypted_path = os.path.join(self.encrypted_dir, f"{audio_rep['id']}_encrypted.m4s")
+            
+            # If m4s file doesn't exist, start downloading
+            if not os.path.exists(encrypted_path):
+                audio_language = audio_rep.get('language', 'Unknown')
+                
+                audio_downloader = MPD_Segments(
+                    tmp_folder=self.encrypted_dir,
+                    representation=audio_rep,
+                    pssh=self.parser.pssh,
+                    limit_segments=video_segments_count if video_segments_count > 0 else None
+                )
+                
+                # Set current downloader for progress tracking
+                self.current_downloader = audio_downloader
+                self.current_download_type = f"audio_{audio_language}"
+                
+                try:
+                    result = audio_downloader.download_streams(description=f"Audio {audio_language}")
+                    
+                    # Check for interruption or failure
+                    if result.get("stopped"):
+                        self.stopped = True
+                        self.error = "Download interrupted"
+                        return False
+                    
+                    if result.get("nFailed", 0) > 0:
+                        self.error = f"Failed segments: {result['nFailed']}"
+                        return False
+                    
+                except Exception as ex:
+                    self.error = str(ex)
+                    console.print(f"[red]Error downloading audio: {ex}[/red]")
+                    return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
+            
+            # NO DECRYPTION: just copy/move to decrypted folder
+            decrypted_path = os.path.join(self.decrypted_dir, "audio.mp4")
+            if os.path.exists(encrypted_path) and not os.path.exists(decrypted_path):
+                shutil.copy2(encrypted_path, decrypted_path)
+                
+        else:
+            self.error = "No audio found"
+            console.print(f"[red]{self.error}[/red]")
+            return False
+        
+        return True
 
     def finalize_output(self):
         """
@@ -415,8 +529,8 @@ class DASH_Downloader:
             console.print("[red]Video file missing, cannot export[/red]")
             return None
         
-        # Merge subtitles if enabled and available
-        if MERGE_SUBTITLE and ENABLE_SUBTITLE and self.selected_subs:
+        # Merge subtitles if available
+        if MERGE_SUBTITLE and self.selected_subs:
 
             # Check which subtitle files actually exist
             existing_sub_tracks = []
@@ -455,7 +569,7 @@ class DASH_Downloader:
         
         # Handle failed sync case
         if use_shortest:
-            new_filename = output_file.replace(".mp4", "_failed_sync.mp4")
+            new_filename = output_file.replace(EXTENSION_OUTPUT, f"_failed_sync{EXTENSION_OUTPUT}")
             if os.path.exists(output_file):
                 os.rename(output_file, new_filename)
                 output_file = new_filename
@@ -465,20 +579,7 @@ class DASH_Downloader:
         if os.path.exists(output_file):
             file_size = internet_manager.format_file_size(os.path.getsize(output_file))
             duration = print_duration_table(output_file, description=False, return_string=True)
-
-            panel_content = (
-                f"[cyan]File size: [bold red]{file_size}[/bold red]\n"
-                f"[cyan]Duration: [bold]{duration}[/bold]\n"
-                f"[cyan]Output: [bold]{os.path.abspath(output_file)}[/bold]"
-            )
-
-            print("")
-            console.print(Panel(
-                panel_content,
-                title=f"{os.path.basename(output_file.replace('.mp4', ''))}",
-                border_style="green"
-            ))
-
+            console.print(f"[yellow]Output [red]{os.path.abspath(output_file)} [cyan]with size [red]{file_size} [cyan]and duration [red]{duration}")
         else:
             console.print(f"[red]Output file not found: {output_file}")
 
@@ -514,4 +615,19 @@ class DASH_Downloader:
             "path": self.output_file,
             "error": self.error,
             "stopped": self.stopped
-        }
+        }
+    
+    def get_progress_data(self) -> Optional[Dict]:
+        """Get current download progress data."""
+        if not self.current_downloader:
+            return None
+
+        try:
+            progress = self.current_downloader.get_progress_data()
+            if progress:
+                progress['download_type'] = self.current_download_type
+            return progress
+            
+        except Exception as e:
+            logging.error(f"Error getting progress data: {e}")
+            return None

StreamingCommunity/Lib/Downloader/DASH/parser.py

@@ -1,6 +1,7 @@
 # 25.07.25
 
 import re
+import logging
 from urllib.parse import urljoin
 import xml.etree.ElementTree as ET
 from typing import List, Dict, Optional, Tuple, Any
@@ -456,6 +457,7 @@ class MPDParser:
                 )
                 
                 response.raise_for_status()
+                logging.info(f"Successfully fetched MPD: {response.content}")
                 self.root = ET.fromstring(response.content)
                 break
 
@@ -480,9 +482,6 @@ class MPDParser:
                 self.pssh = pssh_element.text
                 break
 
-        if not self.pssh:
-            console.print("[bold red]PSSH not found in MPD![/bold red]")
-
     def _parse_representations(self) -> None:
         """Parse all representations from the MPD"""
         base_url = self._get_initial_base_url()