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

StreamingCommunity/Lib/Downloader/DASH/segments.py

@@ -8,6 +8,7 @@ import time
 # External libraries
 import httpx
 from tqdm import tqdm
+from rich.console import Console
 
 
 # Internal utilities
@@ -22,6 +23,12 @@ REQUEST_MAX_RETRY = config_manager.get_int('REQUESTS', 'max_retry')
 DEFAULT_VIDEO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_video_workers')
 DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_workers')
 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
+console = Console()
 
 
 class MPD_Segments:
@@ -38,7 +45,14 @@ class MPD_Segments:
         self.tmp_folder = tmp_folder
         self.selected_representation = representation
         self.pssh = pssh
-        self.limit_segments = limit_segments
+        
+        # Use LIMIT_SEGMENT from config if limit_segments is not specified or is 0
+        if limit_segments is None or limit_segments == 0:
+            self.limit_segments = LIMIT_SEGMENT if LIMIT_SEGMENT > 0 else None
+        else:
+            self.limit_segments = limit_segments
+        
+        self.enable_retry = ENABLE_RETRY
         self.download_interrupted = False
         self.info_nFailed = 0
         
@@ -50,6 +64,10 @@ class MPD_Segments:
         # Progress
         self._last_progress_update = 0
         self._progress_update_interval = 0.1
+        
+        # Segment tracking - store only metadata, not content
+        self.segment_status = {}  # {idx: {'downloaded': bool, 'size': int}}
+        self.segments_lock = asyncio.Lock()
 
     def get_concat_path(self, output_dir: str = None):
         """
@@ -78,10 +96,9 @@ class MPD_Segments:
         if self.limit_segments is not None:
             orig_count = len(self.selected_representation.get('segment_urls', []))
             if orig_count > self.limit_segments:
-                
+
                 # Limit segment URLs
                 self.selected_representation['segment_urls'] = self.selected_representation['segment_urls'][:self.limit_segments]
-                print(f"[yellow]Limiting segments from {orig_count} to {self.limit_segments}")
 
         # Run async download in sync mode
         try:
@@ -89,7 +106,7 @@ class MPD_Segments:
 
         except KeyboardInterrupt:
             self.download_interrupted = True
-            print("\n[red]Download interrupted by user (Ctrl+C).")
+            console.print("\n[red]Download interrupted by user (Ctrl+C).")
 
         return {
             "concat_path": concat_path,
@@ -99,7 +116,7 @@ class MPD_Segments:
 
     async def download_segments(self, output_dir: str = None, concurrent_downloads: int = None, description: str = "DASH"):
         """
-        Download and concatenate all segments (including init) asynchronously and in order.
+        Download segments to temporary files, then concatenate them in order.
         
         Parameters:
             - output_dir (str): Output directory for segments
@@ -113,6 +130,9 @@ class MPD_Segments:
 
         os.makedirs(output_dir or self.tmp_folder, exist_ok=True)
         concat_path = os.path.join(output_dir or self.tmp_folder, f"{rep_id}_encrypted.m4s")
+        
+        temp_dir = os.path.join(output_dir or self.tmp_folder, f"{rep_id}_segments")
+        os.makedirs(temp_dir, exist_ok=True)
 
         # Determine stream type (video/audio) for progress bar
         stream_type = description
@@ -132,7 +152,7 @@ class MPD_Segments:
         # Initialize estimator
         estimator = M3U8_Ts_Estimator(total_segments=len(segment_urls) + 1)
 
-        results = [None] * len(segment_urls)
+        self.segment_status = {}
         self.downloaded_segments = set()
         self.info_nFailed = 0
         self.download_interrupted = False
@@ -148,25 +168,26 @@ class MPD_Segments:
                 # Download init segment
                 await self._download_init_segment(client, init_url, concat_path, estimator, progress_bar)
 
-                # Download all segments (first batch)
+                # Download all segments to temp files
                 await self._download_segments_batch(
-                    client, segment_urls, results, semaphore, REQUEST_MAX_RETRY, estimator, progress_bar
+                    client, segment_urls, temp_dir, semaphore, REQUEST_MAX_RETRY, estimator, progress_bar
                 )
 
