StreamingCommunity 3.3.0__py3-none-any.whl → 3.3.2__py3-none-any.whl

StreamingCommunity/Api/Site/streamingwatch/site.py

@@ -86,9 +86,6 @@ def title_search(query: str) -> int:
         soup = BeautifulSoup(response.text, 'html.parser')
 
     except Exception as e:
-        if "WinError" in str(e) or "Errno" in str(e): 
-            console.print("\n[bold yellow]Please make sure you have enabled and configured a valid proxy.[/bold yellow]")
-            
         console.print(f"[red]Site: {site_constant.SITE_NAME}, request search error: {e}")
         return 0
 

StreamingCommunity/Lib/Downloader/DASH/cdm_helpher.py

@@ -29,29 +29,11 @@ def get_widevine_keys(pssh, license_url, cdm_device_path, headers=None, payload=
     Returns:
         list: List of dicts {'kid': ..., 'key': ...} (only CONTENT keys) or None if error.
     """
-
-    # Check if PSSH is a valid base64 string
-    try:
-        base64.b64decode(pssh)
-    except Exception:
-        console.print("[bold red] Invalid PSSH base64 string.[/bold red]")
-        return None
-
     try:
         device = Device.load(cdm_device_path)
         cdm = Cdm.from_device(device)
         session_id = cdm.open()
 
-        # Display security level in a more readable format
-        security_levels = {1: "L1 (Hardware)", 2: "L2 (Software)", 3: "L3 (Software)"}
-        security_level_str = security_levels.get(device.security_level, 'Unknown')
-        logging.info(f"Security Level: {security_level_str}")
-
-        # Only allow L3, otherwise warn and exit
-        if device.security_level != 3:
-            console.print(f"[bold yellow]⚠️ Only L3 (Software) security level is supported. Current: {security_level_str}[/bold yellow]")
-            return None
-
         try:
             challenge = cdm.get_license_challenge(session_id, PSSH(pssh))
             req_headers = headers or {}
@@ -108,6 +90,7 @@ def get_widevine_keys(pssh, license_url, cdm_device_path, headers=None, payload=
             content_keys = []
             for key in cdm.get_keys(session_id):
                 if key.type == "CONTENT":
+                    
                     kid = key.kid.hex() if isinstance(key.kid, bytes) else str(key.kid)
                     key_val = key.key.hex() if isinstance(key.key, bytes) else str(key.key)
 

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -6,11 +6,13 @@ import shutil
 
 # External libraries
 from rich.console import Console
+from rich.panel import Panel
 
 
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
-from StreamingCommunity.Lib.FFmpeg.command import join_audios, join_video
+from StreamingCommunity.Util.os import internet_manager
+from ...FFmpeg import print_duration_table, join_audios, join_video
 
 
 # Logic class
@@ -20,6 +22,7 @@ from .decrypt import decrypt_with_mp4decrypt
 from .cdm_helpher import get_widevine_keys
 
 
+
 # Config
 DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_audio')
 FILTER_CUSTOM_REOLUTION = str(config_manager.get('M3U8_CONVERSION', 'force_resolution')).strip().lower()
@@ -35,8 +38,8 @@ class DASH_Downloader:
         self.cdm_device = cdm_device
         self.license_url = license_url
         self.mpd_url = mpd_url
-        self.original_output_path = os.path.abspath(str(output_path))
-        self.out_path = os.path.splitext(self.original_output_path)[0]
+        self.out_path = os.path.splitext(os.path.abspath(str(output_path)))[0]
+        self.original_output_path = output_path
         self.parser = None
         self._setup_temp_dirs()
 
@@ -94,12 +97,35 @@ class DASH_Downloader:
         self.error = None
         self.stopped = False
 
+        # 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
+
+        keys = get_widevine_keys(
+            pssh=self.parser.pssh,
+            license_url=self.license_url,
+            cdm_device_path=self.cdm_device,
+            headers=custom_headers,
+            payload=custom_payload
+        )
+
+        if not keys:
+            console.print("[red]No keys found, cannot proceed with download.[/red]")
+            return False
+
+        # Extract the first key for decryption
+        key = keys[0]
+        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 m4s file doesn't exist, start downloading
                 if not os.path.exists(encrypted_path):
                     downloader = MPD_Segments(
                         tmp_folder=self.encrypted_dir,
@@ -124,28 +150,6 @@ class DASH_Downloader:
                         self.error = str(ex)
                         return False
 
-                if not self.parser.pssh:
-                    print("No PSSH found: segments are not encrypted, skipping decryption.")
-                    self.download_segments(clear=True)
-                    return True
-
-                keys = get_widevine_keys(
-                    pssh=self.parser.pssh,
-                    license_url=self.license_url,
-                    cdm_device_path=self.cdm_device,
-                    headers=custom_headers,
-                    payload=custom_payload
-                )
-                
-                if not keys:
-                    self.error = f"No key found, cannot decrypt {typ}"
-                    print(self.error)
-                    return False
-
-                key = keys[0]
-                KID = key['kid']
-                KEY = key['key']
-
                 decrypted_path = os.path.join(self.decrypted_dir, f"{typ}.mp4")
                 result_path = decrypt_with_mp4decrypt(
                     encrypted_path, KID, KEY, output_path=decrypted_path
@@ -169,46 +173,78 @@ class DASH_Downloader:
         pass
 
     def finalize_output(self):
+
+        # Definenition of decrypted files
         video_file = os.path.join(self.decrypted_dir, "video.mp4")
         audio_file = os.path.join(self.decrypted_dir, "audio.mp4")
-
-        # fallback: if one of the two is missing, look in encrypted
-        if not os.path.exists(video_file):
-            for f in os.listdir(self.encrypted_dir):
-                if f.endswith("_encrypted.m4s") and ("video" in f or f.startswith("1_")):
-                    video_file = os.path.join(self.encrypted_dir, f)
-                    break
-        if not os.path.exists(audio_file):
-            for f in os.listdir(self.encrypted_dir):
-                if f.endswith("_encrypted.m4s") and ("audio" in f or f.startswith("0_")):
-                    audio_file = os.path.join(self.encrypted_dir, f)
-                    break
-
-        # Usa il nome file originale per il file finale
         output_file = self.original_output_path
+        
+        # Set the output file path for status tracking
+        self.output_file = output_file
+        use_shortest = False
 
         if os.path.exists(video_file) and os.path.exists(audio_file):
             audio_tracks = [{"path": audio_file}]
-            join_audios(video_file, audio_tracks, output_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)
+            _ = join_video(video_file, output_file, codec=None)
+
+        else:
+            console.print("[red]Video file missing, cannot export[/red]")
+            return None
+        
+        # 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
+
+        # Display file information
+        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]"
+            )
+
+            console.print(Panel(
+                panel_content,
+                title=f"{os.path.basename(output_file.replace('.mp4', ''))}",
+                border_style="green"
+            ))
+
         else:
-            print("Video file missing, cannot export")
+            console.print(f"[red]Output file not found: {output_file}")
 
-        # Clean up: delete all tmp
+        # Clean up: delete only the tmp directory, not the main directory
         if os.path.exists(self.tmp_dir):
             shutil.rmtree(self.tmp_dir, ignore_errors=True)
 
-        # Rimuovi la cartella principale se è vuota
-        try:
-            if os.path.exists(self.out_path) and not os.listdir(self.out_path):
-                os.rmdir(self.out_path)
-        except Exception as e:
-            print(f"[WARN] Impossibile eliminare la cartella {self.out_path}: {e}")
+        # Only remove the temp base directory if it was created specifically for this download
+        # and if the final output is NOT inside this directory
+        output_dir = os.path.dirname(self.original_output_path)
         
+        # Check if out_path is different from the actual output directory
+        # and if it's empty, then it's safe to remove
+        if (self.out_path != output_dir and os.path.exists(self.out_path) and not os.listdir(self.out_path)):
+            try:
+                os.rmdir(self.out_path)
 
-        return self.output_file
+            except Exception as e:
+                console.print(f"[red]Cannot remove directory {self.out_path}: {e}")
 
+        # Verify the final file exists before returning
+        if os.path.exists(output_file):
+            return output_file
+        else:
+            self.error = "Final output file was not created successfully"
+            return None
+    
     def get_status(self):
         """
         Returns a dict with 'path', 'error', and 'stopped' for external use.
@@ -217,4 +253,4 @@ class DASH_Downloader:
             "path": self.output_file,
             "error": self.error,
             "stopped": self.stopped
-        }
+        }

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -39,6 +39,7 @@ DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_lis
 DOWNLOAD_SPECIFIC_SUBTITLE = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_subtitles')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
