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

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -137,7 +137,7 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
                 progress_bar = tqdm(
                     total=total,
                     ascii='░▒█',
-                    bar_format=f"{Colors.YELLOW}[MP4]{Colors.CYAN} Downloading{Colors.WHITE}: "
+                    bar_format=f"{Colors.YELLOW}MP4{Colors.CYAN} Downloading{Colors.WHITE}: "
                                f"{Colors.RED}{{percentage:.1f}}% {Colors.MAGENTA}{{bar:40}} {Colors.WHITE}"
                                f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
                                f"{Colors.LIGHT_CYAN}{{rate_fmt}}",

StreamingCommunity/Lib/FFmpeg/capture.py

@@ -1,6 +1,7 @@
 # 16.04.24
 
 import re
+import time
 import logging
 import threading
 import subprocess
@@ -29,6 +30,7 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
     """
     try:
         max_length = 0
+        start_time = time.time()
 
         for line in iter(process.stdout.readline, ''):          
             try:
@@ -44,8 +46,7 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
 
                 if "size=" in line:
                     try:
-
-                        # Parse the output line to extract relevant information
+                        elapsed_time = time.time() - start_time
                         data = parse_output_line(line)
 
                         if 'q' in data:
@@ -55,11 +56,25 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
                         else:
                             byte_size = int(re.findall(r'\d+', data.get('size', '0'))[0]) * 1000
 
+                        # Extract additional information
+                        fps = data.get('fps', 'N/A')
+                        time_processed = data.get('time', 'N/A')
+                        bitrate = data.get('bitrate', 'N/A')
+                        speed = data.get('speed', 'N/A')
+
+                        # Format elapsed time as HH:MM:SS
+                        elapsed_formatted = format_time(elapsed_time)
 
                         # Construct the progress string with formatted output information
-                        progress_string = (f"{description}[white]: "
-                                           f"([green]'speed': [yellow]{data.get('speed', 'N/A')}[white], "
-                                           f"[green]'size': [yellow]{internet_manager.format_file_size(byte_size)}[white])")
+                        progress_string = (
+                            f"{description}[white]: "
+                            f"([green]'fps': [yellow]{fps}[white], "
+                            f"[green]'speed': [yellow]{speed}[white], "
+                            f"[green]'size': [yellow]{internet_manager.format_file_size(byte_size)}[white], "
+                            f"[green]'time': [yellow]{time_processed}[white], "
+                            f"[green]'bitrate': [yellow]{bitrate}[white], "
+                            f"[green]'elapsed': [yellow]{elapsed_formatted}[white])"
+                        )
                         max_length = max(max_length, len(progress_string))
 
                         # Print the progress string to the console, overwriting the previous line
@@ -81,6 +96,19 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
             logging.error(f"Error terminating process: {e}")
 
 
+def format_time(seconds: float) -> str:
+    """
+    Format seconds into HH:MM:SS format.
+
+    Parameters:
+        - seconds (float): Time in seconds.
+    """
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    secs = int(seconds % 60)
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}"
+
+
 def parse_output_line(line: str) -> dict:
     """
     Function to parse the output line and extract relevant information.
@@ -101,6 +129,10 @@ def parse_output_line(line: str) -> dict:
             if len(key_value) == 2:
                 key = key_value[0]
                 value = key_value[1]
+
+                # Remove milliseconds from time value
+                if key == 'time' and isinstance(value, str) and '.' in value:
+                    value = value.split('.')[0]
                 data[key] = value
 
         return data

StreamingCommunity/Lib/FFmpeg/command.py

@@ -23,18 +23,30 @@ from ..M3U8 import M3U8_Codec
 # Config
 DEBUG_MODE = config_manager.get_bool("DEFAULT", "debug")
 DEBUG_FFMPEG = "debug" if DEBUG_MODE else "error"
-USE_CODEC = config_manager.get_bool("M3U8_CONVERSION", "use_codec")
-USE_VCODEC = config_manager.get_bool("M3U8_CONVERSION", "use_vcodec")
-USE_ACODEC = config_manager.get_bool("M3U8_CONVERSION", "use_acodec")
-USE_BITRATE = config_manager.get_bool("M3U8_CONVERSION", "use_bitrate")
 USE_GPU = config_manager.get_bool("M3U8_CONVERSION", "use_gpu")
-FFMPEG_DEFAULT_PRESET = config_manager.get("M3U8_CONVERSION", "default_preset")
+PARAM_VIDEO = config_manager.get_list("M3U8_CONVERSION", "param_video")
+PARAM_AUDIO = config_manager.get_list("M3U8_CONVERSION", "param_audio")
+PARAM_FINAL = config_manager.get_list("M3U8_CONVERSION", "param_final")
 
 
 # Variable
 console = Console()
 
 
+def add_encoding_params(ffmpeg_cmd: List[str]):
+    """
+    Add encoding parameters to the ffmpeg command.
+    
+    Parameters:
+        ffmpeg_cmd (List[str]): List of the FFmpeg command to modify
+    """
+    if PARAM_FINAL:
+        ffmpeg_cmd.extend(PARAM_FINAL)
+    else:
+        ffmpeg_cmd.extend(PARAM_VIDEO)
+        ffmpeg_cmd.extend(PARAM_AUDIO)
+
+
 def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
     """
     Executes 'ffmpeg -encoders' and checks if 'mov_text' and 'webvtt' encoders are available.
@@ -51,7 +63,6 @@ def check_subtitle_encoders() -> Tuple[Optional[bool], Optional[bool]]:
             check=True
         )
         
-        # Check for encoder presence in output
         output = result.stdout
         mov_text_supported = "mov_text" in output
         webvtt_supported = "webvtt" in output
@@ -74,11 +85,9 @@ def select_subtitle_encoder() -> Optional[str]:
     """
     mov_text_supported, webvtt_supported = check_subtitle_encoders()
     
-    # Return early if check failed
     if mov_text_supported is None:
         return None
         
-    # Prioritize mov_text over webvtt
     if mov_text_supported:
         logging.info("Using 'mov_text' as the subtitle encoder.")
         return "mov_text"
@@ -98,7 +107,7 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
     Parameters:
         - video_path (str): The path to the video file.
         - out_path (str): The path to save the output file.
-        - codec (M3U8_Codec): The video codec to use. Defaults to 'copy'.
+        - codec (M3U8_Codec): The video codec to use (non utilizzato con nuova configurazione).
     """
     ffmpeg_cmd = [get_ffmpeg_path()]
 
@@ -113,48 +122,17 @@ def join_video(video_path: str, out_path: str, codec: M3U8_Codec = None):
     # Insert input video path
     ffmpeg_cmd.extend(['-i', video_path])
 
-    # Add output Parameters
-    if USE_CODEC and codec is not None:
-        if USE_VCODEC:
-            if codec.video_codec_name: 
-                if not USE_GPU: 
-                    ffmpeg_cmd.extend(['-c:v', codec.video_codec_name])
-                else: 
-                    ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-            else: 
-                console.log("[red]Cant find vcodec for 'join_audios'")
-        else:
-            if USE_GPU:
-                ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-
-
-        if USE_ACODEC:
-            if codec.audio_codec_name: 
-                ffmpeg_cmd.extend(['-c:a', codec.audio_codec_name])
-            else: 
-                console.log("[red]Cant find acodec for 'join_audios'")
-
-        if USE_BITRATE:
-            ffmpeg_cmd.extend(['-b:v',  f'{codec.video_bitrate // 1000}k'])
-            ffmpeg_cmd.extend(['-b:a',  f'{codec.audio_bitrate // 1000}k'])
-
-    else:
-        ffmpeg_cmd.extend(['-c', 'copy'])
-
-    # Ultrafast preset always or fast for gpu
-    if not USE_GPU:
-        ffmpeg_cmd.extend(['-preset', FFMPEG_DEFAULT_PRESET])
-    else:
-        ffmpeg_cmd.extend(['-preset', 'fast'])
+    # Add encoding parameters (prima dell'output)
+    add_encoding_params(ffmpeg_cmd)
 
-    # Overwrite
-    ffmpeg_cmd += [out_path, "-y"]
+    # Output file and overwrite
+    ffmpeg_cmd.extend([out_path, '-y'])
 
     # Run join
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
     else:
-        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join video")
+        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow]FFMPEG [cyan]Join video")
         print()
 
     return out_path
@@ -169,6 +147,8 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
         - audio_tracks (list[dict[str, str]]): A list of dictionaries containing information about audio tracks.
             Each dictionary should contain the 'path' and 'name' keys.
         - out_path (str): The path to save the output file.
+        - codec (M3U8_Codec): The video codec to use (non utilizzato con nuova configurazione).
+        - limit_duration_diff (float): Maximum duration difference in seconds.
     """
     use_shortest = False
     duration_diffs = []
@@ -210,61 +190,27 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
     for i, audio_track in enumerate(audio_tracks):
         ffmpeg_cmd.extend(['-i', audio_track.get('path')])
 
-
     # Map the video and audio streams
-    ffmpeg_cmd.append('-map')
-    ffmpeg_cmd.append('0:v')            # Map video stream from the first input (video_path)
+    ffmpeg_cmd.extend(['-map', '0:v'])
     
     for i in range(1, len(audio_tracks) + 1):
-        ffmpeg_cmd.append('-map')
-        ffmpeg_cmd.append(f'{i}:a')     # Map audio streams from subsequent inputs
-
-    # Add output Parameters
-    if USE_CODEC:
-        if USE_VCODEC:
-            if codec.video_codec_name: 
-                if not USE_GPU: 
-                    ffmpeg_cmd.extend(['-c:v', codec.video_codec_name])
-                else: 
-                    ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-            else: 
-                console.log("[red]Cant find vcodec for 'join_audios'")
-        else:
-            if USE_GPU:
-                ffmpeg_cmd.extend(['-c:v', 'h264_nvenc'])
-
-        if USE_ACODEC:
-            if codec.audio_codec_name: 
-                ffmpeg_cmd.extend(['-c:a', codec.audio_codec_name])
-            else: 
-                console.log("[red]Cant find acodec for 'join_audios'")
-
-        if USE_BITRATE:
-            ffmpeg_cmd.extend(['-b:v',  f'{codec.video_bitrate // 1000}k'])
-            ffmpeg_cmd.extend(['-b:a',  f'{codec.audio_bitrate // 1000}k'])
+        ffmpeg_cmd.extend(['-map', f'{i}:a'])
 
-    else:
-        ffmpeg_cmd.extend(['-c', 'copy'])
-
-    # Ultrafast preset always or fast for gpu
-    if not USE_GPU:
-        ffmpeg_cmd.extend(['-preset', FFMPEG_DEFAULT_PRESET])
-    else:
-        ffmpeg_cmd.extend(['-preset', 'fast'])
+    # Add encoding parameters (prima di -shortest e output)
+    add_encoding_params(ffmpeg_cmd)
 
     # Use shortest input path if any audio track has significant difference
     if use_shortest:
         ffmpeg_cmd.extend(['-shortest', '-strict', 'experimental'])
 
-    # Overwrite
-    ffmpeg_cmd += [out_path, "-y"]
+    # Output file and overwrite
+    ffmpeg_cmd.extend([out_path, '-y'])
 
     # Run join
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
-        
     else:
-        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join audio")
+        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow]FFMPEG [cyan]Join audio")
         print()
 
     return out_path, use_shortest
