StreamingCommunity 3.3.6__py3-none-any.whl → 3.3.8__py3-none-any.whl

StreamingCommunity/Api/Template/loader.py

@@ -0,0 +1,158 @@
+# 01.10.25 
+
+import os
+import sys
+import glob
+import logging
+import importlib
+from typing import Dict
+
+
+# External import
+from rich.console import Console
+
+
+# Variable
+console = Console()
+
+
+class LazySearchModule:
+    def __init__(self, module_name: str, indice: int):
+        """
+        Lazy loader for a search module.
+        Args:
+            module_name: Name of the site module (e.g., 'streamingcommunity')
+            indice: Sort index for the module
+        """
+        self.module_name = module_name
+        self.indice = indice
+        self._module = None
+        self._search_func = None
+        self._use_for = None
+    
+    def _load_module(self):
+        """Load the module on first access."""
+        if self._module is None:
+            try:
+                self._module = importlib.import_module(
+                    f'StreamingCommunity.Api.Site.{self.module_name}'
+                )
+                self._search_func = getattr(self._module, 'search')
+                self._use_for = getattr(self._module, '_useFor')
+                logging.info(f"Loaded module: {self.module_name}")
+            except Exception as e:
+                console.print(f"[red]Failed to load module {self.module_name}: {str(e)}")
+                raise
+    
+    def __call__(self, *args, **kwargs):
+        """Execute search function when called.
+        
+        Args:
+            *args: Positional arguments to pass to search function
+            **kwargs: Keyword arguments to pass to search function
+            
+        Returns:
+            Result from the search function
+        """
+        self._load_module()
+        return self._search_func(*args, **kwargs)
+    
+    @property
+    def use_for(self):
+        """Get _useFor attribute (loads module if needed).
+        
+        Returns:
+            List of content types this module supports
+        """
+        if self._use_for is None:
+            self._load_module()
+
+        return self._use_for
+    
+    def __getitem__(self, index: int):
+        """Support tuple unpacking: func, use_for = loaded_functions['name'].
+        
+        Args:
+            index: Index to access (0 for function, 1 for use_for)
+            
+        Returns:
+            Self (as callable) for index 0, use_for for index 1
+            
+        Raises:
+            IndexError: If index is not 0 or 1
+        """
+        if index == 0:
+            return self
+        elif index == 1:
+            return self.use_for
+        
+        raise IndexError("LazySearchModule only supports indices 0 and 1")
+
+
+def load_search_functions() -> Dict[str, LazySearchModule]:
+    """Load and return all available search functions from site modules.
+    
+    This function uses lazy loading - modules are only imported when first used.
+    Returns instantly (~0.001s) instead of ~0.2s with full imports.
+    
+    Returns:
+        Dictionary mapping '{module_name}_search' to LazySearchModule instances
+        
+    Example:
+        >>> search_funcs = load_search_functions()  # Instant!
+        >>> results = search_funcs['streamingcommunity_search']("breaking bad")  # Import happens here
+    """
+    loaded_functions = {}
+    
+    # Determine base path (calculated once)
+    if getattr(sys, 'frozen', False):
+
+        # When frozen (exe), sys._MEIPASS points to temporary extraction directory
+        base_path = os.path.join(sys._MEIPASS, "StreamingCommunity")
+        api_dir = os.path.join(base_path, 'Api', 'Site')
+        
+    else:
+        # When not frozen, __file__ is in StreamingCommunity/Api/Template/loader.py
+        # Go up two levels to get to StreamingCommunity/Api
+        base_path = os.path.dirname(os.path.dirname(__file__))
+        api_dir = os.path.join(base_path, 'Site')
+    
+    # Quick scan: just read directory structure and module metadata
+    modules_metadata = []
+    
+    for init_file in glob.glob(os.path.join(api_dir, '*', '__init__.py')):
+        module_name = os.path.basename(os.path.dirname(init_file))
+        
+        try:
+            # Read only the __init__.py file to extract metadata (no import)
+            with open(init_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+                
+            # Quick check for deprecation without importing
+            if '_deprecate = True' in content or '_deprecate=True' in content:
+                continue
+            
+            # Extract indice using simple string search (faster than regex)
+            indice = None
+            for line in content.split('\n'):
+                line = line.strip()
+                if line.startswith('indice =') or line.startswith('indice='):
+                    try:
+                        indice = int(line.split('=')[1].strip())
+                        break
+                    except (ValueError, IndexError):
+                        pass
+            
+            if indice is not None:
+                modules_metadata.append((module_name, indice))
+                logging.info(f"Found module: {module_name} (index: {indice})")
+                
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not read metadata from {module_name}: {str(e)}")
+    
+    # Sort by index and create lazy loaders
+    for module_name, indice in sorted(modules_metadata, key=lambda x: x[1]):
+        loaded_functions[f'{module_name}_search'] = LazySearchModule(module_name, indice)
+    
+    logging.info(f"Loaded {len(loaded_functions)} search modules")
+    return loaded_functions

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -1,6 +1,7 @@
 # 25.07.25
 
 import os
+import time
 import shutil
 
 
@@ -13,7 +14,8 @@ from rich.table import Table
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.os import internet_manager
-from ...FFmpeg import print_duration_table, join_audios, join_video
+from StreamingCommunity.Util.http_client import create_client
+from StreamingCommunity.Util.headers import get_userAgent
 
 
 # Logic class
@@ -23,11 +25,18 @@ from .decrypt import decrypt_with_mp4decrypt
 from .cdm_helpher import get_widevine_keys
 
 
+# FFmpeg functions
+from ...FFmpeg import print_duration_table, join_audios, join_video, join_subtitle
+
 
 # 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')
 
 
 # Variable
@@ -35,12 +44,24 @@ console = Console()
 
 
 class DASH_Downloader:
-    def __init__(self, cdm_device, license_url, mpd_url, output_path):
+    def __init__(self, cdm_device, 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.license_url = license_url
         self.mpd_url = mpd_url
+        self.mpd_sub_list = mpd_sub_list or []
         self.out_path = os.path.splitext(os.path.abspath(str(output_path)))[0]
         self.original_output_path = output_path
+        self.file_already_exists = os.path.exists(self.original_output_path)
         self.parser = None
         self._setup_temp_dirs()
 
@@ -52,16 +73,27 @@ class DASH_Downloader:
         """
         Create temporary folder structure under out_path\tmp
         """
+        if self.file_already_exists:
+            return
+
         self.tmp_dir = os.path.join(self.out_path, "tmp")
         self.encrypted_dir = os.path.join(self.tmp_dir, "encrypted")
         self.decrypted_dir = os.path.join(self.tmp_dir, "decrypted")
         self.optimize_dir = os.path.join(self.tmp_dir, "optimize")
+        self.subs_dir = os.path.join(self.tmp_dir, "subs")
         
         os.makedirs(self.encrypted_dir, exist_ok=True)
         os.makedirs(self.decrypted_dir, exist_ok=True)
         os.makedirs(self.optimize_dir, exist_ok=True)
+        os.makedirs(self.subs_dir, exist_ok=True)
 
     def parse_manifest(self, custom_headers):
+        """
+        Parse the MPD manifest file and extract relevant information.
+        """
+        if self.file_already_exists:
+            return
+
         self.parser = MPDParser(self.mpd_url)
         self.parser.parse(custom_headers)
 
@@ -79,15 +111,38 @@ class DASH_Downloader:
             
             data_rows.append(["Video", available_video, set_video, downloadable_video_str])
 
-            # Audio info 
+            # Audio info
             selected_audio, list_available_audio_langs, filter_custom_audio, downloadable_audio = self.parser.select_audio(DOWNLOAD_SPECIFIC_AUDIO)
             self.selected_audio = selected_audio
             
-            available_audio = ', '.join(list_available_audio_langs) if list_available_audio_langs else "Nothing"
-            set_audio = str(filter_custom_audio) if filter_custom_audio else "Nothing"
-            downloadable_audio_str = str(downloadable_audio) if downloadable_audio else "Nothing"
+            if list_available_audio_langs:
+                available_audio = ', '.join(list_available_audio_langs)
+                set_audio = str(filter_custom_audio) if filter_custom_audio else "Nothing"
+                downloadable_audio_str = str(downloadable_audio) if downloadable_audio else "Nothing"
+                
+                data_rows.append(["Audio", available_audio, set_audio, downloadable_audio_str])
+            
+            # Subtitle info
+            available_sub_languages = [sub.get('language') for sub in self.mpd_sub_list]
             
-            data_rows.append(["Audio", available_audio, set_audio, downloadable_audio_str])
+            if available_sub_languages:
+                available_subs = ', '.join(available_sub_languages)
+                
+                # Filter subtitles based on configuration
+                if "*" in DOWNLOAD_SPECIFIC_SUBTITLE:
+                    self.selected_subs = self.mpd_sub_list
+                    downloadable_sub_languages = available_sub_languages
+                else:
+                    self.selected_subs = [
+                        sub for sub in self.mpd_sub_list 
+                        if sub.get('language') in DOWNLOAD_SPECIFIC_SUBTITLE
+                    ]
+                    downloadable_sub_languages = [sub.get('language') for sub in self.selected_subs]
+                
+                downloadable_subs = ', '.join(downloadable_sub_languages) if downloadable_sub_languages else "Nothing"
+                set_subs = ', '.join(DOWNLOAD_SPECIFIC_SUBTITLE) if DOWNLOAD_SPECIFIC_SUBTITLE else "Nothing"
+                
+                data_rows.append(["Subtitle", available_subs, set_subs, downloadable_subs])
             
             # Calculate max width for each column
             headers = ["Type", "Available", "Set", "Downloadable"]
@@ -120,19 +175,77 @@ class DASH_Downloader:
         console.print("")
 
     def get_representation_by_type(self, typ):
+        """
+        Get the representation of the selected stream by type.
+        """
         if typ == "video":
             return getattr(self, "selected_video", None)
         elif typ == "audio":
             return getattr(self, "selected_audio", None)
         return None
 
+    def download_subtitles(self) -> bool:
+        """
+        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)
+        
+        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
+                    
+                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]")
+            
+            if not success:
+                continue
+        
+        return True
+
     def download_and_decrypt(self, custom_headers=None, custom_payload=None):
         """
-        Download and decrypt video/audio streams. Sets self.error, self.stopped, self.output_file.
-        Returns True if successful, False otherwise.
+        Download and decrypt video/audio streams. Skips download if file already exists.
         """
+        if self.file_already_exists:
+            console.print(f"[red]File already exists: {self.original_output_path}[/red]")
+            self.output_file = self.original_output_path
+            return True
+        
         self.error = None
         self.stopped = False
+        video_segments_count = 0
 
         # Fetch keys immediately after obtaining PSSH
         if not self.parser.pssh:
@@ -157,50 +270,106 @@ class DASH_Downloader:
         KID = key['kid']
         KEY = key['key']
 
-        for typ in ["video", "audio"]:
-            rep = self.get_representation_by_type(typ)
-            if rep:
-                encrypted_path = os.path.join(self.encrypted_dir, f"{rep['id']}_encrypted.m4s")
-
-                # If m4s file doesn't exist, start downloading
-                if not os.path.exists(encrypted_path):
-                    downloader = MPD_Segments(
-                        tmp_folder=self.encrypted_dir,
-                        representation=rep,
-                        pssh=self.parser.pssh
-                    )
+        # Download subtitles
+        self.download_subtitles()
 
-                    try:
-                        result = downloader.download_streams()
+        # Download the video to get segment count
+        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")
 
-                        # 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)
+            # 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
+                )
+
+                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)
+                    return False
+
+                # 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
+                )
+
+                if not result_path:
+                    self.error = "Decryption of video failed"
+                    print(self.error)
+                    return False
+
+        else:
+            self.error = "No video found"
+            print(self.error)
+            return False
+            
+        # Now 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
+                )
+
+                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)
+                    return False
 
-                decrypted_path = os.path.join(self.decrypted_dir, f"{typ}.mp4")
+                # 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
                 )
 
                 if not result_path:
-                    self.error = f"Decryption of {typ} failed"
+                    self.error = "Decryption of audio failed"
                     print(self.error)
                     return False
 
-            else:
-                self.error = f"No {typ} found"
-                print(self.error)
-                return False
+        else:
+            self.error = "No audio found"
+            print(self.error)
+            return False
 
         return True
 
@@ -210,8 +379,15 @@ class DASH_Downloader:
         pass
 
     def finalize_output(self):
-
-        # Definenition of decrypted files
+        """
+        Merge video, audio, and optionally subtitles into final output file.
+        """
+        if self.file_already_exists:
+            output_file = self.original_output_path
+            self.output_file = output_file
+            return output_file
+        
+        # Definition of decrypted files
         video_file = os.path.join(self.decrypted_dir, "video.mp4")
         audio_file = os.path.join(self.decrypted_dir, "audio.mp4")
         output_file = self.original_output_path
@@ -220,23 +396,63 @@ class DASH_Downloader:
         self.output_file = output_file
         use_shortest = False
 
+        # Merge video and audio
         if os.path.exists(video_file) and os.path.exists(audio_file):
             audio_tracks = [{"path": audio_file}]
-            _, use_shortest = join_audios(video_file, audio_tracks, output_file)
-
+            merged_file, use_shortest = join_audios(video_file, audio_tracks, output_file)
+            
         elif os.path.exists(video_file):
-            _ = join_video(video_file, output_file, codec=None)
-
+            merged_file = join_video(video_file, output_file, codec=None)
+            
         else:
             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:
+
+            # Check which subtitle files actually exist
+            existing_sub_tracks = []
+            for sub in self.selected_subs:
+                language = sub.get('language', 'unknown')
+                fmt = sub.get('format', 'vtt')
+                sub_path = os.path.join(self.subs_dir, f"{language}.{fmt}")
+                
+                if os.path.exists(sub_path):
+                    existing_sub_tracks.append({
+                        'path': sub_path,
+                        'language': language
+                    })
+            
+            if existing_sub_tracks:
+
+                # Create temporary file for subtitle merge
+                temp_output = output_file.replace('.mp4', '_temp.mp4')
+                
+                try:
+                    final_file = join_subtitle(
+                        video_path=merged_file,
+                        subtitles_list=existing_sub_tracks,
+                        out_path=temp_output
+                    )
+                    
+                    # Replace original with subtitled version
+                    if os.path.exists(final_file):
+                        if os.path.exists(output_file):
+                            os.remove(output_file)
+                        os.rename(final_file, output_file)
+                        merged_file = output_file
+                        
+                except Exception as e:
+                    console.print(f"[yellow]Warning: Failed to merge subtitles: {e}[/yellow]")
+        
         # Handle failed sync case
         if use_shortest:
             new_filename = output_file.replace(".mp4", "_failed_sync.mp4")
-            os.rename(output_file, new_filename)
-            output_file = new_filename
-            self.output_file = new_filename
+            if os.path.exists(output_file):
+                os.rename(output_file, new_filename)
+                output_file = new_filename
+                self.output_file = new_filename
 
         # Display file information
         if os.path.exists(output_file):
@@ -291,4 +507,4 @@ class DASH_Downloader:
             "path": self.output_file,
             "error": self.error,
             "stopped": self.stopped
-        }
+        }