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

StreamingCommunity/Lib/FFmpeg/command.py

@@ -10,12 +10,12 @@ from rich.console import Console
 
 
 # Internal utilities
-from StreamingCommunity.Util.config_json import config_manager, get_use_large_bar
-from StreamingCommunity.Util.os import os_manager, suppress_output, get_ffmpeg_path
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.os import get_ffmpeg_path
 
 
 # Logic class
-from .util import need_to_force_to_ts, check_duration_v_a, get_video_duration
+from .util import need_to_force_to_ts, check_duration_v_a
 from .capture import capture_ffmpeg_real_time
 from ..M3U8 import M3U8_Codec
 
@@ -82,6 +82,7 @@ def select_subtitle_encoder() -> Optional[str]:
     if mov_text_supported:
         logging.info("Using 'mov_text' as the subtitle encoder.")
         return "mov_text"
+    
     elif webvtt_supported:
         logging.info("Using 'webvtt' as the subtitle encoder.")
         return "webvtt"
@@ -99,14 +100,6 @@ 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
@@ -115,7 +108,6 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
 
     # Add mpegts to force to detect input file as ts file
     if need_to_force_to_ts(video_path):
-        #console.log("[red]Force input file to 'mpegts'.")
         ffmpeg_cmd.extend(['-f', 'mpegts'])
 
     # Insert input video path
@@ -162,21 +154,13 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
     else:
-
-        if get_use_large_bar():
-            capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join video")
-            print()
-
-        else:
-            console.log("[purple]FFmpeg [white][[cyan]Join video[white]] ...")
-            with suppress_output():
-                capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join video")
-                print()
+        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join video")
+        print()
 
     return out_path
 
 
-def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: str, codec: M3U8_Codec = None):
+def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: str, codec: M3U8_Codec = None, limit_duration_diff: float = 2.0):
     """
     Joins audio tracks with a video file using FFmpeg.
     
@@ -186,47 +170,31 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
             Each dictionary should contain the 'path' and 'name' keys.
         - out_path (str): The path to save the output file.
     """
-    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)
+        is_matched, diff, video_duration, audio_duration = check_duration_v_a(video_path, audio_path)
         
         duration_diffs.append({
             'language': audio_lang,
             'difference': diff,
-            'has_error': diff > 0.5,
+            'has_error': diff > limit_duration_diff,
             'video_duration': video_duration,
             'audio_duration': audio_duration
         })
         
-        if diff > 0.5:
+        # If any audio track has a significant duration difference, use -shortest
+        if diff > limit_duration_diff:
             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()]
@@ -240,10 +208,8 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
 
     # Add audio tracks as input
     for i, audio_track in enumerate(audio_tracks):
-        if os_manager.check_file(audio_track.get('path')):
-            ffmpeg_cmd.extend(['-i', audio_track.get('path')])
-        else:
-            logging.error(f"Skip audio join: {audio_track.get('path')} dont exist")
+        ffmpeg_cmd.extend(['-i', audio_track.get('path')])
+
 
     # Map the video and audio streams
     ffmpeg_cmd.append('-map')
@@ -298,15 +264,8 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
         subprocess.run(ffmpeg_cmd, check=True)
         
     else:
-        if get_use_large_bar():
-            capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join audio")
-            print()
-
-        else:
-            console.log("[purple]FFmpeg [white][[cyan]Join audio[white]] ...")
-            with suppress_output():
-                capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join audio")
-                print()
+        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join audio")
+        print()
 
     return out_path, use_shortest
 
@@ -321,26 +280,11 @@ 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
     for subtitle in subtitles_list:
-        if os_manager.check_file(subtitle.get('path')):
-            ffmpeg_cmd += ["-i", subtitle['path']]
-        else:
-            logging.error(f"Skip subtitle join: {subtitle.get('path')} doesn't exist")
+        ffmpeg_cmd += ["-i", subtitle['path']]
 
     # Add maps for video and audio streams
     ffmpeg_cmd += ["-map", "0:v", "-map", "0:a"]
@@ -365,14 +309,7 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
         subprocess.run(ffmpeg_cmd, check=True)
 
     else:
-        if get_use_large_bar():
-            capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join subtitle")
-            print()
-
-        else:
-            console.log("[purple]FFmpeg [white][[cyan]Join subtitle[white]] ...")
-            with suppress_output():
-                capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join subtitle")
-                print()
+        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join subtitle")
+        print()
 
     return out_path

StreamingCommunity/Lib/FFmpeg/util.py

@@ -154,7 +154,7 @@ def get_ffprobe_info(file_path):
             cmd,
             capture_output=True,
             text=True,
