StreamingCommunity 3.2.0__py3-none-any.whl → 3.2.5__py3-none-any.whl

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

@@ -41,7 +41,6 @@ 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')
@@ -445,19 +444,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

StreamingCommunity/Lib/Downloader/HLS/segments.py

@@ -35,11 +35,11 @@ from ...M3U8 import (
 )
 
 # Config
-TQDM_DELAY_WORKER = config_manager.get_float('M3U8_DOWNLOAD', 'tqdm_delay')
+TQDM_DELAY_WORKER = 0.01
 REQUEST_MAX_RETRY = config_manager.get_int('REQUESTS', 'max_retry')
 REQUEST_VERIFY = config_manager.get_bool('REQUESTS', 'verify')
-DEFAULT_VIDEO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_video_workser')
-DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_workser')
+DEFAULT_VIDEO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_video_workers')
+DEFAULT_AUDIO_WORKERS = config_manager.get_int('M3U8_DOWNLOAD', 'default_audio_workers')
 MAX_TIMEOOUT = config_manager.get_int("REQUESTS", "timeout")
 SEGMENT_MAX_TIMEOUT = config_manager.get_int("M3U8_DOWNLOAD", "segment_timeout")
 TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')

StreamingCommunity/Lib/Downloader/MP4/downloader.py

@@ -31,7 +31,6 @@ from ...FFmpeg import print_duration_table
 
 # Config
 REQUEST_VERIFY = config_manager.get_bool('REQUESTS', 'verify')
-GET_ONLY_LINK = config_manager.get_bool('M3U8_PARSER', 'get_only_link')
 REQUEST_TIMEOUT = config_manager.get_float('REQUESTS', 'timeout')
 TELEGRAM_BOT = config_manager.get_bool('DEFAULT', 'telegram_bot')
 
@@ -87,10 +86,6 @@ def MP4_downloader(url: str, path: str, referer: str = None, headers_: dict = No
             bot.send_message(f"Contenuto già scaricato!", None)
         return None, False
 
-    if GET_ONLY_LINK:
-        console.print(f"[bold red]URL: {url}[/bold red]")
-        return path, True
-
     if not (url.lower().startswith('http://') or url.lower().startswith('https://')):
         logging.error(f"Invalid URL: {url}")
         console.print(f"[bold red]Invalid URL: {url}[/bold red]")

StreamingCommunity/Lib/FFmpeg/capture.py

@@ -30,14 +30,14 @@ def capture_output(process: subprocess.Popen, description: str) -> None:
     try:
         max_length = 0
 
-        for line in iter(process.stdout.readline, ''):
+        for line in iter(process.stdout.readline, ''):          
             try:
                 line = line.strip()
+                logging.info(f"CAPTURE ffmpeg line: {line}")
+
                 if not line:
                     continue
 
-                logging.info(f"CAPTURE ffmpeg line: {line}")
-
                 # Check if termination is requested
                 if terminate_flag.is_set():
                     break

StreamingCommunity/Lib/FFmpeg/command.py

@@ -251,8 +251,8 @@ def join_audios(video_path: str, audio_tracks: List[Dict[str, str]], out_path: s
     # Run join
     if DEBUG_MODE:
         subprocess.run(ffmpeg_cmd, check=True)
+        
     else:
-
         if get_use_large_bar():
             capture_ffmpeg_real_time(ffmpeg_cmd, "[cyan]Join audio")
             print()

StreamingCommunity/TelegramHelp/config.json

@@ -25,9 +25,8 @@
         "pass": "adminadmin"
     },
     "M3U8_DOWNLOAD": {
-        "tqdm_delay": 0.01,
-        "default_video_workser": 12,
-        "default_audio_workser": 12,
+        "default_video_workers": 12,
+        "default_audio_workers": 12,
         "segment_timeout": 8,
         "download_audio": true,
         "merge_audio": true,
@@ -51,8 +50,7 @@
         "default_preset": "ultrafast"
     },
     "M3U8_PARSER": {
-        "force_resolution": "Best",
-        "get_only_link": false
+        "force_resolution": "Best"
     },
     "REQUESTS": {
         "verify": false,

StreamingCommunity/Upload/version.py

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

StreamingCommunity/Util/os.py

@@ -14,6 +14,7 @@ import contextlib
 import importlib.metadata
 import socket
 
+
 # External library
 from unidecode import unidecode
 from rich.console import Console
@@ -512,3 +513,23 @@ def get_ffmpeg_path():
 def get_ffprobe_path():
     """Returns the path of FFprobe."""
     return os_summary.ffprobe_path
+
+def get_wvd_path():
+    """
+    Searches the system's binary folder and returns the path of the first file ending with 'wvd'.
+    Returns None if not found.
+    """
+    system = platform.system().lower()
+    home = os.path.expanduser('~')
+    if system == 'windows':
+        binary_dir = os.path.join(os.path.splitdrive(home)[0] + os.path.sep, 'binary')
+    elif system == 'darwin':
+        binary_dir = os.path.join(home, 'Applications', 'binary')
+    else:
+        binary_dir = os.path.join(home, '.local', 'bin', 'binary')
+    if not os.path.exists(binary_dir):
+        return None
+    for file in os.listdir(binary_dir):
+        if file.lower().endswith('wvd'):
+            return os.path.join(binary_dir, file)
+    return None

StreamingCommunity/run.py

@@ -229,7 +229,7 @@ def main(script_id = 0):
 
     if not internet_manager.check_dns_resolve(hostname_list):
         print()
-        console.print("[red]❌ ERROR: DNS configuration is required!")
+        console.print("[red] ERROR: DNS configuration is required!")
         console.print("[red]The program cannot function correctly without proper DNS settings.")
         console.print("[yellow]Please configure one of these DNS servers:")
         console.print("[blue]• Cloudflare (1.1.1.1) 'https://developers.cloudflare.com/1.1.1.1/setup/windows/'")

{streamingcommunity-3.2.0.dist-info → streamingcommunity-3.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: StreamingCommunity
-Version: 3.2.0
+Version: 3.2.5
 Home-page: https://github.com/Lovi-0/StreamingCommunity
 Author: Lovi-0
 Project-URL: Bug Reports, https://github.com/Lovi-0/StreamingCommunity/issues
@@ -25,7 +25,7 @@ Requires-Dist: pycryptodomex
 Requires-Dist: ua-generator
 Requires-Dist: qbittorrent-api
 Requires-Dist: pyTelegramBotAPI
-Requires-Dist: beautifulsoup4
+Requires-Dist: pywidevine
 Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
@@ -839,3 +839,5 @@ API non ufficiale per accedere ai contenuti del sito italiano StreamingCommunity
 # Disclaimer
 
 This software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the software or the use or other dealings in the software.
+
+> **Note:** DASH downloads require a valid L3 CDM (Content Decryption Module) to proceed. This project does not provide, include, or facilitate obtaining any CDM. Users are responsible for ensuring compliance with all applicable laws and requirements regarding DRM and decryption modules.