StreamingCommunity 3.2.1__py3-none-any.whl → 3.2.7__py3-none-any.whl

StreamingCommunity/Lib/Downloader/DASH/parser.py

@@ -0,0 +1,249 @@
+# 25.07.25
+
+from urllib.parse import urljoin
+import xml.etree.ElementTree as ET
+
+
+# External library
+import httpx
+from rich.console import Console
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_manager
+
+
+# Variable
+console = Console()
+max_timeout = config_manager.get_int('REQUESTS', 'timeout')
+
+
+class MPDParser:
+    @staticmethod
+    def get_best(representations):
+        """
+        Returns the video representation with the highest resolution/bandwidth, or audio with highest bandwidth.
+        """
+        videos = [r for r in representations if r['type'] == 'video']
+        audios = [r for r in representations if r['type'] == 'audio']
+        if videos:
+            return max(videos, key=lambda r: (r['height'], r['width'], r['bandwidth']))
+        elif audios:
+            return max(audios, key=lambda r: r['bandwidth'])
+        return None
+
+    @staticmethod
+    def get_worst(representations):
+        """
+        Returns the video representation with the lowest resolution/bandwidth, or audio with lowest bandwidth.
+        """
+        videos = [r for r in representations if r['type'] == 'video']
+        audios = [r for r in representations if r['type'] == 'audio']
+        if videos:
+            return min(videos, key=lambda r: (r['height'], r['width'], r['bandwidth']))
+        elif audios:
+            return min(audios, key=lambda r: r['bandwidth'])
+        return None
+
+    @staticmethod
+    def get_list(representations, type_filter=None):
+        """
+        Returns the list of representations filtered by type ('video', 'audio', etc.).
+        """
+        if type_filter:
+            return [r for r in representations if r['type'] == type_filter]
+        return representations
+
+    def __init__(self, mpd_url):
+        self.mpd_url = mpd_url
+        self.pssh = None
+        self.representations = []
+        self.base_url = mpd_url.rsplit('/', 1)[0] + '/'
+
+    def parse(self, custom_headers):
+        response = httpx.get(self.mpd_url, headers=custom_headers, timeout=max_timeout)
+        response.raise_for_status()
+
+        root = ET.fromstring(response.content)
+
+        # Properly handle default namespace
+        ns = {}
+        if root.tag.startswith('{'):
+            uri = root.tag[1:].split('}')[0]
+            ns['mpd'] = uri
+            ns['cenc'] = 'urn:mpeg:cenc:2013'
+
+        # Extract PSSH dynamically: take the first <cenc:pssh> found
+        for protection in root.findall('.//mpd:ContentProtection', ns):
+            pssh_element = protection.find('cenc:pssh', ns)
+            if pssh_element is not None and pssh_element.text:
+                self.pssh = pssh_element.text
+                break
+
+        if not self.pssh:
+            console.print("[bold red]PSSH not found in MPD![/bold red]")
+
+        # Extract representations
+        for adapt_set in root.findall('.//mpd:AdaptationSet', ns):
+            mime_type = adapt_set.get('mimeType', '')
+            lang = adapt_set.get('lang', '')
+
+            # Find SegmentTemplate at AdaptationSet level (DASH spec allows this)
+            seg_template = adapt_set.find('mpd:SegmentTemplate', ns)
+
+            for rep in adapt_set.findall('mpd:Representation', ns):
+                rep_id = rep.get('id')
+                bandwidth = rep.get('bandwidth')
+                codecs = rep.get('codecs')
+                width = rep.get('width')
+                height = rep.get('height')
+
+                # Try to find SegmentTemplate at Representation level (overrides AdaptationSet)
+                rep_seg_template = rep.find('mpd:SegmentTemplate', ns)
+                seg_tmpl = rep_seg_template if rep_seg_template is not None else seg_template
+                if seg_tmpl is None:
+                    continue
+
+                init = seg_tmpl.get('initialization')
+                media = seg_tmpl.get('media')
+                start_number = int(seg_tmpl.get('startNumber', 1))
+
+                # Use BaseURL from Representation if present, else fallback to self.base_url
+                base_url_elem = rep.find('mpd:BaseURL', ns)
+                base_url = base_url_elem.text if base_url_elem is not None else self.base_url
+
+                # Replace $RepresentationID$ in init/media if present
+                if init and '$RepresentationID$' in init:
+                    init = init.replace('$RepresentationID$', rep_id)
+                if media and '$RepresentationID$' in media:
+                    media = media.replace('$RepresentationID$', rep_id)
+
+                init_url = urljoin(base_url, init) if init else None
+
+                # Calculate segments from timeline
+                segments = []
+                seg_timeline = seg_tmpl.find('mpd:SegmentTimeline', ns)
+                if seg_timeline is not None:
+                    segment_number = start_number
+                    for s in seg_timeline.findall('mpd:S', ns):
+                        repeat = int(s.get('r', 0))
+                        
+                        # Always append at least one segment
+                        segments.append(segment_number)
+                        segment_number += 1
+                        for _ in range(repeat):
+                            segments.append(segment_number)
+                            segment_number += 1
+
+                if not segments:
+                    segments = list(range(start_number, start_number + 100))
+
+                # Replace $Number$ and $RepresentationID$ in media URL
+                media_urls = []
+                for n in segments:
+                    url = media
+                    if '$Number$' in url:
+                        url = url.replace('$Number$', str(n))
+                    if '$RepresentationID$' in url:
+                        url = url.replace('$RepresentationID$', rep_id)
+                    media_urls.append(urljoin(base_url, url))
+
+                self.representations.append({
+                    'id': rep_id,
+                    'type': mime_type.split('/')[0] if mime_type else (rep.get('mimeType', '').split('/')[0] if rep.get('mimeType') else 'unknown'),
+                    'codec': codecs,
+                    'bandwidth': int(bandwidth) if bandwidth else 0,
+                    'width': int(width) if width else 0,
+                    'height': int(height) if height else 0,
+                    'language': lang,
+                    'init_url': init_url,
+                    'segment_urls': media_urls
+                })
+
+    def get_resolutions(self):
+        """Return list of video representations with their resolutions."""
+        return [
+            rep for rep in self.representations
+            if rep['type'] == 'video'
+        ]
+
+    def get_audios(self):
+        """Return list of audio representations."""
+        return [
+            rep for rep in self.representations
+            if rep['type'] == 'audio'
+        ]
+
+    def get_best_video(self):
+        """Return the best video representation (highest resolution, then bandwidth)."""
+        videos = self.get_resolutions()
+        if not videos:
+            return None
+        
+        # Sort by (height, width, bandwidth)
+        return max(videos, key=lambda r: (r['height'], r['width'], r['bandwidth']))
+
+    def get_best_audio(self):
+        """Return the best audio representation (highest bandwidth)."""
+        audios = self.get_audios()
+        if not audios:
+            return None
+        return max(audios, key=lambda r: r['bandwidth'])
+
+    def select_video(self, force_resolution="Best"):
+        """
+        Select a video representation based on the requested resolution.
+        Returns: (selected_video, list_available_resolution, filter_custom_resolution, downloadable_video)
+        """
+        video_reps = self.get_resolutions()
+        list_available_resolution = [
+            f"{rep['width']}x{rep['height']}" for rep in video_reps
+        ]
+        force_resolution_l = (force_resolution or "Best").lower()
+
+        if force_resolution_l == "best":
+            selected_video = self.get_best_video()
+            filter_custom_resolution = "Best"
+
+        elif force_resolution_l == "worst":
+            selected_video = MPDParser.get_worst(video_reps)
+            filter_custom_resolution = "Worst"
+
+        else:
+            selected_video = self.get_best_video()
+            filter_custom_resolution = "Best"
+
+        downloadable_video = f"{selected_video['width']}x{selected_video['height']}" if selected_video else "N/A"
+        return selected_video, list_available_resolution, filter_custom_resolution, downloadable_video
+
+    def select_audio(self, preferred_audio_langs=None):
+        """
+        Select an audio representation based on preferred languages.
+        Returns: (selected_audio, list_available_audio_langs, filter_custom_audio, downloadable_audio)
+        """
+        audio_reps = self.get_audios()
+        list_available_audio_langs = [
+            rep['language'] or "None" for rep in audio_reps
+        ]
+
+        selected_audio = None
+        filter_custom_audio = "First"
+
+        if preferred_audio_langs:
+            
+            # Search for the first available language in order of preference
+            for lang in preferred_audio_langs:
+                for rep in audio_reps:
+                    if (rep['language'] or "None").lower() == lang.lower():
+                        selected_audio = rep
+                        filter_custom_audio = lang
+                        break
+                if selected_audio:
+                    break
+            if not selected_audio:
+                selected_audio = self.get_best_audio()
+        else:
+            selected_audio = self.get_best_audio()
+
+        downloadable_audio = selected_audio['language'] or "None" if selected_audio else "N/A"
+        return selected_audio, list_available_audio_langs, filter_custom_audio, downloadable_audio