-            check=False  # Don't raise exception on non-zero exit
+            check=False
         )
 
         if result.returncode != 0:
@@ -206,7 +206,7 @@ def need_to_force_to_ts(file_path):
     file_info = get_ffprobe_info(file_path)
 
     if is_png_format_or_codec(file_info):
-       console.print(f"[yellow]Warning: The input file [green]{os.path.basename(file_path)}[/green] is in PNG format or contains a PNG codec. It will be converted to TS format for processing.[/yellow]")
+       logging.info(f"File {file_path} is in PNG format or contains a PNG codec. Need to convert to TS format.")
        return True
     
     return False
@@ -222,7 +222,11 @@ def check_duration_v_a(video_path, audio_path, tolerance=1.0):
         - tolerance (float): Allowed tolerance for the duration difference (in seconds).
 
     Returns:
-        - tuple: (bool, float) -> True if the duration of the video and audio matches, False otherwise, along with the difference in duration.
+        - tuple: (bool, float, float, float) -> 
+            - Bool: True if the duration of the video and audio matches within tolerance
+            - Float: Difference in duration
+            - Float: Video duration
+            - Float: Audio duration
     """
     video_duration = get_video_duration(video_path, file_type="video")
     audio_duration = get_video_duration(audio_path, file_type="audio")
@@ -230,21 +234,21 @@ def check_duration_v_a(video_path, audio_path, tolerance=1.0):
     # 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
+        return False, 0.0, 0.0, 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
+        console.print("[yellow]Warning: Video duration is None. Using audio duration for calculation.[/yellow]")
+        return False, 0.0, 0.0, audio_duration
     
     elif audio_duration is None:
-        console.print("[yellow]Warning: Audio duration is None. Returning 0 as duration difference.[/yellow]")
-        return False, 0.0
+        console.print("[yellow]Warning: Audio duration is None. Using video duration for calculation.[/yellow]")
+        return False, 0.0, video_duration, 0.0
     
     # Calculate the duration difference
     duration_difference = abs(video_duration - audio_duration)
 
     # Check if the duration difference is within the tolerance
     if duration_difference <= tolerance:
-        return True, duration_difference
+        return True, duration_difference, video_duration, audio_duration
     else:
-        return False, duration_difference
+        return False, duration_difference, video_duration, audio_duration

StreamingCommunity/Lib/M3U8/estimator.py

@@ -54,6 +54,7 @@ class M3U8_Ts_Estimator:
         speed_buffer = deque(maxlen=3)
         error_count = 0
         max_errors = 5
+        current_interval = 0.1
         
         while self._running:
             try:
@@ -64,12 +65,16 @@ class M3U8_Ts_Estimator:
                 current_upload, current_download = io_counters.bytes_sent, io_counters.bytes_recv
                 
                 if last_upload and last_download:
-                    upload_speed = (current_upload - last_upload) / interval
-                    download_speed = (current_download - last_download) / interval
+                    upload_speed = (current_upload - last_upload) / current_interval
+                    download_speed = (current_download - last_download) / current_interval
                     
                     if download_speed > 1024:
                         speed_buffer.append(download_speed)
 
+                        # Increase interval if we have a stable speed measurement
+                        if len(speed_buffer) >= 2:
+                            current_interval = min(interval, current_interval * 1.5)
+                    
                         if speed_buffer:
                             avg_speed = sum(speed_buffer) / len(speed_buffer)
                             
@@ -77,7 +82,6 @@ class M3U8_Ts_Estimator:
                                 formatted_upload = internet_manager.format_transfer_speed(max(0, upload_speed))
                                 formatted_download = internet_manager.format_transfer_speed(avg_speed)
                                 
-                                # Lock minimale
                                 with self.lock:
                                     self.speed = {
                                         "upload": formatted_upload,
@@ -99,9 +103,9 @@ class M3U8_Ts_Estimator:
                 if error_count > max_errors:
                     with self.lock:
                         self.speed = {"upload": "N/A", "download": "N/A"}
-                    interval = 10.0
-            
-            time.sleep(interval)
+                    current_interval = 10.0
+        
+            time.sleep(current_interval)
 
     def calculate_total_size(self) -> str:
         """