+GET_ONLY_LINK = config_manager.get_int('M3U8_DOWNLOAD', 'get_only_link')
 FILTER_CUSTOM_RESOLUTION = str(config_manager.get('M3U8_CONVERSION', 'force_resolution')).strip().lower()
 RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
@@ -63,7 +64,6 @@ class HLSClient:
         Returns:
             Response content/text or None if all retries fail
         """
-        # Use unified HTTP client (inherits timeout/verify/proxy from config)
         client = create_client(headers=self.headers)
 
         for attempt in range(RETRY_LIMIT):
@@ -211,10 +211,10 @@ class M3U8Manager:
         # Get available subtitles and their languages
         available_subtitles = self.parser._subtitle.get_all_uris_and_names() or []
         available_sub_languages = [sub.get('language') for sub in available_subtitles]
-        
+
         # If "*" is in DOWNLOAD_SPECIFIC_SUBTITLE, all languages are downloadable
         downloadable_sub_languages = available_sub_languages if "*" in DOWNLOAD_SPECIFIC_SUBTITLE else list(set(available_sub_languages) & set(DOWNLOAD_SPECIFIC_SUBTITLE))
-            
+
         if available_sub_languages:
             console.print(
                 f"[cyan bold]Subtitle [/cyan bold] [green]Available:[/green] [purple]{', '.join(available_sub_languages)}[/purple] | "
@@ -260,7 +260,7 @@ class DownloadManager:
 
         if result.get('stopped', False):
             self.stopped = True
-        
+
         return self.stopped
 
     def download_audio(self, audio: Dict):
@@ -304,7 +304,7 @@ class DownloadManager:
         """
         return_stopped = False
         video_file = os.path.join(self.temp_dir, 'video', '0.ts')