StreamingCommunity/Lib/Downloader/DASH/segments.py

@@ -0,0 +1,332 @@
+# 25.07.25
+
+import os
+import asyncio
+
+
+# External libraries
+import httpx
+from tqdm import tqdm
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_userAgent
+from StreamingCommunity.Lib.M3U8.estimator import M3U8_Ts_Estimator
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.color import Colors
+
+
+# Config
+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")
+
+
+class MPD_Segments:
+    def __init__(self, tmp_folder: str, representation: dict, pssh: str = None):
+        """
+        Initialize MPD_Segments with temp folder, representation, and optional pssh.
+        """
+        self.tmp_folder = tmp_folder
+        self.selected_representation = representation
+        self.pssh = pssh
+        self.download_interrupted = False
+        self.info_nFailed = 0
+
+    def get_concat_path(self, output_dir: str = None):
+        """
+        Get the path for the concatenated output file.
+        """
+        rep_id = self.selected_representation['id']
+        return os.path.join(output_dir or self.tmp_folder, f"{rep_id}_encrypted.m4s")
+
+    def download_streams(self, output_dir: str = None):
+        """
+        Synchronous wrapper for download_segments, compatible with legacy calls.
+        """
+        concat_path = self.get_concat_path(output_dir)
+
+        # Run async download in sync mode
+        try:
+            asyncio.run(self.download_segments(output_dir=output_dir))
+
+        except KeyboardInterrupt:
+            self.download_interrupted = True
+            print("\n[red]Download interrupted by user (Ctrl+C).")
+
+        return {
+            "concat_path": concat_path,
+            "representation_id": self.selected_representation['id'],
+            "pssh": self.pssh
+        }
+
+    async def download_segments(self, output_dir: str = None, concurrent_downloads: int = 8, description: str = "DASH"):
+        """
+        Download and concatenate all segments (including init) asynchronously and in order.
+        """
+        rep = self.selected_representation
+        rep_id = rep['id']
+        segment_urls = rep['segment_urls']
+        init_url = rep.get('init_url')
+
+        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")
+
+        # Determine stream type (video/audio) for progress bar
+        stream_type = rep.get('type', description)
+        progress_bar = tqdm(
+            total=len(segment_urls) + 1,
+            desc=f"Downloading {rep_id}",
+            bar_format=self._get_bar_format(stream_type),
+            mininterval=0.6,
+            maxinterval=1.0
+        )
+
+        # Define semaphore for concurrent downloads
+        semaphore = asyncio.Semaphore(concurrent_downloads)
+
+        # Initialize estimator
+        estimator = M3U8_Ts_Estimator(total_segments=len(segment_urls) + 1)
+
+        results = [None] * len(segment_urls)
+        self.downloaded_segments = set()
+        self.info_nFailed = 0
+        self.download_interrupted = False
+        self.info_nRetry = 0
+
+        try:
+            async with httpx.AsyncClient(timeout=SEGMENT_MAX_TIMEOUT) as client:
+                # Download init segment
+                await self._download_init_segment(client, init_url, concat_path, estimator, progress_bar)
+
+                # Download all segments (first batch)
+                await self._download_segments_batch(
+                    client, segment_urls, results, 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
+                )
+
+                # Write all results to file
+                self._write_results_to_file(concat_path, results)
+
+        except KeyboardInterrupt:
+            self.download_interrupted = True
+            print("\n[red]Download interrupted by user (Ctrl+C).")
+
+        finally:
+            self._cleanup_resources(None, progress_bar)
+
+        self._verify_download_completion()
+        return self._generate_results(stream_type)
+
+    async def _download_init_segment(self, client, init_url, concat_path, estimator, progress_bar):
+        """
+        Download the init segment and update progress/estimator.
+        """
+        if not init_url:
+            with open(concat_path, 'wb') as outfile:
+                pass
+            return
+        
+        try:
+            headers = {'User-Agent': get_userAgent()}
+            response = await client.get(init_url, headers=headers)
+
+            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
+            estimator.update_progress_bar(len(response.content), progress_bar)
+
+        except Exception as e:
+            progress_bar.close()
+            raise RuntimeError(f"Error downloading init segment: {e}")
+
+    async def _download_segments_batch(self, client, segment_urls, results, semaphore, max_retry, estimator, progress_bar):
+        """
+        Download a batch of segments and update results.
+        """
+        async def download_single(url, idx):
+            async with semaphore:
+                headers = {'User-Agent': get_userAgent()}
+                for attempt in range(max_retry):
+                    try:
+                        resp = await client.get(url, headers=headers)
+                        if resp.status_code == 200:
+                            return idx, resp.content, attempt
+                        else:
+                            await asyncio.sleep(1.1 * (2 ** attempt))
+                    except Exception:
+                        await asyncio.sleep(1.1 * (2 ** attempt))
+                return idx, b'', max_retry
+
+        # Initial download attempt
+        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
+                if data and len(data) > 0:
+                    self.downloaded_segments.add(idx)
+                else:
+                    self.info_nFailed += 1
+                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
+                estimator.update_progress_bar(len(data), progress_bar)
+
+            except KeyboardInterrupt:
+                self.download_interrupted = True
+                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):
+        """
+        Retry failed segments up to 5 times.
+        """
+        max_global_retries = 5
+        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]
+            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()}
+
+                    for attempt in range(max_retry):
+                        try:
+                            resp = await client.get(url, headers=headers)
+
+                            if resp.status_code == 200:
+                                return idx, resp.content, attempt
+                            else:
+                                await asyncio.sleep(1.1 * (2 ** attempt))
+
+                        except Exception:
+                            await asyncio.sleep(1.1 * (2 ** attempt))
+                return idx, b'', max_retry
+
+            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
+
+                    if data and len(data) > 0:
+                        results[idx] = data
+                        self.downloaded_segments.add(idx)
+                    else:
+                        nFailed_this_round += 1
+
+                    self.info_nRetry += nretry
+                    progress_bar.update(0)  # No progress bar increment, already counted
+                    estimator.add_ts_file(len(data))
+                    estimator.update_progress_bar(len(data), progress_bar)
+
+                except KeyboardInterrupt:
+                    self.download_interrupted = True
+                    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):
+        """
+        Write all downloaded segments to the output file.
+        """
+        with open(concat_path, 'ab') as outfile:
+            for data in results:
+                if data:
+                    outfile.write(data)
+
+    def _get_bar_format(self, description: str) -> str:
+        """
+        Generate platform-appropriate progress bar format.
+        """
+        return (
+            f"{Colors.YELLOW}[MPD] ({Colors.CYAN}{description}{Colors.WHITE}): "
+            f"{Colors.RED}{{percentage:.2f}}% "
+            f"{Colors.MAGENTA}{{bar}} "
+            f"{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.WHITE}{{postfix}}{Colors.WHITE}"
+        )
+
+    def _get_worker_count(self, stream_type: str) -> int:
+        """
+        Calculate optimal parallel workers based on stream type and infrastructure.
+        """
+        base_workers = {
+            'video': DEFAULT_VIDEO_WORKERS,
+            'audio': DEFAULT_AUDIO_WORKERS
+        }.get(stream_type.lower(), 1)
+        return base_workers
+
+    def _generate_results(self, stream_type: str) -> dict:
+        """
+        Package final download results.
+        """
+        return {
+            'type': stream_type,
+            'nFailed': getattr(self, 'info_nFailed', 0),
+            'stopped': getattr(self, 'download_interrupted', False)
+        }
+
+    def _verify_download_completion(self) -> None:
+        """
+        Validate final download integrity.
+        """
+        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:
+            missing = sorted(set(range(total)) - completed)
+            raise RuntimeError(f"Download incomplete ({len(completed)/total:.1%}). Missing segments: {missing}")
+
+    def _cleanup_resources(self, writer_thread, progress_bar: tqdm) -> None:
+        """
+        Ensure resource cleanup and final reporting.
+        """
+        progress_bar.close()
+        if getattr(self, 'info_nFailed', 0) > 0:
+            self._display_error_summary()
+            
+        self.buffer = {}
+        self.expected_index = 0
+
+    def _display_error_summary(self) -> None:
+        """
+        Generate final error report.
+        """
+        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) > len(self.selected_representation['segment_urls']) * 0.3:
+            print("[yellow]Warning: High retry count detected. Consider reducing worker count in config.")

