StreamingCommunity 2.0.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

StreamingCommunity/Lib/M3U8/estimator.py

@@ -1,4 +1,4 @@
-# 20.02.24
+# 21.04.25
 
 import os
 import time
@@ -26,7 +26,7 @@ class M3U8_Ts_Estimator:
     def __init__(self, total_segments: int):
         """
         Initialize the M3U8_Ts_Estimator object.
-
+        
         Parameters:
             - total_segments (int): Length of total segments to download.
         """
@@ -34,73 +34,120 @@ class M3U8_Ts_Estimator:
         self.now_downloaded_size = 0
         self.total_segments = total_segments
         self.lock = threading.Lock()
-        self.speed = {"upload": "N/A", "download": "N/A"}  # Default to N/A
-        self.speed_thread = threading.Thread(target=self.capture_speed)
-        self.speed_thread.daemon = True
-        self.speed_thread.start()
+        self.speed = {"upload": "N/A", "download": "N/A"}
+        self.process_pid = os.getpid()  # Get current process PID
+        logging.debug(f"Initializing M3U8_Ts_Estimator with PID: {self.process_pid}")
 
-    def add_ts_file(self, size: int, size_download: int, duration: float):
-        """
-        Add a file size to the list of file sizes.
+        # Start the speed capture thread if TQDM_USE_LARGE_BAR is True
+        if TQDM_USE_LARGE_BAR:
+            logging.debug("TQDM_USE_LARGE_BAR is True, starting speed capture thread")
+            self.speed_thread = threading.Thread(target=self.capture_speed, args=(1, self.process_pid))
+            self.speed_thread.daemon = True
+            self.speed_thread.start()
 
-        Parameters:
-            - size (int): The size of the ts file to be added.
-            - size_download (int): Single size of the ts file.
-            - duration (float): Time to download segment file.
-        """
+        else:
+            logging.debug("TQDM_USE_LARGE_BAR is False, speed capture thread not started")
+
+    def add_ts_file(self, size: int, size_download: int, duration: float):
+        """Add a file size to the list of file sizes."""
+        logging.debug(f"Adding ts file - size: {size}, download size: {size_download}, duration: {duration}")
+        
         if size <= 0 or size_download <= 0 or duration <= 0:
-            logging.error("Invalid input values: size=%d, size_download=%d, duration=%f", size, size_download, duration)
+            logging.error(f"Invalid input values: size={size}, size_download={size_download}, duration={duration}")
             return
 
-        # Add total size bytes
         self.ts_file_sizes.append(size)
         self.now_downloaded_size += size_download
+        logging.debug(f"Current total downloaded size: {self.now_downloaded_size}")
 
-    def capture_speed(self, interval: float = 1):
-        """
-        Capture the internet speed periodically and store the values.
-        """
-        def get_network_io():
-            """Get network I/O counters, handle missing psutil gracefully."""
+    def capture_speed(self, interval: float = 1, pid: int = None):
+        """Capture the internet speed periodically."""
+        logging.debug(f"Starting speed capture with interval {interval}s for PID: {pid}")
+        
+        def get_network_io(process=None):
             try:
-                io_counters = psutil.net_io_counters()
-                return io_counters
-            
+                if process:
+
+                    # For process-specific monitoring
+                    connections = process.connections(kind='inet')
+                    if connections:
+                        io_counters = process.io_counters()
+                        logging.debug(f"Process IO counters: {io_counters}")
+                        return io_counters
+                    
+                    else:
+                        logging.debug("No active internet connections found for process")
+                        return None
+                else:
+
+                    # For system-wide monitoring
+                    io_counters = psutil.net_io_counters()
+                    logging.debug(f"System IO counters: {io_counters}")
+                    return io_counters
+                
             except Exception as e:
-                logging.warning(f"Unable to access network I/O counters: {e}")
+                logging.error(f"Error getting network IO: {str(e)}")
                 return None
 