-        
+
         if not os.path.exists(video_file):
             if self.download_video(video_url):
                 if not return_stopped:
@@ -360,6 +360,7 @@ class MergeManager:
         """
         video_file = os.path.join(self.temp_dir, 'video', '0.ts')
         merged_file = video_file
+        use_shortest = False
 
         if not self.audio_streams and not self.sub_streams:
             merged_file = join_video(
@@ -376,7 +377,7 @@ class MergeManager:
                 } for a in self.audio_streams]
 
                 merged_audio_path = os.path.join(self.temp_dir, 'merged_audio.mp4')
-                merged_file = join_audios(
+                merged_file, use_shortest = join_audios(
                     video_path=video_file,
                     audio_tracks=audio_tracks,
                     out_path=merged_audio_path,
@@ -396,7 +397,7 @@ class MergeManager:
                     out_path=merged_subs_path
                 )
 
-        return merged_file
+        return merged_file, use_shortest
 
 
 class HLS_Downloader:
@@ -420,8 +421,20 @@ class HLS_Downloader:
                 - is_master: Whether the M3U8 was a master playlist
             Or raises an exception if there's an error
         """
+
+        if GET_ONLY_LINK:
+            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': None,
+                'stopped': True
+            }
+
         console.print("[cyan]You can safely stop the download with [bold]Ctrl+c[bold] [cyan] \n")
-        
+
         if TELEGRAM_BOT:
             bot = get_bot_instance()
 