StreamingCommunity/Lib/Downloader/HLS/downloader.py

@@ -17,7 +17,7 @@ from rich.panel import Panel
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.headers import get_userAgent
-from StreamingCommunity.Util.os import compute_sha1_hash, os_manager, internet_manager
+from StreamingCommunity.Util.os import os_manager, internet_manager
 from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
 
@@ -33,15 +33,12 @@ from .segments import M3U8_Segments
 
 
 # Config
-ENABLE_AUDIO = config_manager.get_bool('M3U8_DOWNLOAD', 'download_audio')
 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_AUDIO = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_audio')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
 FILTER_CUSTOM_REOLUTION = str(config_manager.get('M3U8_PARSER', 'force_resolution')).strip().lower()
-GET_ONLY_LINK = config_manager.get_bool('M3U8_PARSER', 'get_only_link')
 RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
@@ -66,6 +63,7 @@ class HLSClient:
             Response content/text or None if all retries fail
         """
         client = httpx.Client(headers=self.headers, timeout=MAX_TIMEOUT, follow_redirects=True)
+
         for attempt in range(RETRY_LIMIT):
             try:
                 response = client.get(url)
@@ -96,11 +94,6 @@ class PathManager:
         Ensures output path is valid and follows expected format.
         Creates a hash-based filename if no path is provided.
         """