-                # Retry failed segments 
-                await self._retry_failed_segments(
-                    client, segment_urls, results, semaphore, REQUEST_MAX_RETRY, estimator, progress_bar
-                )
+                # Retry failed segments only if enabled
+                if self.enable_retry:
+                    await self._retry_failed_segments(
+                        client, segment_urls, temp_dir, semaphore, REQUEST_MAX_RETRY, estimator, progress_bar
+                    )
 
-                # Write all results to file
-                self._write_results_to_file(concat_path, results)
+                # Concatenate all segments IN ORDER
+                await self._concatenate_segments_in_order(temp_dir, concat_path, len(segment_urls))
 
         except KeyboardInterrupt:
             self.download_interrupted = True
-            print("\n[red]Download interrupted by user (Ctrl+C).")
+            console.print("\n[red]Download interrupted by user (Ctrl+C).")
 
         finally:
-            self._cleanup_resources(None, progress_bar)
+            self._cleanup_resources(temp_dir, progress_bar)
 
         self._verify_download_completion()
         return self._generate_results(stream_type)
@@ -187,12 +208,9 @@ class MPD_Segments:
             with open(concat_path, 'wb') as outfile:
                 if response.status_code == 200:
                     outfile.write(response.content)
-                    # Update estimator with init segment size
                     estimator.add_ts_file(len(response.content))
 
             progress_bar.update(1)
-
-            # Update progress bar with estimated info
             self._throttled_progress_update(len(response.content), estimator, progress_bar)
 
         except Exception as e:
@@ -208,24 +226,35 @@ class MPD_Segments:
             estimator.update_progress_bar(content_size, progress_bar)
             self._last_progress_update = current_time
 
-    async def _download_segments_batch(self, client, segment_urls, results, semaphore, max_retry, estimator, progress_bar):
+    async def _download_segments_batch(self, client, segment_urls, temp_dir, semaphore, max_retry, estimator, progress_bar):
         """
-        Download a batch of segments and update results.
+        Download segments to temporary files - write immediately to disk, not memory.
         """
         async def download_single(url, idx):
             async with semaphore:
                 headers = {'User-Agent': get_userAgent()}
+                temp_file = os.path.join(temp_dir, f"seg_{idx:06d}.tmp")
                 
                 for attempt in range(max_retry):
                     if self.download_interrupted:
-                        return idx, b'', attempt
+                        return idx, False, attempt, 0
                         
                     try:
                         timeout = min(SEGMENT_MAX_TIMEOUT, 10 + attempt * 3)
                         resp = await client.get(url, headers=headers, follow_redirects=True, timeout=timeout)
 
+                        # Write directly to temp file
                         if resp.status_code == 200:
-                            return idx, resp.content, attempt
+                            content_size = len(resp.content)
+                            with open(temp_file, 'wb') as f:
+                                f.write(resp.content)
+                            
+                            # Update status
+                            async with self.segments_lock:
+                                self.segment_status[idx] = {'downloaded': True, 'size': content_size}
+                                self.downloaded_segments.add(idx)
+                            
+                            return idx, True, attempt, content_size
                         else:
                             if attempt < 2:
                                 sleep_time = 0.5 + attempt * 0.5
@@ -236,20 +265,21 @@ class MPD_Segments:
                     except Exception:
                         sleep_time = min(2.0, 1.1 * (2 ** attempt))
                         await asyncio.sleep(sleep_time)
+                
+                # Mark as failed
+                async with self.segments_lock:
+                    self.segment_status[idx] = {'downloaded': False, 'size': 0}
                         
-                return idx, b'', max_retry
+                return idx, False, max_retry, 0
 
-        # Initial download attempt
+        # Download all segments concurrently
         tasks = [download_single(url, i) for i, url in enumerate(segment_urls)]
 
         for coro in asyncio.as_completed(tasks):
             try:
-                idx, data, nretry = await coro
-                results[idx] = data
+                idx, success, nretry, size = await coro
                 
-                if data and len(data) > 0:
-                    self.downloaded_segments.add(idx)
-                else:
+                if not success:
                     self.info_nFailed += 1
                 
                 if nretry > self.info_maxRetry:
@@ -257,19 +287,15 @@ class MPD_Segments:
                 self.info_nRetry += nretry
                     
                 progress_bar.update(1)
