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

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
 
 
 # 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,55 +97,58 @@ 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")
 
-                downloader = MPD_Segments(
-                    tmp_folder=self.encrypted_dir,
-                    representation=rep,
-                    pssh=self.parser.pssh
-                )
-
-                try:
-                    result = downloader.download_streams()
-
-                    # 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']}"
+                # 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
+                    )
+
+                    try:
+                        result = downloader.download_streams()
+
+                        # 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
-                    
-                except Exception as ex:
-                    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(
@@ -167,46 +173,74 @@ class DASH_Downloader:
         pass
 
     def finalize_output(self):
-        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
+
+        # Use the original output path for the final file
         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):
+        """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)
+            out_audio_path, use_shortest = join_audios(video_file, audio_tracks, output_file)
+
         elif os.path.exists(video_file):
-            join_video(video_file, output_file, codec=None)
+            out_video_path = join_video(video_file, output_file, codec=None)
+        
         else:
             print("Video file missing, cannot export")
+            return None
+        """
 
-        # Clean up: delete all tmp
+        # 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"
+            ))
+
+        # 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)
+            except Exception as e:
+                print(f"[WARN] Cannot remove directory {self.out_path}: {e}")
 
-        return self.output_file
-
+        # 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.
@@ -215,4 +249,4 @@ class DASH_Downloader:
             "path": self.output_file,
             "error": self.error,
             "stopped": self.stopped
-        }
+        }

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -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:
@@ -467,9 +468,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 +496,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,7 +524,18 @@ 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,

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/Downloader/MP4/downloader.py

@@ -7,6 +7,7 @@ import time
 import signal
 import logging
 from functools import partial
+import threading
 
 
 # External libraries
@@ -101,10 +102,23 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
     else:
         headers['User-Agent'] = get_userAgent()
 
-    # Set interrupt handler
+    # Set interrupt handler (only in main thread). In background threads (e.g., Django), skip custom signal handling.
     temp_path = f"{path}.temp"
     interrupt_handler = InterruptHandler()
-    original_handler = signal.signal(signal.SIGINT, partial(signal_handler, interrupt_handler=interrupt_handler, original_handler=signal.getsignal(signal.SIGINT)))
+    original_handler = None
+    try:
+        if threading.current_thread() is threading.main_thread():
+            original_handler = signal.signal(
+                signal.SIGINT,
+                partial(
+                    signal_handler,
+                    interrupt_handler=interrupt_handler,
+                    original_handler=signal.getsignal(signal.SIGINT),
+                ),
+            )
+    except Exception:
+        # If setting signal handler fails (non-main thread), continue without it
+        original_handler = None
 
     # Ensure the output directory exists
     os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -184,4 +198,8 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
         return None, interrupt_handler.kill_download
     
     finally:
-        signal.signal(signal.SIGINT, original_handler)
+        if original_handler is not None:
+            try:
+                signal.signal(signal.SIGINT, original_handler)
+            except Exception:
+                pass

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/Upload/update.py

@@ -90,7 +90,7 @@ def update():
         latest_commit_message = 'No commit history available'
 
     console.print(f"\n[cyan]Current installed version: [yellow]{current_version}")
-    console.print(f"[cyan]Last commit: [yellow]{latest_commit_message}")
+    console.print(f"[cyan]Last commit: [yellow]{latest_commit_message.splitlines()[0]}")
     
     if str(current_version).replace('v', '') != str(last_version).replace('v', ''):
         console.print(f"\n[cyan]New version available: [yellow]{last_version}")
@@ -98,4 +98,4 @@ def update():
     console.print(f"\n[red]{__title__} has been downloaded [yellow]{total_download_count} [red]times, but only [yellow]{percentual_stars}% [red]of users have starred it.\n\
         [cyan]Help the repository grow today by leaving a [yellow]star [cyan]and [yellow]sharing [cyan]it with others online!")
     
-    time.sleep(4)
+    time.sleep(4)

StreamingCommunity/Upload/version.py

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