-        if not path:
-            root = config_manager.get('OUT_FOLDER', 'root_path')
-            hash_name = compute_sha1_hash(self.m3u8_url) + ".mp4"
-            return os.path.join(root, "undefined", hash_name)
-
         if not path.endswith(".mp4"):
             path += ".mp4"
 
@@ -172,12 +165,11 @@ class M3U8Manager:
                 logging.error("Resolution not recognized.")
                 self.video_url, self.video_res = self.parser._video.get_best_uri()
 
-            self.audio_streams = []
-            if ENABLE_AUDIO:
-                self.audio_streams = [
-                    s for s in (self.parser._audio.get_all_uris_and_names() or [])
-                    if s.get('language') in DOWNLOAD_SPECIFIC_AUDIO
-                ]
+            # Audio info
+            self.audio_streams = [
+                s for s in (self.parser._audio.get_all_uris_and_names() or [])
+                if s.get('language') in DOWNLOAD_SPECIFIC_AUDIO
+            ]
 
             self.sub_streams = []
             if ENABLE_SUBTITLE:
@@ -309,8 +301,8 @@ class DownloadManager:
         Downloads all selected streams (video, audio, subtitles).
         """
         return_stopped = False
-
         video_file = os.path.join(self.temp_dir, 'video', '0.ts')
+        
         if not os.path.exists(video_file):
             if self.download_video(video_url):
                 if not return_stopped:
@@ -375,7 +367,7 @@ class MergeManager:
             )
 
         else:
-            if MERGE_AUDIO and self.audio_streams:
+            if self.audio_streams:
                 audio_tracks = [{
                     'path': os.path.join(self.temp_dir, 'audio', a['language'], '0.ts'),
                     'name': a['language']
@@ -445,19 +437,7 @@ class HLS_Downloader:
                 if TELEGRAM_BOT:
                     bot.send_message(f"Contenuto già scaricato!", None)
                 return response
-            
-            if GET_ONLY_LINK:
-                console.print(f"URL: [bold red]{self.m3u8_url}[/bold red]")
-                return {
-                    'path': None,
-                    'url': self.m3u8_url,
-                    'is_master': getattr(self.m3u8_manager, 'is_master', None),
-                    'msg': None,
-                    'error': None,
-                    'stopped': True
-                }
-
-
+        
             self.path_manager.setup_directories()
 
             # Parse M3U8 and determine if it's a master playlist