@@ -133,11 +137,8 @@ class M3U8_Ts_Estimator:
         """
         try:
             self.add_ts_file(segment_size)
-            
-            with self.lock:
-                self.downloaded_segments_count += 1
-            
             file_total_size = self.calculate_total_size()
+            
             if file_total_size == "Error":
                 return
                 
@@ -152,8 +153,8 @@ class M3U8_Ts_Estimator:
                 average_internet_speed, average_internet_unit = "N/A", ""
             
             progress_str = (
-                f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
-                f"{Colors.WHITE}, {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit} "
+                f"{Colors.LIGHT_GREEN}{number_file_total_size} {Colors.LIGHT_MAGENTA}{units_file_total_size} {Colors.WHITE}"
+                f"{Colors.DARK_GRAY}@ {Colors.LIGHT_CYAN}{average_internet_speed} {Colors.LIGHT_MAGENTA}{average_internet_unit}"
             )
             
             progress_counter.set_postfix_str(progress_str)

StreamingCommunity/Lib/M3U8/parser.py

@@ -381,6 +381,7 @@ class M3U8_Subtitle:
 class M3U8_Parser:
     def __init__(self):
         self.is_master_playlist = None
+        self.init_segment = None
         self.segments = []
         self.video_playlist = []
         self.keys = None
@@ -403,11 +404,12 @@ class M3U8_Parser:
             - m3u8_content (str): The content of the M3U8 file.
         """
         m3u8_obj = loads(raw_content, uri)
-        
+
         self.__parse_video_info__(m3u8_obj)
         self.__parse_subtitles_and_audio__(m3u8_obj)
         self.__parse_segments__(m3u8_obj)
         self.is_master_playlist = self.__is_master__(m3u8_obj)
+        self.init_segment = self.__parse_init_segment__(m3u8_obj)
 
     @staticmethod
     def extract_resolution(uri: str) -> int:
@@ -457,9 +459,6 @@ class M3U8_Parser:
         """
         Determines if the given M3U8 object is a master playlist.
 
-        Parameters:
-            - m3u8_obj (m3u8.M3U8): The parsed M3U8 object.
-
         Returns:
             - bool: True if it's a master playlist, False if it's a media playlist, None if unknown.
         """
@@ -478,9 +477,6 @@ class M3U8_Parser:
     def __parse_video_info__(self, m3u8_obj) -> None:
         """
         Extracts video information from the M3U8 object.
-
-        Parameters:
-            - m3u8_obj: The M3U8 object containing video playlists.
         """
         try:
             for playlist in m3u8_obj.playlists:
@@ -526,9 +522,6 @@ class M3U8_Parser:
     def __parse_encryption_keys__(self, obj) -> None:
         """
         Extracts encryption keys either from the M3U8 object or from individual segments.
-
-        Parameters:
-            - obj: Either the main M3U8 object or an individual segment.
         """
         try:
             if hasattr(obj, 'key') and obj.key is not None:
@@ -557,9 +550,6 @@ class M3U8_Parser:
     def __parse_subtitles_and_audio__(self, m3u8_obj) -> None:
         """
         Extracts subtitles and audio information from the M3U8 object.
-
-        Parameters:
-            - m3u8_obj: The M3U8 object containing subtitles and audio data.
         """
         try:
             for media in m3u8_obj.media:
@@ -587,9 +577,6 @@ class M3U8_Parser:
     def __parse_segments__(self, m3u8_obj) -> None:
         """
         Extracts segment information from the M3U8 object.
-
-        Parameters:
-            - m3u8_obj: The M3U8 object containing segment data.
         """
         try:
             for segment in m3u8_obj.segments:
@@ -612,6 +599,19 @@ class M3U8_Parser:
         except Exception as e:
             logging.error(f"Error parsing segments: {e}")
 