@@ -294,11 +240,8 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
         ffmpeg_cmd += ["-map", f"{idx + 1}:s"]
         ffmpeg_cmd += ["-metadata:s:s:{}".format(idx), "title={}".format(subtitle['language'])]
 
-    # Add output Parameters
-    if USE_CODEC:
-        ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', select_subtitle_encoder()])
-    else:
-        ffmpeg_cmd.extend(['-c', 'copy', '-c:s', select_subtitle_encoder()])
+    # For subtitles, we always use copy for video/audio and only encoder for subtitles
+    ffmpeg_cmd.extend(['-c:v', 'copy', '-c:a', 'copy', '-c:s', select_subtitle_encoder()])
 
     # Overwrite
     ffmpeg_cmd += [out_path, "-y"]
@@ -307,9 +250,8 @@ def join_subtitle(video_path: str, subtitles_list: List[Dict[str, str]], out_pat
     # Run join
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
-
     else:
-        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow][FFMPEG] [cyan]Join subtitle")
+        capture_ffmpeg_real_time(ffmpeg_cmd, "[yellow]FFMPEG [cyan]Join subtitle")
         print()
 
     return out_path

StreamingCommunity/Lib/M3U8/estimator.py

@@ -42,7 +42,6 @@ class M3U8_Ts_Estimator:
     def add_ts_file(self, size: int):
         """Add a file size to the list of file sizes."""
         if size <= 0:
-            logging.error(f"Invalid input values: size={size}")
             return
 
         with self.lock:

StreamingCommunity/Lib/TMBD/tmdb.py

@@ -4,13 +4,12 @@ import sys
 
 
 # External libraries
-import httpx
 from rich.console import Console
 
 
 # Internal utilities
 from .obj_tmbd import Json_film
-from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Util.table import TVShowManager
 
 
@@ -18,7 +17,6 @@ from StreamingCommunity.Util.table import TVShowManager
 console = Console()
 table_show_manager = TVShowManager()
 api_key = "a800ed6c93274fb857ea61bd9e7256c5"
-MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 
 
 def get_select_title(table_show_manager, generic_obj):
@@ -113,7 +111,7 @@ class TheMovieDB:
 
         params['api_key'] = self.api_key
         url = f"{self.base_url}/{endpoint}"
-        response = httpx.get(url, params=params, timeout=MAX_TIMEOUT)
+        response = create_client().get(url, params=params)
         response.raise_for_status()
         
         return response.json()

StreamingCommunity/TelegramHelp/config.json

@@ -29,7 +29,6 @@
         "specific_list_audio": [
             "ita"
         ],
-        "download_subtitle": true,
         "merge_subs": true,
         "specific_list_subtitles": [
             "ita",

StreamingCommunity/Upload/version.py

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

StreamingCommunity/Util/config_json.py

@@ -318,7 +318,7 @@ class ConfigManager:
             logging.error(f"Download of {filename} failed: {e}")
             raise
     
-    def get(self, section: str, key: str, data_type: type = str, from_site: bool = False) -> Any:
+    def get(self, section: str, key: str, data_type: type = str, from_site: bool = False, default: Any = None) -> Any:
         """
         Read a value from the configuration.
         
@@ -327,9 +327,10 @@ class ConfigManager:
             key (str): Key to read
             data_type (type, optional): Expected data type. Default: str
             from_site (bool, optional): Whether to read from the site configuration. Default: False
+            default (Any, optional): Default value if key is not found. Default: None
             
         Returns:
-            Any: The key value converted to the specified data type
+            Any: The key value converted to the specified data type, or default if not found
         """
         cache_key = f"{'site' if from_site else 'config'}.{section}.{key}"
         logging.info(f"Reading key: {cache_key}")
@@ -343,9 +344,15 @@ class ConfigManager:
         
         # Check if the section and key exist
         if section not in config_source:
+            if default is not None:
+                logging.info(f"Section '{section}' not found. Returning default value.")
+                return default
             raise ValueError(f"Section '{section}' not found in {'site' if from_site else 'main'} configuration")
         
         if key not in config_source[section]:
+            if default is not None:
+                logging.info(f"Key '{key}' not found in section '{section}'. Returning default value.")
+                return default
             raise ValueError(f"Key '{key}' not found in section '{section}' of {'site' if from_site else 'main'} configuration")
         
         # Get and convert the value
@@ -356,7 +363,7 @@ class ConfigManager:
         self.cache[cache_key] = converted_value
         
         return converted_value
-    
+
     def _convert_to_data_type(self, value: Any, data_type: type) -> Any:
         """
         Convert the value to the specified data type.
@@ -399,30 +406,30 @@ class ConfigManager:
             raise ValueError(f"Cannot convert '{value}' to {data_type.__name__}: {str(e)}")
     
     # Getters for main configuration
-    def get_string(self, section: str, key: str) -> str:
+    def get_string(self, section: str, key: str, default: str = None) -> str:
         """Read a string from the main configuration."""
-        return self.get(section, key, str)
-    
-    def get_int(self, section: str, key: str) -> int:
+        return self.get(section, key, str, default=default)
+
+    def get_int(self, section: str, key: str, default: int = None) -> int:
         """Read an integer from the main configuration."""
-        return self.get(section, key, int)
-    
-    def get_float(self, section: str, key: str) -> float:
+        return self.get(section, key, int, default=default)
+
+    def get_float(self, section: str, key: str, default: float = None) -> float:
         """Read a float from the main configuration."""
-        return self.get(section, key, float)
-    
-    def get_bool(self, section: str, key: str) -> bool:
+        return self.get(section, key, float, default=default)
+
+    def get_bool(self, section: str, key: str, default: bool = None) -> bool:
         """Read a boolean from the main configuration."""
-        return self.get(section, key, bool)
-    
-    def get_list(self, section: str, key: str) -> List[str]:
+        return self.get(section, key, bool, default=default)
+
+    def get_list(self, section: str, key: str, default: List[str] = None) -> List[str]:
         """Read a list from the main configuration."""
-        return self.get(section, key, list)
-    
-    def get_dict(self, section: str, key: str) -> dict:
+        return self.get(section, key, list, default=default)
+
+    def get_dict(self, section: str, key: str, default: dict = None) -> dict:
         """Read a dictionary from the main configuration."""
-        return self.get(section, key, dict)
-    
+        return self.get(section, key, dict, default=default)
+
     # Getters for site configuration
     def get_site(self, section: str, key: str) -> Any:
         """Read a value from the site configuration."""

StreamingCommunity/Util/http_client.py

@@ -8,6 +8,7 @@ from typing import Any, Dict, Optional, Union
 
 # External library
 import httpx
+from curl_cffi import requests
 
 
 # Logic class
@@ -104,6 +105,33 @@ def create_async_client(
     )
 
 
+def create_client_curl(
+    *,
+    headers: Optional[Dict[str, str]] = None,
+    cookies: Optional[Dict[str, str]] = None,
+    timeout: Optional[Union[int, float]] = None,
+    verify: Optional[bool] = None,
+    proxies: Optional[Dict[str, str]] = None,
+    impersonate: str = "chrome136",
+    allow_redirects: bool = True,
+):
+    """Factory for a configured curl_cffi session."""
+    session = requests.Session()
+    session.headers.update(_default_headers(headers))
+    if cookies:
+        session.cookies.update(cookies)
+    session.timeout = timeout if timeout is not None else _get_timeout()
+    session.verify = _get_verify() if verify is None else verify
+    if proxies is not None:
+        session.proxies = proxies
+    elif _get_proxies():
+        session.proxies = _get_proxies()
+    session.impersonate = impersonate
+    session.allow_redirects = allow_redirects
+    
+    return session
+
+
 def _sleep_with_backoff(attempt: int, base: float = 1.1, cap: float = 10.0) -> None:
     """Exponential backoff with jitter."""
     delay = min(base * (2 ** attempt), cap)

StreamingCommunity/Util/os.py

@@ -71,27 +71,37 @@ class OsManager:
 
         return normalized
 
-    def get_sanitize_file(self, filename: str) -> str:
-        """Sanitize filename."""
+    def get_sanitize_file(self, filename: str, year: str = None) -> str:
+        """Sanitize filename. Optionally append a year in format ' (YYYY)' if year is provided and valid."""
         if not filename:
             return filename
 
-        # Decode and sanitize
+        # Extract and validate year if provided
+        year_str = ""
+        if year:
+            y = str(year).split('-')[0].strip()
+            if y.isdigit() and len(y) == 4:
+                year_str = f" ({y})"
+
+        # Decode and sanitize base filename
         decoded = unidecode(filename)
         sanitized = sanitize_filename(decoded)
 
         # Split name and extension
         name, ext = os.path.splitext(sanitized)
 
+        # Append year if present
+        name_with_year = name + year_str
+
         # Calculate available length for name considering the '...' and extension
         max_name_length = self.max_length - len('...') - len(ext)
 
         # Truncate name if it exceeds the max name length
-        if len(name) > max_name_length:
-            name = name[:max_name_length] + '...'
+        if len(name_with_year) > max_name_length:
+            name_with_year = name_with_year[:max_name_length] + '...'
 
         # Ensure the final file name includes the extension
-        return name + ext
+        return name_with_year + ext
 
     def get_sanitize_path(self, path: str) -> str:
         """Sanitize complete path."""

{streamingcommunity-3.3.8.dist-info → streamingcommunity-3.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: StreamingCommunity
-Version: 3.3.8
+Version: 3.4.0
 Home-page: https://github.com/Arrowar/StreamingCommunity
 Author: Arrowar
 Project-URL: Bug Reports, https://github.com/Arrowar/StreamingCommunity/issues
@@ -182,7 +182,6 @@ mpd_url = "https://example.com/stream.mpd"
 license_url = "https://example.com/get_license"
 
 dash_process = DASH_Downloader(
-    cdm_device=get_wvd_path(),
     license_url=license_url,
     mpd_url=mpd_url,
     output_path="output.mp4",
@@ -267,7 +266,6 @@ To enable qBittorrent integration, follow the setup guide [here](https://github.
         "specific_list_audio": [
             "ita"
         ],
-        "download_subtitle": true,
         "merge_subs": true,
         "specific_list_subtitles": [
             "ita",    // Specify language codes or use ["*"] to download all available subtitles