StreamingCommunity/Util/os.py

@@ -435,7 +435,10 @@ class OsSummary:
         ffmpeg_str = f"'{self.ffmpeg_path}'" if self.ffmpeg_path else "None"
         ffprobe_str = f"'{self.ffprobe_path}'" if self.ffprobe_path else "None"
         mp4decrypt_str = f"'{self.mp4decrypt_path}'" if self.mp4decrypt_path else "None"
-        console.print(f"[cyan]Path: [red]ffmpeg [bold yellow]{ffmpeg_str}[/bold yellow][white], [red]ffprobe [bold yellow]{ffprobe_str}[/bold yellow][white], [red]mp4decrypt [bold yellow]{mp4decrypt_str}[/bold yellow]")
+        wvd_path = get_wvd_path()
+        wvd_str = f"'{wvd_path}'" if wvd_path else "None"
+        
+        console.print(f"[cyan]Path: [red]ffmpeg [bold yellow]{ffmpeg_str}[/bold yellow][white], [red]ffprobe [bold yellow]{ffprobe_str}[/bold yellow][white], [red]mp4decrypt [bold yellow]{mp4decrypt_str}[/bold yellow][white], [red]wvd [bold yellow]{wvd_str}[/bold yellow]")
 
 
 os_manager = OsManager()

StreamingCommunity/run.py

@@ -329,13 +329,13 @@ def check_dns_and_exit_if_needed():
     ]
     
     if not internet_manager.check_dns_resolve(hostname_list):
-        console.print("[red] ERROR: DNS configuration is required!")
+        console.print("[red]\nERROR: DNS configuration is required!")
         console.print("[red]The program cannot function correctly without proper DNS settings.")
-        console.print("[yellow]Please configure one of these DNS servers:")
+        console.print("\n[yellow]Please configure one of these DNS servers:")
         console.print("[red]• Cloudflare (1.1.1.1) 'https://developers.cloudflare.com/1.1.1.1/setup/windows/'")
         console.print("[red]• Quad9 (9.9.9.9) 'https://docs.quad9.net/Setup_Guides/Windows/Windows_10/'")
-        console.print("\n[yellow]⚠️ The program will not work until you configure your DNS settings.")
-        os._exit(0)
+        console.print("\n[yellow]-> The program will not work until you configure your DNS settings.")
+        sys.exit(0)
 
 
 def setup_argument_parser(search_functions):

{streamingcommunity-3.2.9.dist-info → streamingcommunity-3.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: StreamingCommunity
-Version: 3.2.9
+Version: 3.3.1
 Home-page: https://github.com/Lovi-0/StreamingCommunity
 Author: Lovi-0
 Project-URL: Bug Reports, https://github.com/Lovi-0/StreamingCommunity/issues
@@ -25,6 +25,7 @@ Requires-Dist: ua-generator
 Requires-Dist: qbittorrent-api
 Requires-Dist: pyTelegramBotAPI
 Requires-Dist: pywidevine
+Requires-Dist: seleniumbase
 Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
@@ -913,17 +914,11 @@ python3 telegram_bot.py
 - [Pypy](https://www.youtube.com/watch?v=C6m9ZKOK0p4)
 - [Compiled](https://www.youtube.com/watch?v=pm4lqsxkTVo)
 
-# To Do
-
-- To Finish [website API](https://github.com/Arrowar/StreamingCommunity/tree/test_gui_1)
-- To finish [website API 2](https://github.com/hydrosh/StreamingCommunity/tree/test_gui_1)
-
 ## Useful Project
 
 ### 🎯 [Unit3Dup](https://github.com/31December99/Unit3Dup)
 Bot in Python per la generazione e l'upload automatico di torrent su tracker basati su Unit3D.
 
-
 ### 🇮🇹 [MammaMia](https://github.com/UrloMythus/MammaMia)
 Addon per Stremio che consente lo streaming HTTPS di film, serie, anime e TV in diretta in lingua italiana.