+    def __parse_init_segment__(self, m3u8_obj) -> None:
+        """
+        Extracts initialization segment information from the M3U8 object.
+        """
+        try:
+            if len(m3u8_obj.segment_map) > 0:
+                init_segment = m3u8_obj.segment_map[0].uri
+                return init_segment
+        
+        except Exception as e:
+            logging.error(f"Error parsing initialization segment: {e}")
+            return None
+
     def __create_variable__(self):
         """
         Initialize variables for video, audio, and subtitle playlists.

StreamingCommunity/Upload/update.py

@@ -88,14 +88,12 @@ def update():
         latest_commit_message = latest_commit.get('commit', {}).get('message', 'No commit message')
     else:
         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.splitlines()[0]}")
     
     if str(current_version).replace('v', '') != str(last_version).replace('v', ''):
         console.print(f"\n[cyan]New version available: [yellow]{last_version}")
 
     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\
+        [green]Current installed version: [yellow]{current_version} [green]last commit: [white]''[yellow]{latest_commit_message.splitlines()[0]}[white]''\n\
         [cyan]Help the repository grow today by leaving a [yellow]star [cyan]and [yellow]sharing [cyan]it with others online!")
     
-    time.sleep(2)
+    time.sleep(1)

StreamingCommunity/Upload/version.py

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

StreamingCommunity/Util/config_json.py

@@ -53,7 +53,6 @@ class ConfigManager:
         self.cache = {}
 
         self.fetch_domain_online = True
-        self.validate_github_config = False
         
         console.print(f"[bold cyan]Initializing ConfigManager:[/bold cyan] [green]{self.file_path}[/green]")
         
@@ -64,7 +63,7 @@ class ConfigManager:
         """Load the configuration and initialize all settings."""
         if not os.path.exists(self.file_path):
             console.print(f"[bold red]WARNING: Configuration file not found:[/bold red] {self.file_path}")
-            console.print("[bold yellow]Attempting to download from reference repository...[/bold yellow]")
+            console.print("[bold yellow]Downloading from repository...[/bold yellow]")
             self._download_reference_config()
         
         # Load the configuration file
@@ -75,12 +74,6 @@ class ConfigManager:
             
             # Update settings from the configuration
             self._update_settings_from_config()
-            
-            # Validate and update the configuration if requested
-            if self.validate_github_config:
-                self._validate_and_update_config()
-            else:
-                console.print("[bold yellow]GitHub validation disabled[/bold yellow]")
                 
             # Load site data based on fetch_domain_online setting
             self._load_site_data()
@@ -115,14 +108,12 @@ class ConfigManager:
         
         # Get fetch_domain_online setting (True by default)
         self.fetch_domain_online = default_section.get('fetch_domain_online', True)
-        self.validate_github_config = default_section.get('validate_github_config', False)
         
         console.print(f"[bold cyan]Fetch domains online:[/bold cyan] [{'green' if self.fetch_domain_online else 'yellow'}]{self.fetch_domain_online}[/{'green' if self.fetch_domain_online else 'yellow'}]")
-        console.print(f"[bold cyan]GitHub configuration validation:[/bold cyan] [{'green' if self.validate_github_config else 'yellow'}]{self.validate_github_config}[/{'green' if self.validate_github_config else 'yellow'}]")
     
     def _download_reference_config(self) -> None:
         """Download the reference configuration from GitHub."""
-        console.print(f"[bold cyan]Downloading reference configuration:[/bold cyan] [green]{self.reference_config_url}[/green]")
+        console.print(f"[bold cyan]Downloading configuration:[/bold cyan] [green]{self.reference_config_url}[/green]")
 
         try:
             response = requests.get(self.reference_config_url, timeout=8, headers={'User-Agent': get_userAgent()})
@@ -133,7 +124,6 @@ class ConfigManager:
                 file_size = len(response.content) / 1024
                 console.print(f"[bold green]Download complete:[/bold green] {os.path.basename(self.file_path)} ({file_size:.2f} KB)")
             else:
-
                 error_msg = f"HTTP Error: {response.status_code}, Response: {response.text[:100]}"
                 console.print(f"[bold red]Download failed:[/bold red] {error_msg}")
                 raise Exception(error_msg)
@@ -142,107 +132,6 @@ class ConfigManager:
             console.print(f"[bold red]Download error:[/bold red] {str(e)}")
             raise
     
-    def _validate_and_update_config(self) -> None:
-        """Validate the local configuration against the reference one and update missing keys."""
-        try:
-            # Download the reference configuration
-            console.print("[bold cyan]Validating configuration with GitHub...[/bold cyan]")
-            response = requests.get(self.reference_config_url, timeout=8, headers={'User-Agent': get_userAgent()})
-            
-            if not response.ok:
-                raise Exception(f"Error downloading reference configuration. Code: {response.status_code}")
-            
-            reference_config = response.json()
-            
-            # Compare and update missing keys
-            merged_config = self._deep_merge_configs(self.config, reference_config)
-            
-            if merged_config != self.config:
-                added_keys = self._get_added_keys(self.config, merged_config)
-                
-                # Save the merged configuration
-                with open(self.file_path, 'w') as f:
-                    json.dump(merged_config, f, indent=4)
-                
-                key_examples = ', '.join(added_keys[:5])
-                if len(added_keys) > 5:
-                    key_examples += ' and others...'
-                    
-                console.print(f"[bold green]Configuration updated with {len(added_keys)} new keys:[/bold green] {key_examples}")
-                
-                # Update the configuration in memory
-                self.config = merged_config
-                self._update_settings_from_config()
-            else:
-                console.print("[bold green]The configuration is up to date.[/bold green]")
-                
-        except Exception as e:
-            console.print(f"[bold red]Error validating configuration:[/bold red] {str(e)}")
-    
-    def _get_added_keys(self, old_config: dict, new_config: dict, prefix="") -> list:
-        """
-        Get the list of keys added in the new configuration compared to the old one.
-        
-        Args:
-            old_config (dict): Original configuration
-            new_config (dict): New configuration
-            prefix (str): Prefix for nested keys
-            
-        Returns:
-            list: List of added key names
-        """
-        added_keys = []
-        
-        for key, value in new_config.items():
-            full_key = f"{prefix}.{key}" if prefix else key
-            
-            if key not in old_config:
-                added_keys.append(full_key)
-            elif isinstance(value, dict) and isinstance(old_config.get(key), dict):
-                added_keys.extend(self._get_added_keys(old_config[key], value, full_key))
-                
-        return added_keys
-    
-    def _deep_merge_configs(self, local_config: dict, reference_config: dict) -> dict:
-        """
-        Recursively merge the reference configuration into the local one, preserving local values.
-        
-        Args:
-            local_config (dict): Local configuration
-            reference_config (dict): Reference configuration
-            
-        Returns:
-            dict: Merged configuration
-        """
-        merged = local_config.copy()
-        
-        for key, value in reference_config.items():
-            if key not in merged:
-
-                # Create the key if it doesn't exist
-                merged[key] = value
-            elif isinstance(value, dict) and isinstance(merged[key], dict):
-
-                # Handle the DEFAULT section specially
-                if key == 'DEFAULT':
-
-                    # Make sure control keys maintain local values
-                    merged_section = self._deep_merge_configs(merged[key], value)
-                    
-                    # Preserve local values for critical settings
-                    if 'fetch_domain_online' in merged[key]:
-                        merged_section['fetch_domain_online'] = merged[key]['fetch_domain_online']
-                    if 'validate_github_config' in merged[key]:
-                        merged_section['validate_github_config'] = merged[key]['validate_github_config']
-                    
-                    merged[key] = merged_section
-                else:
-
-                    # Normal merge for other sections
-                    merged[key] = self._deep_merge_configs(merged[key], value)
-                
-        return merged
-    
     def _load_site_data(self) -> None:
         """Load site data based on fetch_domain_online setting."""
         if self.fetch_domain_online:
@@ -258,7 +147,6 @@ class ConfigManager:
         }
         
         try:
-            console.print("[bold cyan]Fetching domains from GitHub:[/bold cyan]")
             response = requests.get(domains_github_url, timeout=8, headers=headers)
 
             if response.ok:
@@ -267,9 +155,6 @@ class ConfigManager:
                 # Determine which file to save to
                 self._save_domains_to_appropriate_location()
                 
-                site_count = len(self.configSite) if isinstance(self.configSite, dict) else 0
-                console.print(f"[bold green]Domains loaded from GitHub:[/bold green] {site_count} streaming services found.")
-                
             else:
                 console.print(f"[bold red]GitHub request failed:[/bold red] HTTP {response.status_code}, {response.text[:100]}")
                 self._handle_site_data_fallback()
@@ -296,21 +181,18 @@ class ConfigManager:
         
         try:
             if os.path.exists(github_domains_path):
-
+                
                 # Update existing GitHub structure file
                 with open(github_domains_path, 'w', encoding='utf-8') as f:
                     json.dump(self.configSite, f, indent=4, ensure_ascii=False)
-                console.print(f"[bold green]Domains updated in GitHub structure:[/bold green] {github_domains_path}")
                 
             elif not os.path.exists(self.domains_path):
-
                 # Save to root only if it doesn't exist and GitHub structure doesn't exist
                 with open(self.domains_path, 'w', encoding='utf-8') as f:
                     json.dump(self.configSite, f, indent=4, ensure_ascii=False)
                 console.print(f"[bold green]Domains saved to:[/bold green] {self.domains_path}")
                 
             else:
-
                 # Root file exists, don't overwrite it
                 console.print(f"[bold yellow]Local domains.json already exists, not overwriting:[/bold yellow] {self.domains_path}")
                 console.print("[bold yellow]Tip: Delete the file if you want to recreate it from GitHub[/bold yellow]")
@@ -636,16 +518,5 @@ class ConfigManager:
         return section in config_source
 
 
-def get_use_large_bar():
-    """
-    Determine if the large bar feature should be enabled.
-    
-    Returns:
-        bool: True if running on PC (Windows, macOS, Linux),
-              False if running on Android or iOS.
-    """
-    return not any(platform in sys.platform for platform in ("android", "ios"))
-
-
 # Initialize the ConfigManager when the module is imported
 config_manager = ConfigManager()