-        while True:
-            old_value = get_network_io()
-
-            if old_value is None:  # If psutil is not available, continue with default values
-                time.sleep(interval)
-                continue
-
-            time.sleep(interval)
-            new_value = get_network_io()
-            
-            if new_value is None:  # Handle again if psutil fails in the next call
-                time.sleep(interval)
-                continue
+        try:
+            process = psutil.Process(pid) if pid else None
+            logging.debug(f"Monitoring process: {process}")
 
-            with self.lock:
-                upload_speed = (new_value.bytes_sent - old_value.bytes_sent) / interval
-                download_speed = (new_value.bytes_recv - old_value.bytes_recv) / interval
+        except Exception as e:
+            logging.error(f"Failed to get process with PID {pid}: {str(e)}")
+            process = None
 
-                self.speed = {
-                    "upload": internet_manager.format_transfer_speed(upload_speed),
-                    "download": internet_manager.format_transfer_speed(download_speed)
-                }
+        last_upload = None
+        last_download = None
+        first_run = True
+        
+        # Buffer circolare per le ultime N misurazioni
+        speed_buffer_size = 3
+        speed_buffer = deque(maxlen=speed_buffer_size)
 
-    def get_average_speed(self) -> float:
-        """
-        Calculate the average internet speed.
+        while True:
+            try:
+                io_counters = get_network_io()
+                
+                if io_counters:
+                    current_upload = io_counters.bytes_sent
+                    current_download = io_counters.bytes_recv
+                    
+                    if not first_run and last_upload is not None and last_download is not None:
+
+                        # Calcola la velocità istantanea
+                        upload_speed = max(0, (current_upload - last_upload) / interval)
+                        download_speed = max(0, (current_download - last_download) / interval)
+                        
+                        # Aggiungi al buffer
+                        speed_buffer.append(download_speed)
+                        
+                        # Calcola la media mobile delle velocità
+                        if len(speed_buffer) > 0:
+                            avg_download_speed = sum(speed_buffer) / len(speed_buffer)
+                            
+                            if avg_download_speed > 0:
+                                with self.lock:
+                                    self.speed = {
+                                        "upload": internet_manager.format_transfer_speed(upload_speed),
+                                        "download": internet_manager.format_transfer_speed(avg_download_speed)
+                                    }
+                                    logging.debug(f"Updated speeds - Upload: {self.speed['upload']}, Download: {self.speed['download']}")
+                    
+                    last_upload = current_upload
+                    last_download = current_download
+                    first_run = False
+                
+                time.sleep(interval)
+            except Exception as e:
+                logging.error(f"Error in speed capture loop: {str(e)}")
+                logging.exception("Full traceback:")
+                logging.sleep(interval)
 
-        Returns:
-            float: The average internet speed in Mbps.
-        """
+    def get_average_speed(self) -> list:
+        """Calculate the average internet speed."""
         with self.lock:
+            logging.debug(f"Current speed data: {self.speed}")
             return self.speed['download'].split(" ")
 
     def calculate_total_size(self) -> str:
@@ -127,7 +174,7 @@ class M3U8_Ts_Estimator:
         except Exception as e:
             logging.error("An unexpected error occurred: %s", e)
             return "Error"
-
+        
     def get_downloaded_size(self) -> str:
         """
         Get the total downloaded size formatted as a human-readable string.
@@ -136,41 +183,47 @@ class M3U8_Ts_Estimator:
             str: The total downloaded size as a human-readable string.
         """
         return internet_manager.format_file_size(self.now_downloaded_size)
-
+    
     def update_progress_bar(self, total_downloaded: int, duration: float, progress_counter: tqdm) -> None:
-        """
-        Updates the progress bar with information about the TS segment download.
-
-        Parameters:
-            total_downloaded (int): The length of the content of the downloaded TS segment.
-            duration (float): The duration of the segment download in seconds.
-            progress_counter (tqdm): The tqdm object representing the progress bar.
-        """
-        # Add the size of the downloaded segment to the estimator
-        self.add_ts_file(total_downloaded * self.total_segments, total_downloaded, duration)
-
-        # Get downloaded size and total estimated size
-        downloaded_file_size_str = self.get_downloaded_size()
-        file_total_size = self.calculate_total_size()
-
-        # Fix parameter for prefix
-        number_file_downloaded = downloaded_file_size_str.split(' ')[0]
-        number_file_total_size = file_total_size.split(' ')[0]
-        units_file_downloaded = downloaded_file_size_str.split(' ')[1]
-        units_file_total_size = file_total_size.split(' ')[1]
-
-        average_internet_speed = self.get_average_speed()[0]
-        average_internet_unit = self.get_average_speed()[1]
-
-        # Update the progress bar's postfix
-        if TQDM_USE_LARGE_BAR:
-            progress_counter.set_postfix_str(
-                f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< {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}"
-            )
-        else:
-            progress_counter.set_postfix_str(
-                f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded}{Colors.RED} {units_file_downloaded} "
-                f"{Colors.WHITE}| {Colors.CYAN}{average_internet_speed} {Colors.RED}{average_internet_unit}"
-            )
-    
+        """Updates the progress bar with download information."""
+        try:
+            self.add_ts_file(total_downloaded * self.total_segments, total_downloaded, duration)
+            
+            downloaded_file_size_str = self.get_downloaded_size()
+            file_total_size = self.calculate_total_size()
+            
+            number_file_downloaded = downloaded_file_size_str.split(' ')[0]
+            number_file_total_size = file_total_size.split(' ')[0]
+            units_file_downloaded = downloaded_file_size_str.split(' ')[1]
+            units_file_total_size = file_total_size.split(' ')[1]
+            
+            if TQDM_USE_LARGE_BAR:
+                speed_data = self.get_average_speed()
+                logging.debug(f"Speed data for progress bar: {speed_data}")
+                
+                if len(speed_data) >= 2:
+                    average_internet_speed = speed_data[0]
+                    average_internet_unit = speed_data[1]
+
+                else:
+                    logging.warning(f"Invalid speed data format: {speed_data}")
+                    average_internet_speed = "N/A"
+                    average_internet_unit = ""
+                
+                progress_str = (
+                    f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
+                    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}"
+                )
+                
+            else:
+                progress_str = (
+                    f"{Colors.WHITE}[ {Colors.GREEN}{number_file_downloaded} {Colors.WHITE}< "
+                    f"{Colors.GREEN}{number_file_total_size} {Colors.RED}{units_file_total_size}"
+                )
+            
+            progress_counter.set_postfix_str(progress_str)
+            logging.debug(f"Updated progress bar: {progress_str}")
+            
+        except Exception as e:
+            logging.error(f"Error updating progress bar: {str(e)}")

StreamingCommunity/Upload/update.py

@@ -57,11 +57,10 @@ def update():
 
     # Check installed version
     if str(__version__).replace('v', '') != str(last_version).replace('v', '') :
-        console.print(f"[red]New version available: [yellow]{last_version}")
+        console.print(f"[red]New version available: [yellow]{last_version} \n")
     else:
-        console.print(f"[red]Everything is up to date")
+        console.print(f" [yellow]Everything is up to date \n")
 
-    console.print("\n")
     console.print(f"[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!")
     

StreamingCommunity/Upload/version.py

@@ -1,5 +1,5 @@
 __title__ = 'StreamingCommunity'
-__version__ = '2.0.0'
+__version__ = '2.2.0'
 __author__ = 'Lovi-0'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2024'

StreamingCommunity/Util/ffmpeg_installer.py