-
-                # Update estimator with segment size
-                estimator.add_ts_file(len(data))
-
-                # Update progress bar with estimated info and segment count
-                self._throttled_progress_update(len(data), estimator, progress_bar)
+                estimator.add_ts_file(size)
+                self._throttled_progress_update(size, estimator, progress_bar)
 
             except KeyboardInterrupt:
                 self.download_interrupted = True
-                print("\n[red]Download interrupted by user (Ctrl+C).")
+                console.print("\n[red]Download interrupted by user (Ctrl+C).")
                 break
 
-    async def _retry_failed_segments(self, client, segment_urls, results, semaphore, max_retry, estimator, progress_bar):
+    async def _retry_failed_segments(self, client, segment_urls, temp_dir, semaphore, max_retry, estimator, progress_bar):
         """
         Retry failed segments up to 3 times.
         """
@@ -277,79 +303,93 @@ class MPD_Segments:
         global_retry_count = 0
 
         while self.info_nFailed > 0 and global_retry_count < max_global_retries and not self.download_interrupted:
-            failed_indices = [i for i, data in enumerate(results) if not data or len(data) == 0]
+            failed_indices = [i for i in range(len(segment_urls)) if i not in self.downloaded_segments]
             if not failed_indices:
                 break
-
-            print(f"[yellow]Retrying {len(failed_indices)} failed segments (attempt {global_retry_count+1}/{max_global_retries})...")
             
             async def download_single(url, idx):
                 async with semaphore:
                     headers = {'User-Agent': get_userAgent()}
+                    temp_file = os.path.join(temp_dir, f"seg_{idx:06d}.tmp")
 
                     for attempt in range(max_retry):
                         if self.download_interrupted:
-                            return idx, b'', attempt
+                            return idx, False, attempt, 0
                             
                         try:
                             timeout = min(SEGMENT_MAX_TIMEOUT, 15 + attempt * 5)
                             resp = await client.get(url, headers=headers, timeout=timeout)
                             
+                            # Write directly to temp file
                             if resp.status_code == 200:
-                                return idx, resp.content, attempt
+                                content_size = len(resp.content)
+                                with open(temp_file, 'wb') as f:
+                                    f.write(resp.content)
+                                
+                                async with self.segments_lock:
+                                    self.segment_status[idx] = {'downloaded': True, 'size': content_size}
+                                    self.downloaded_segments.add(idx)
+                                
+                                return idx, True, attempt, content_size
                             else:
                                 await asyncio.sleep(1.5 * (2 ** attempt))
 
                         except Exception:
                             await asyncio.sleep(1.5 * (2 ** attempt))
                             
-                return idx, b'', max_retry
+                return idx, False, max_retry, 0
 
             retry_tasks = [download_single(segment_urls[i], i) for i in failed_indices]
 
-            # Reset nFailed for this round
             nFailed_this_round = 0
             for coro in asyncio.as_completed(retry_tasks):
                 try:
-                    idx, data, nretry = await coro
+                    idx, success, nretry, size = await coro
 
-                    if data and len(data) > 0:
-                        results[idx] = data
-                        self.downloaded_segments.add(idx)
-                    else:
+                    if not success:
                         nFailed_this_round += 1
 
                     if nretry > self.info_maxRetry:
                         self.info_maxRetry = nretry
                     self.info_nRetry += nretry
                     
-                    progress_bar.update(0)  # No progress bar increment, already counted
-                    estimator.add_ts_file(len(data))
-                    self._throttled_progress_update(len(data), estimator, progress_bar)
+                    progress_bar.update(0)
+                    estimator.add_ts_file(size)
+                    self._throttled_progress_update(size, estimator, progress_bar)
 
                 except KeyboardInterrupt:
                     self.download_interrupted = True
-                    print("\n[red]Download interrupted by user (Ctrl+C).")
+                    console.print("\n[red]Download interrupted by user (Ctrl+C).")
                     break
                     
             self.info_nFailed = nFailed_this_round
             global_retry_count += 1
 
-    def _write_results_to_file(self, concat_path, results):
+    async def _concatenate_segments_in_order(self, temp_dir, concat_path, total_segments):
         """
-        Write all downloaded segments to the output file.
+        Concatenate all segment files IN ORDER to the final output file.
         """
         with open(concat_path, 'ab') as outfile:
-            for data in results:
-                if data:
-                    outfile.write(data)
+            for idx in range(total_segments):
+                temp_file = os.path.join(temp_dir, f"seg_{idx:06d}.tmp")
+                
+                # Only concatenate successfully downloaded segments
+                if idx in self.downloaded_segments and os.path.exists(temp_file):
+                    with open(temp_file, 'rb') as infile:
+                        
+                        # Read and write in chunks to avoid memory issues
+                        while True:
+                            chunk = infile.read(8192)  # 8KB chunks
+                            if not chunk:
+                                break
+                            outfile.write(chunk)
 
     def _get_bar_format(self, description: str) -> str:
         """
         Generate platform-appropriate progress bar format.
         """
         return (
-            f"{Colors.YELLOW}[DASH]{Colors.CYAN} {description}{Colors.WHITE}: "
+            f"{Colors.YELLOW}DASH{Colors.CYAN} {description}{Colors.WHITE}: "
             f"{Colors.MAGENTA}{{bar:40}} "
             f"{Colors.LIGHT_GREEN}{{n_fmt}}{Colors.WHITE}/{Colors.CYAN}{{total_fmt}} {Colors.LIGHT_MAGENTA}TS {Colors.WHITE}"
             f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
@@ -378,43 +418,60 @@ class MPD_Segments:
 
     def _verify_download_completion(self) -> None:
         """
-        Validate final download integrity.
+        Validate final download integrity - allow partial downloads.
         """
         total = len(self.selected_representation['segment_urls'])
         completed = getattr(self, 'downloaded_segments', set())
 
-        # If interrupted, skip raising error
         if self.download_interrupted:
             return
         
         if total == 0:
             return
         
-        if len(completed) / total < 0.999:
+        completion_rate = len(completed) / total
+        missing_count = total - len(completed)
+        
+        # Allow downloads with up to 30 missing segments or 90% completion rate
+        if completion_rate >= 0.90 or missing_count <= 30:
+            return
+        
+        else:
             missing = sorted(set(range(total)) - completed)
-            raise RuntimeError(f"Download incomplete ({len(completed)/total:.1%}). Missing segments: {missing}")
+            console.print(f"[red]Missing segments: {missing[:10]}..." if len(missing) > 10 else f"[red]Missing segments: {missing}")
 
-    def _cleanup_resources(self, writer_thread, progress_bar: tqdm) -> None:
+    def _cleanup_resources(self, temp_dir, progress_bar: tqdm) -> None:
         """
         Ensure resource cleanup and final reporting.
         """
         progress_bar.close()
+        
+        # Delete temp segment files
+        if temp_dir and os.path.exists(temp_dir):
+            try:
+                for idx in range(len(self.selected_representation.get('segment_urls', []))):
+                    temp_file = os.path.join(temp_dir, f"seg_{idx:06d}.tmp")
+                    if os.path.exists(temp_file):
+                        os.remove(temp_file)
+                os.rmdir(temp_dir)
+
+            except Exception as e:
+                print(f"[yellow]Warning: Could not clean temp directory: {e}")
+        
         if getattr(self, 'info_nFailed', 0) > 0:
             self._display_error_summary()
             
         # Clear memory
-        self.buffer = {}
-        self.expected_index = 0
+        self.segment_status = {}
 
     def _display_error_summary(self) -> None:
         """
         Generate final error report.
         """
         total_segments = len(self.selected_representation.get('segment_urls', []))
-        print(f"\n[cyan]Retry Summary: "
-              f"[white]Max retries: [green]{getattr(self, 'info_maxRetry', 0)} "
-              f"[white]Total retries: [green]{getattr(self, 'info_nRetry', 0)} "
-              f"[white]Failed segments: [red]{getattr(self, 'info_nFailed', 0)}")
-        
-        if getattr(self, 'info_nRetry', 0) > total_segments * 0.3:
-            print("[yellow]Warning: High retry count detected. Consider reducing worker count in config.")
+        failed_indices = [i for i in range(total_segments) if i not in self.downloaded_segments]
+
+        console.print(f" [cyan]Max retries: [red]{getattr(self, 'info_maxRetry', 0)} [white]| "
+            f"[cyan]Total retries: [red]{getattr(self, 'info_nRetry', 0)} [white]| "
+            f"[cyan]Failed segments: [red]{getattr(self, 'info_nFailed', 0)} [white]| "
+            f"[cyan]Failed indices: [red]{failed_indices}")

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)