@@ -439,7 +452,7 @@ class HLS_Downloader:
                 if TELEGRAM_BOT:
                     bot.send_message("Contenuto già scaricato!", None)
                 return response
-        
+
             self.path_manager.setup_directories()
 
             # Parse M3U8 and determine if it's a master playlist
@@ -467,9 +480,9 @@ class HLS_Downloader:
                 sub_streams=self.m3u8_manager.sub_streams
             )
 
-            final_file = self.merge_manager.merge()
+            final_file, use_shortest = self.merge_manager.merge()
             self.path_manager.move_final_file(final_file)
-            self._print_summary()
+            self._print_summary(use_shortest)
             self.path_manager.cleanup()
 
             return {
@@ -495,7 +508,7 @@ class HLS_Downloader:
                 'stopped': False
             }
 
-    def _print_summary(self):
+    def _print_summary(self, use_shortest):
         """Prints download summary including file size, duration, and any missing segments."""
         if TELEGRAM_BOT:
             bot = get_bot_instance()
@@ -523,10 +536,21 @@ class HLS_Downloader:
 
         if missing_ts:
             panel_content += f"\n{missing_info}"
-            os.rename(self.path_manager.output_path, self.path_manager.output_path.replace(".mp4", "_failed.mp4"))
+
+        new_filename = self.path_manager.output_path
+        if missing_ts and use_shortest:
+            new_filename = new_filename.replace(".mp4", "_failed_sync_ts.mp4")
+        elif missing_ts:
+            new_filename = new_filename.replace(".mp4", "_failed_ts.mp4")
+        elif use_shortest:
+            new_filename = new_filename.replace(".mp4", "_failed_sync.mp4")
+
+        if missing_ts or use_shortest:
+            os.rename(self.path_manager.output_path, new_filename)
+            self.path_manager.output_path = new_filename
 
         console.print(Panel(
             panel_content,
             title=f"{os.path.basename(self.path_manager.output_path.replace('.mp4', ''))}",
             border_style="green"
-        ))
+        ))

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -249,7 +249,7 @@ class M3U8_Segments:
                 self.info_nRetry += 1
 
                 if attempt + 1 == REQUEST_MAX_RETRY:
-                    console.log(f"[red]Final retry failed for segment: {index}")
+                    console.print(f"[red]Final retry failed for segment: {index}")
                     self.queue.put((index, None))  # Marker for failed segment
                     progress_bar.update(1)
                     self.info_nFailed += 1

StreamingCommunity/Lib/FFmpeg/command.py

@@ -15,7 +15,7 @@ from StreamingCommunity.Util.os import os_manager, suppress_output, get_ffmpeg_p
 
 
 # Logic class
-from .util import need_to_force_to_ts, check_duration_v_a
+from .util import need_to_force_to_ts, check_duration_v_a, get_video_duration
 from .capture import capture_ffmpeg_real_time
 from ..M3U8 import M3U8_Codec
 
@@ -99,6 +99,14 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
         - out_path (str): The path to save the output file.
         - codec (M3U8_Codec): The video codec to use. Defaults to 'copy'.
     """
+    if video_path is None:
+        console.log("[red]No video path provided for joining.")
+        return None
+    
+    if out_path is None:
+        console.log("[red]No output path provided for joining.")
+        return None
+
     ffmpeg_cmd = [get_ffmpeg_path()]
 
     # Enabled the use of gpu
@@ -175,10 +183,50 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
     Parameters:
         - video_path (str): The path to the video file.
         - audio_tracks (list[dict[str, str]]): A list of dictionaries containing information about audio tracks.
-            Each dictionary should contain the 'path' key with the path to the audio file.
+            Each dictionary should contain the 'path' and 'name' keys.
         - out_path (str): The path to save the output file.
     """