@@ -116,21 +116,35 @@ class FFMPEGDownloader:
     def _check_existing_binaries(self) -> Tuple[Optional[str], Optional[str], Optional[str]]:
         """
         Check if FFmpeg binaries already exist in the base directory.
-
-        Returns:
-            Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay executables.
-            Returns None for each executable that is not found.
+        Enhanced to check both the binary directory and system paths on macOS.
         """
         config = FFMPEG_CONFIGURATION[self.os_name]
         executables = config['executables']
         found_executables = []
 
-        for executable in executables:
-            exe_paths = glob.glob(os.path.join(self.base_dir, executable))
-            if exe_paths:
-                found_executables.append(exe_paths[0])
-            else:
-                found_executables.append(None)
+        # For macOS, check both binary directory and system paths
+        if self.os_name == 'darwin':
+            potential_paths = [
+                '/usr/local/bin',
+                '/opt/homebrew/bin',
+                '/usr/bin',
+                self.base_dir
+            ]
+            
+            for executable in executables:
+                found = None
+                for path in potential_paths:
+                    full_path = os.path.join(path, executable)
+                    if os.path.exists(full_path) and os.access(full_path, os.X_OK):
+                        found = full_path
+                        break
+                found_executables.append(found)
+        else:
+
+            # Original behavior for other operating systems
+            for executable in executables:
+                exe_paths = glob.glob(os.path.join(self.base_dir, executable))
+                found_executables.append(exe_paths[0] if exe_paths else None)
 
         return tuple(found_executables) if len(found_executables) == 3 else (None, None, None)
 
@@ -275,37 +289,63 @@ class FFMPEGDownloader:
 def check_ffmpeg() -> Tuple[Optional[str], Optional[str], Optional[str]]:
     """
     Check for FFmpeg executables in the system and download them if not found.
+    Enhanced detection for macOS systems.
 
     Returns:
         Tuple[Optional[str], Optional[str], Optional[str]]: Paths to ffmpeg, ffprobe, and ffplay executables.
-        Returns None for each executable that couldn't be found or downloaded.
-
-    The function first checks if FFmpeg executables are available in the system PATH:
-    - On Windows, uses the 'where' command
-    - On Unix-like systems, uses 'which'
-    
-    If the executables are not found in PATH, it attempts to download and install them
-    using the FFMPEGDownloader class.
     """
     try:
-        if platform.system().lower() == 'windows':
-            ffmpeg_path = subprocess.check_output(['where', 'ffmpeg'], text=True).strip().split('\n')[0] if subprocess.call(['where', 'ffmpeg'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0 else None
-            ffprobe_path = subprocess.check_output(['where', 'ffprobe'], text=True).strip().split('\n')[0] if subprocess.call(['where', 'ffprobe'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0 else None
-            ffplay_path = subprocess.check_output(['where', 'ffplay'], text=True).strip().split('\n')[0] if subprocess.call(['where', 'ffplay'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) == 0 else None
+        system_platform = platform.system().lower()
+        
+        # Special handling for macOS
+        if system_platform == 'darwin':
+
+            # Common installation paths on macOS
+            potential_paths = [
+                '/usr/local/bin',                               # Homebrew default
+                '/opt/homebrew/bin',                            # Apple Silicon Homebrew
+                '/usr/bin',                                     # System default
+                os.path.expanduser('~/Applications/binary'),    # Custom installation
+                '/Applications/binary'                          # Custom installation
+            ]
             
-            if all([ffmpeg_path, ffprobe_path, ffplay_path]):
-                return ffmpeg_path, ffprobe_path, ffplay_path
+            for path in potential_paths:
+                ffmpeg_path = os.path.join(path, 'ffmpeg')
+                ffprobe_path = os.path.join(path, 'ffprobe')
+                ffplay_path = os.path.join(path, 'ffplay')
+                
+                if (os.path.exists(ffmpeg_path) and os.path.exists(ffprobe_path) and 
+                    os.access(ffmpeg_path, os.X_OK) and os.access(ffprobe_path, os.X_OK)):
+                    
+                    # Return found executables, with ffplay being optional
+                    ffplay_path = ffplay_path if os.path.exists(ffplay_path) else None
+                    return ffmpeg_path, ffprobe_path, ffplay_path
+
+        # Windows detection
+        elif system_platform == 'windows':
+            try:
+                ffmpeg_path = subprocess.check_output(['where', 'ffmpeg'], text=True).strip().split('\n')[0]
+                ffprobe_path = subprocess.check_output(['where', 'ffprobe'], text=True).strip().split('\n')[0]
+                ffplay_path = subprocess.check_output(['where', 'ffplay'], text=True).strip().split('\n')[0]
+                
+                if ffmpeg_path and ffprobe_path:
+                    return ffmpeg_path, ffprobe_path, ffplay_path
+            except subprocess.CalledProcessError:
+                pass
+
+        # Linux detection
         else:
             ffmpeg_path = shutil.which('ffmpeg')
             ffprobe_path = shutil.which('ffprobe')
             ffplay_path = shutil.which('ffplay')
             
-            if all([ffmpeg_path, ffprobe_path, ffplay_path]):
+            if ffmpeg_path and ffprobe_path:
                 return ffmpeg_path, ffprobe_path, ffplay_path
-        
+
+        # If executables were not found, attempt to download FFmpeg
         downloader = FFMPEGDownloader()
         return downloader.download()
-    
+
     except Exception as e:
-        logging.error(f"Error checking FFmpeg: {e}")
+        logging.error(f"Error checking or downloading FFmpeg executables: {e}")
         return None, None, None

StreamingCommunity/Util/os.py

@@ -317,16 +317,13 @@ class InternManager():
     def check_internet():
         while True:
             try:
-                httpx.get("https://www.google.com")
-                #console.log("[bold green]Internet is available![/bold green]")
+                httpx.get("https://www.google.com", timeout=15)
                 break
 
             except urllib.error.URLError:
                 console.log("[bold red]Internet is not available. Waiting...[/bold red]")
                 time.sleep(5)
 
-        print()
-
 
 class OsSummary:
 
@@ -353,20 +350,17 @@ class OsSummary:
             console.print(f"{command[0]} not found", style="bold red")
             sys.exit(0)
 
-    def check_ffmpeg_location(self, command: list):
+    def check_ffmpeg_location(self, command: list) -> str:
         """
-        Run 'where ffmpeg' command to check FFmpeg's location.
-
-        Returns:
-            str: Location of FFmpeg executable or None if not found
+        Check if a specific executable (ffmpeg or ffprobe) is located using the given command.
+        Returns the path of the executable or None if not found.
         """
         try:
-            result = subprocess.check_output(command, stderr=subprocess.STDOUT, text=True).strip()
-            return result
+            result = subprocess.check_output(command, text=True).strip()
+            return result.split('\n')[0] if result else None
         
         except subprocess.CalledProcessError:
-            console.print("FFmpeg not found in system PATH", style="bold red")
-            sys.exit(0)
+            return None
 
     def get_library_version(self, lib_name: str):
         """
@@ -467,27 +461,24 @@ class OsSummary:
         console.print(f"[cyan]Python[white]: [bold red]{python_version} ({python_implementation} {arch}) - {os_info} ({glibc_version})[/bold red]")
         logging.info(f"Python: {python_version} ({python_implementation} {arch}) - {os_info} ({glibc_version})")
         
-        # Usa il comando 'where' su Windows
-        if platform.system() == "Windows":
-            command = 'where'
-
-        # Usa il comando 'which' su Unix/Linux
-        else:
-            command = 'which'
+        # Use the 'where' command on Windows and 'which' command on Unix-like systems
+        system_platform = platform.system().lower()
+        command = 'where' if system_platform == 'windows' else 'which'
 
-        # Locate ffmpeg and ffprobe from path enviroment
-        if self.ffmpeg_path != None and "binary" not in self.ffmpeg_path:        
+        # Locate ffmpeg and ffprobe from the PATH environment
+        if self.ffmpeg_path is not None and "binary" not in self.ffmpeg_path:
             self.ffmpeg_path = self.check_ffmpeg_location([command, 'ffmpeg'])
 
-        if self.ffprobe_path != None and "binary" not in self.ffprobe_path:
+        if self.ffprobe_path is not None and "binary" not in self.ffprobe_path:
             self.ffprobe_path = self.check_ffmpeg_location([command, 'ffprobe'])
 
-        # Locate ffmpeg from bin installation
+        # If ffmpeg or ffprobe is not located, fall back to using the check_ffmpeg function
         if self.ffmpeg_path is None or self.ffprobe_path is None:
             self.ffmpeg_path, self.ffprobe_path, self.ffplay_path = check_ffmpeg()
 
+        # If still not found, print error and exit
         if self.ffmpeg_path is None or self.ffprobe_path is None:
-            console.log("[red]Cant locate ffmpeg or ffprobe")
+            console.log("[red]Can't locate ffmpeg or ffprobe")
             sys.exit(0)
 
         ffmpeg_version = self.get_executable_version([self.ffprobe_path, '-version'])

StreamingCommunity/run.py

@@ -120,7 +120,6 @@ def initialize():
     # Attempting GitHub update
     try:
         git_update()
-        print()
     except:
         console.log("[red]Error with loading github.")
 

{StreamingCommunity-2.0.0.dist-info → StreamingCommunity-2.2.0.dist-info}/METADATA

@@ -1,17 +1,17 @@
 Metadata-Version: 2.1
 Name: StreamingCommunity
-Version: 2.0.0
-Summary: A streaming community package
+Version: 2.2.0
+Summary: UNKNOWN
 Home-page: https://github.com/Lovi-0/StreamingCommunity
 Author: Lovi-0
+License: UNKNOWN
 Project-URL: Bug Reports, https://github.com/Lovi-0/StreamingCommunity/issues
 Project-URL: Source, https://github.com/Lovi-0/StreamingCommunity
-Keywords: Streaming Community
+Keywords: streaming community
+Platform: UNKNOWN
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: httpx
-Requires-Dist: cffi
 Requires-Dist: bs4
 Requires-Dist: rich
 Requires-Dist: tqdm
@@ -255,7 +255,7 @@ The configuration file is divided into several main sections:
   * `%(episode)` : Is the number of the episode
   * `%(episode_name)` : Is the name of the episode
     `<br/><br/>`
-    
+
 - `not_close`: If true, continues running after downloading
 
     ### qBittorrent Configuration
@@ -307,6 +307,9 @@ The configuration file is divided into several main sections:
 - `default_audio_workser`: Number of threads for audio download
 - `cleanup_tmp_folder`: Remove temporary .ts files after download
 
+> [!IMPORTANT]
+> Set `tqdm_use_large_bar` to `false` when using Termux or terminals with limited width to prevent display issues
+
 
 <br>
 
@@ -359,10 +362,8 @@ forced-ita         hin - Hindi        pol - Polish      tur - Turkish
 
 <br>
 
-
 # COMMAND
 
-
 - Download a specific season by entering its number.
   *  **Example:** `1` will download *Season 1* only.
 
@@ -433,7 +434,7 @@ The `run-container` command mounts also the `config.json` file, so any change to
 
 # To Do 
 
-- Create website API -> https://github.com/Lovi-0/StreamingCommunity/tree/test_gui_1
+- Finish [website API](https://github.com/Lovi-0/StreamingCommunity/tree/test_gui_1)
 
 # Contributing
 
@@ -454,3 +455,5 @@ This software is provided "as is", without warranty of any kind, express or impl
 <a href="https://github.com/Lovi-0/StreamingCommunity/graphs/contributors" alt="View Contributors">
   <img src="https://contrib.rocks/image?repo=Lovi-0/StreamingCommunity&max=1000&columns=10" alt="Contributors" />
 </a>
+
+