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

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -1,14 +1,12 @@
 # 17.10.24
 
 import os
-import time
 import logging
 import shutil
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 
 # External libraries
-import httpx
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
@@ -17,7 +15,7 @@ from rich.table import Table
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.headers import get_userAgent
-from StreamingCommunity.Util.http_client import create_client
+from StreamingCommunity.Util.http_client import fetch
 from StreamingCommunity.Util.os import os_manager, internet_manager
 
 
@@ -33,15 +31,13 @@ from .segments import M3U8_Segments
 
 
 # Config
-ENABLE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'download_subtitle')
 DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_audio')
 DOWNLOAD_SPECIFIC_SUBTITLE = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_subtitles')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
 GET_ONLY_LINK = config_manager.get_int('M3U8_DOWNLOAD', 'get_only_link')
 FILTER_CUSTOM_RESOLUTION = str(config_manager.get('M3U8_CONVERSION', 'force_resolution')).strip().lower()
-RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
-MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
+EXTENSION_OUTPUT = config_manager.get("M3U8_CONVERSION", "extension")
 
 console = Console()
 
@@ -51,9 +47,9 @@ class HLSClient:
     def __init__(self, custom_headers: Optional[Dict[str, str]] = None):
         self.headers = custom_headers if custom_headers else {'User-Agent': get_userAgent()}
 
-    def request(self, url: str, return_content: bool = False) -> Optional[httpx.Response]:
+    def request(self, url: str, return_content: bool = False) -> Optional[Union[str, bytes]]:
         """
-        Makes HTTP GET requests with retry logic.
+        Makes HTTP GET requests with retry logic using http_client.
 
         Args:
             url: Target URL to request
@@ -67,21 +63,12 @@ class HLSClient:
             logging.error("URL is None or empty, cannot make request")
             return None
 
-        client = create_client(headers=self.headers)
-
-        for attempt in range(RETRY_LIMIT):
-            try:
-                response = client.get(url)
-                response.raise_for_status()
-                return response.content if return_content else response.text
-
-            except Exception as e:
-                logging.error(f"Attempt {attempt+1} failed for URL {url}: {str(e)}")
-                if attempt < RETRY_LIMIT - 1:  # Don't sleep on last attempt
-                    time.sleep(1.5 ** attempt)
-        
-        logging.error(f"All {RETRY_LIMIT} attempts failed for URL: {url}")
-        return None
+        return fetch(
+            url,
+            method="GET",
+            headers=self.headers,
+            return_content=return_content
+        )
 
 
 class PathManager:
@@ -94,7 +81,7 @@ class PathManager:
         """
         self.m3u8_url = m3u8_url
         self.output_path = self._sanitize_output_path(output_path)
-        base_name = os.path.basename(self.output_path).replace(".mp4", "")
+        base_name = os.path.basename(self.output_path).replace(EXTENSION_OUTPUT, "")
         self.temp_dir = os.path.join(os.path.dirname(self.output_path), f"{base_name}_tmp")
 
     def _sanitize_output_path(self, path: Optional[str]) -> str:
@@ -103,10 +90,10 @@ class PathManager:
         Creates a hash-based filename if no path is provided.
         """
         if not path:
-            path = "download.mp4"
+            path = f"download{EXTENSION_OUTPUT}"
             
-        if not path.endswith(".mp4"):
-            path += ".mp4"
+        if not path.endswith(EXTENSION_OUTPUT):
+            path += EXTENSION_OUTPUT
 
         return os_manager.get_sanitize_path(path)
 
@@ -182,6 +169,11 @@ class M3U8Manager:
             elif str(FILTER_CUSTOM_RESOLUTION).replace("p", "").replace("px", "").isdigit():
                 resolution_value = int(str(FILTER_CUSTOM_RESOLUTION).replace("p", "").replace("px", ""))
                 self.video_url, self.video_res = self.parser._video.get_custom_uri(resolution_value)
+
+                # Fallback to best if custom resolution not found
+                if self.video_url is None:
+                    self.video_url, self.video_res = self.parser._video.get_best_uri()
+
             else:
                 logging.error("Resolution not recognized.")
                 self.video_url, self.video_res = self.parser._video.get_best_uri()
@@ -192,15 +184,15 @@ class M3U8Manager:
                 if s.get('language') in DOWNLOAD_SPECIFIC_AUDIO
             ]
 
+            # Subtitle info
             self.sub_streams = []
-            if ENABLE_SUBTITLE:
-                if "*" in DOWNLOAD_SPECIFIC_SUBTITLE:
-                    self.sub_streams = self.parser._subtitle.get_all_uris_and_names() or []
-                else:
-                    self.sub_streams = [
-                        s for s in (self.parser._subtitle.get_all_uris_and_names() or [])
-                        if s.get('language') in DOWNLOAD_SPECIFIC_SUBTITLE
-                    ]
+            if "*" in DOWNLOAD_SPECIFIC_SUBTITLE:
+                self.sub_streams = self.parser._subtitle.get_all_uris_and_names() or []
+            else:
+                self.sub_streams = [
+                    s for s in (self.parser._subtitle.get_all_uris_and_names() or [])
+                    if s.get('language') in DOWNLOAD_SPECIFIC_SUBTITLE
+                ]
 
     def log_selection(self):
         """Log the stream selection information in a formatted table."""
@@ -220,17 +212,6 @@ class M3U8Manager:
             
             data_rows.append(["Video", available_video, str(FILTER_CUSTOM_RESOLUTION), downloadable_video])
             
-            # Codec information
-            if self.parser.codec is not None:
-                available_codec_info = (
-                    f"v: {self.parser.codec.video_codec_name} "
-                    f"(b: {self.parser.codec.video_bitrate // 1000}k), "
-                    f"a: {self.parser.codec.audio_codec_name} "
-                    f"(b: {self.parser.codec.audio_bitrate // 1000}k)"
-                )
-                set_codec_info = available_codec_info if config_manager.get_bool("M3U8_CONVERSION", "use_codec") else "copy"
-                
-                data_rows.append(["Codec", available_codec_info, set_codec_info, set_codec_info])
 
             # Subtitle information
             available_subtitles = self.parser._subtitle.get_all_uris_and_names() or []
@@ -683,11 +664,11 @@ class HLS_Downloader:
 
         new_filename = self.path_manager.output_path
         if missing_ts and use_shortest:
-            new_filename = new_filename.replace(".mp4", "_failed_sync_ts.mp4")
+            new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_sync_ts{EXTENSION_OUTPUT}")
         elif missing_ts:
-            new_filename = new_filename.replace(".mp4", "_failed_ts.mp4")
+            new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_ts{EXTENSION_OUTPUT}")
         elif use_shortest:
-            new_filename = new_filename.replace(".mp4", "_failed_sync.mp4")
+            new_filename = new_filename.replace(EXTENSION_OUTPUT, f"_failed_sync{EXTENSION_OUTPUT}")
 
         if missing_ts or use_shortest:
             os.rename(self.path_manager.output_path, new_filename)

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -18,6 +18,7 @@ from rich.console import Console
 # Internal utilities
 from StreamingCommunity.Util.color import Colors
 from StreamingCommunity.Util.headers import get_userAgent
+from StreamingCommunity.Util.http_client import create_client_curl
 from StreamingCommunity.Util.config_json import config_manager
 
 
@@ -38,6 +39,7 @@ DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_w
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
 LIMIT_SEGMENT = config_manager.get_int('M3U8_DOWNLOAD', 'limit_segment')
+ENABLE_RETRY = config_manager.get_bool('M3U8_DOWNLOAD', 'enable_retry')
 
 
 # Variable
@@ -68,6 +70,8 @@ class M3U8_Segments:
             self.limit_segments = LIMIT_SEGMENT if LIMIT_SEGMENT > 0 else None
         else:
             self.limit_segments = limit_segments
+            
+        self.enable_retry = ENABLE_RETRY
 
         # Util class
         self.decryption: M3U8_Decryption = None 
@@ -94,12 +98,7 @@ class M3U8_Segments:
         self.key_base_url = f"{parsed_url.scheme}://{parsed_url.netloc}/"
         
         try:
-            client_params = {
-                'headers': self.custom_headers, 
-                'timeout': MAX_TIMEOUT, 
-                'verify': REQUEST_VERIFY
-            }
-            response = httpx.get(url=key_uri, **client_params)
+            response = create_client_curl(headers=self.custom_headers).get(key_uri)
             response.raise_for_status()
 
             hex_content = binascii.hexlify(response.content).decode('utf-8')
@@ -146,12 +145,7 @@ class M3U8_Segments:
         """
         if self.is_index_url:
             try:
-                client_params = {
-                    'headers': self.custom_headers, 
-                    'timeout': MAX_TIMEOUT, 
-                    'verify': REQUEST_VERIFY
-                }
-                response = httpx.get(self.url, **client_params, follow_redirects=True)
+                response = create_client_curl(headers=self.custom_headers).get(self.url)
                 response.raise_for_status()
                 
                 self.parse_data(response.text)
@@ -174,7 +168,7 @@ class M3U8_Segments:
         """
         Get the file path for a temporary segment.
         """
-        return os.path.join(temp_dir, f"seg_{index:06d}.tmp")
+        return os.path.join(temp_dir, f"seg_{index:06d}.ts")
 
     async def _download_init_segment(self, client: httpx.AsyncClient, output_path: str, progress_bar: tqdm) -> bool:
         """
@@ -220,7 +214,7 @@ class M3U8_Segments:
     async def _download_single_segment(self, client: httpx.AsyncClient, ts_url: str, index: int, temp_dir: str,
                                        semaphore: asyncio.Semaphore, max_retry: int) -> tuple:
         """
-        Downloads a single TS segment and saves to temp file.
+        Downloads a single TS segment and saves to temp file IMMEDIATELY.
 
         Returns:
             tuple: (index, success, retry_count, file_size)
@@ -248,11 +242,13 @@ class M3U8_Segments:
                                 return index, False, attempt, 0
                             raise e
 
-                    # Write to temp file
+                    # Write segment to temp file IMMEDIATELY
                     with open(temp_file, 'wb') as f:
                         f.write(segment_content)
-
-                    return index, True, attempt, len(segment_content)
+                    
+                    size = len(segment_content)
+                    del segment_content
+                    return index, True, attempt, size
 
                 except Exception:
                     if attempt + 1 == max_retry:
@@ -296,8 +292,8 @@ class M3U8_Segments:
                 console.print("\n[red]Download interrupted by user (Ctrl+C).")
                 break
 
-        # Retry failed segments
-        if not self.download_interrupted:
+        # Retry failed segments only if enabled
+        if self.enable_retry and not self.download_interrupted:
             await self._retry_failed_segments(client, temp_dir, semaphore, progress_bar)
 
     async def _retry_failed_segments(self, client: httpx.AsyncClient, temp_dir: str, semaphore: asyncio.Semaphore, 
@@ -356,6 +352,7 @@ class M3U8_Segments:
                 if os.path.exists(temp_file):
                     with open(temp_file, 'rb') as infile:
                         outfile.write(infile.read())
+                    os.remove(temp_file)
 
     async def download_segments_async(self, description: str, type: str):
         """
@@ -473,13 +470,12 @@ class M3U8_Segments:
         """Ensure resource cleanup and final reporting."""
         progress_bar.close()
         
-        # Delete temp segment files
+        # Delete temp directory if exists
         if temp_dir and os.path.exists(temp_dir):
             try:
-                for idx in range(len(self.segments)):
-                    temp_file = self._get_temp_segment_path(temp_dir, idx)
-                    if os.path.exists(temp_file):
-                        os.remove(temp_file)
+                # Remove any remaining files (in case of interruption)
+                for file in os.listdir(temp_dir):
+                    os.remove(os.path.join(temp_dir, file))
                 os.rmdir(temp_dir)
             except Exception as e:
                 console.print(f"[yellow]Warning: Could not clean temp directory: {e}")
@@ -489,7 +485,6 @@ class M3U8_Segments:
 
     def _display_error_summary(self) -> None:
         """Generate final error report."""
-        console.print(f"\n[green]Retry Summary: "
-                     f"[cyan]Max retries: [red]{self.info_maxRetry} "
-                     f"[cyan]Total retries: [red]{self.info_nRetry} "
-                     f"[cyan]Failed segments: [red]{self.info_nFailed}")
+        console.print(f" [cyan]Max retries: [red]{self.info_maxRetry} [white] | "
+            f"[cyan]Total retries: [red]{self.info_nRetry} [white] | "
+            f"[cyan]Failed segments: [red]{self.info_nFailed}")

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,42 +122,11 @@ 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:
@@ -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,59 +190,25 @@ 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")
         print()
@@ -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,7 +250,6 @@ 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")
         print()

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.9'
+__version__ = '3.4.0'
 __author__ = 'Arrowar'
 __description__ = 'A command-line program to download film'
 __copyright__ = 'Copyright 2025'