-    video_audio_same_duration, duration_diff = check_duration_v_a(video_path, audio_tracks[0].get('path'))
+    if video_path is None:
+        console.log("[red]No video path provided for joining audios.")
+        return None, False
+
+    if audio_tracks is None or len(audio_tracks) == 0:
+        console.log("[red]No audio tracks provided for joining.")
+        return None, False
+
+    if out_path is None:
+        console.log("[red]No output path provided for joining audios.")
+        return None, False
+
+    use_shortest = False
+    duration_diffs = []
+    
+    # Get video duration first
+    video_duration = get_video_duration(video_path, None)
+    
+    for audio_track in audio_tracks:
+        audio_path = audio_track.get('path')
+        audio_lang = audio_track.get('name', 'unknown')
+        audio_duration, diff = check_duration_v_a(video_path, audio_path)
+        
+        duration_diffs.append({
+            'language': audio_lang,
+            'difference': diff,
+            'has_error': diff > 0.5,
+            'video_duration': video_duration,
+            'audio_duration': audio_duration
+        })
+        
+        if diff > 0.5:
+            use_shortest = True
+            console.log("[red]Warning: Some audio tracks have duration differences (>0.5s)")
+
+    # Print duration differences for each track
+    if use_shortest:
+        for track in duration_diffs:
+            color = "red" if track['has_error'] else "green"
+            console.print(f"[{color}]Audio {track['language']}: Video duration: {track['video_duration']:.2f}s, Audio duration: {track['audio_duration']:.2f}s, Difference: {track['difference']:.2f}s[/{color}]")
+    
 
     # Start command with locate ffmpeg
     ffmpeg_cmd = [get_ffmpeg_path()]
@@ -238,9 +286,8 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
     else:
         ffmpeg_cmd.extend(['-preset', 'fast'])
 
-    # Use shortest input path for video and audios
-    if not video_audio_same_duration:
-        console.log(f"[red]Use shortest input (Duration difference: {duration_diff:.2f} seconds)...")
+    # Use shortest input path if any audio track has significant difference
+    if use_shortest:
         ffmpeg_cmd.extend(['-shortest', '-strict', 'experimental'])
 
     # Overwrite
@@ -261,7 +308,7 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
                 capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join audio")
                 print()
 
-    return out_path
+    return out_path, use_shortest
 
 
 def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_path: str):
@@ -274,6 +321,18 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
             Each dictionary should contain the 'path' key with the path to the subtitle file and the 'name' key with the name of the subtitle.
         - out_path (str): The path to save the output file.
     """
+    if video_path is None:
+        console.log("[red]No video path provided for joining subtitles.")
+        return None
+
+    if subtitles_list is None or len(subtitles_list) == 0:
+        console.log("[red]No subtitles provided for joining.")
+        return None
+
+    if out_path is None:
+        console.log("[red]No output path provided for joining subtitles.")
+        return None
+
     ffmpeg_cmd = [get_ffmpeg_path(), "-i", video_path]
 
     # Add subtitle input files first

StreamingCommunity/Lib/FFmpeg/util.py

@@ -47,15 +47,16 @@ def has_audio_stream(video_path: str) -> bool:
         return False
 
 
-def get_video_duration(file_path: str) -> float:
+def get_video_duration(file_path: str, file_type: str = "file") -> float:
     """
-    Get the duration of a video file.
+    Get the duration of a media file (video or audio).
 
     Parameters:
-        - file_path (str): The path to the video file.
+        - file_path (str): The path to the media file.
+        - file_type (str): The type of the file ('video' or 'audio'). Defaults to 'file'.
 
     Returns:
-        (float): The duration of the video in seconds if successful, None if there's an error.
+        (float): The duration of the media file in seconds if successful, None if there's an error.
     """
     try:
         ffprobe_cmd = [get_ffprobe_path(), '-v', 'error', '-show_format', '-print_format', 'json', file_path]
@@ -64,23 +65,23 @@ def get_video_duration(file_path: str) -> float:
         # Use a with statement to ensure the subprocess is cleaned up properly
         with subprocess.Popen(ffprobe_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) as proc:
             stdout, stderr = proc.communicate()
-            
+
             if proc.returncode != 0:
                 logging.error(f"Error: {stderr}")
                 return None
-            
+
             # Parse JSON output
             probe_result = json.loads(stdout)
 
-            # Extract duration from the video information
+            # Extract duration from the media information
             try:
                 return float(probe_result['format']['duration'])
-            
+
             except Exception:
                 return 1
 
     except Exception as e:
-        logging.error(f"Get video duration error: {e}")
+        logging.error(f"Get {file_type} duration error: {e}, ffprobe path: {get_ffprobe_path()}, file path: {file_path}")
         sys.exit(0)
 
 
@@ -242,20 +243,22 @@ def check_duration_v_a(video_path, audio_path, tolerance=1.0):
     Returns:
         - tuple: (bool, float) -> True if the duration of the video and audio matches, False otherwise, along with the difference in duration.
     """
-    video_duration = get_video_duration(video_path)
-    audio_duration = get_video_duration(audio_path)
+    video_duration = get_video_duration(video_path, file_type="video")
+    audio_duration = get_video_duration(audio_path, file_type="audio")
 
     # Check if either duration is None and specify which one is None
     if video_duration is None and audio_duration is None:
         console.print("[yellow]Warning: Both video and audio durations are None. Returning 0 as duration difference.[/yellow]")
         return False, 0.0
+    
     elif video_duration is None:
         console.print("[yellow]Warning: Video duration is None. Returning 0 as duration difference.[/yellow]")
         return False, 0.0
+    
     elif audio_duration is None:
         console.print("[yellow]Warning: Audio duration is None. Returning 0 as duration difference.[/yellow]")
         return False, 0.0
-
+    
     # Calculate the duration difference
     duration_difference = abs(video_duration - audio_duration)
 
@@ -263,4 +266,4 @@ def check_duration_v_a(video_path, audio_path, tolerance=1.0):
     if duration_difference <= tolerance:
         return True, duration_difference
     else:
-        return False, duration_difference
+        return False, duration_difference

StreamingCommunity/Lib/M3U8/decryptor.py

@@ -78,18 +78,4 @@ class M3U8_Decryption:
         else:
             raise ValueError("Invalid or unsupported method")
 
-        """
-        end = time.perf_counter_ns()
-
-        # Calculate the elapsed time with high precision
-        elapsed_nanoseconds = end - start
-        elapsed_milliseconds = elapsed_nanoseconds / 1_000_000
-        elapsed_seconds = elapsed_nanoseconds / 1_000_000_000
-
-        # Log performance metrics
-        logging.info("[Crypto Decryption Performance]")
-        logging.info(f"Method: {self.method}")
-        logging.info(f"Decryption Time: {elapsed_milliseconds:.4f} ms ({elapsed_seconds:.6f} s)")
-        logging.info(f"Decrypted Content Length: {len(decrypted_content)} bytes")
-        """
         return decrypted_content

StreamingCommunity/Lib/TMBD/tmdb.py

@@ -1,7 +1,6 @@
 # 24.08.24
 
 import sys
-from typing import Dict
 
 
 # External libraries
@@ -95,7 +94,6 @@ class TheMovieDB:
         """
         self.api_key = api_key
         self.base_url = "https://api.themoviedb.org/3"
-        #self.genres = self._fetch_genres()
         self._cached_trending_tv = None
         self._cached_trending_movies = None
 
@@ -120,16 +118,6 @@ class TheMovieDB:
         
         return response.json()
 
-    def _fetch_genres(self) -> Dict[int, str]:
-        """
-        Fetch and return the genre names from TheMovieDB.
-
-        Returns:
-            Dict[int, str]: A dictionary mapping genre IDs to genre names.
-        """
-        genres = self._make_request("genre/movie/list")
-        return {genre['id']: genre['name'] for genre in genres.get('genres', [])}
-
     def _display_top_5(self, category: str, data, name_key='title'):
         """
         Display top 5 most popular items in a single line with colors.

StreamingCommunity/Upload/version.py

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