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

StreamingCommunity/Lib/Downloader/DASH/cdm_helpher.py

@@ -0,0 +1,131 @@
+# 25.07.25
+
+import base64
+import logging
+import os
+
+
+# External libraries
+import httpx
+from rich.console import Console
+from pywidevine.cdm import Cdm
+from pywidevine.device import Device
+from pywidevine.pssh import PSSH
+
+
+# Variable
+console = Console()
+
+
+def get_widevine_keys(pssh, license_url, cdm_device_path, headers=None, payload=None):
+    """
+    Extract Widevine CONTENT keys (KID/KEY) from a license using pywidevine.
+
+    Args:
+        pssh (str): PSSH base64.
+        license_url (str): Widevine license URL.
+        cdm_device_path (str): Path to CDM file (device.wvd).
+        headers (dict): Optional HTTP headers.
+
+    Returns:
+        list: List of dicts {'kid': ..., 'key': ...} (only CONTENT keys) or None if error.
+    """
+
+    # Check if CDM file exists
+    if not os.path.isfile(cdm_device_path):
+        console.print(f"[bold red] CDM file not found: {cdm_device_path}[/bold red]")
+        return None
+
+    # Check if PSSH is a valid base64 string
+    try:
+        base64.b64decode(pssh)
+    except Exception:
+        console.print(f"[bold red] Invalid PSSH base64 string.[/bold red]")
+        return None
+
+    try:
+        device = Device.load(cdm_device_path)
+        cdm = Cdm.from_device(device)
+        session_id = cdm.open()
+
+        # Display security level in a more readable format
+        security_levels = {1: "L1 (Hardware)", 2: "L2 (Software)", 3: "L3 (Software)"}
+        security_level_str = security_levels.get(device.security_level, 'Unknown')
+        logging.info(f"Security Level: {security_level_str}")
+
+        # Only allow L3, otherwise warn and exit
+        if device.security_level != 3:
+            console.print(f"[bold yellow]⚠️ Only L3 (Software) security level is supported. Current: {security_level_str}[/bold yellow]")
+            return None
+
+        try:
+            challenge = cdm.get_license_challenge(session_id, PSSH(pssh))
+            req_headers = headers or {}
+            req_headers['Content-Type'] = 'application/octet-stream'
+
+            # Send license request
+            response = httpx.post(license_url, data=challenge, headers=req_headers, content=payload)
+
+            if response.status_code != 200:
+                console.print(f"[bold red]License error:[/bold red] {response.status_code}")
+                return None
+
+            # Handle (JSON) or classic (binary) license response
+            license_data = response.content
+            content_type = response.headers.get("Content-Type", "")
+            logging.info(f"License data: {license_data}, Content-Type: {content_type}")
+
+            # Check if license_data is empty
+            if not license_data:
+                console.print(f"[bold red]License response is empty.[/bold red]")
+                return None
+
+            if "application/json" in content_type:
+                try:
+                    
+                    # Try to decode as JSON only if plausible
+                    text = response.text
+                    data = None
+                    try:
+                        data = response.json()
+                    except Exception as e:
+                        data = None
+
+                    if data and "license" in data:
+                        license_data = base64.b64decode(data["license"])
+                        
+                    elif data is not None:
+                        console.print("[bold red]'license' field not found in JSON response.[/bold red]")
+                        return None
+                    
+                except Exception as e:
+                    console.print(f"[bold red]Error parsing JSON license:[/bold red] {e}")
+
+            cdm.parse_license(session_id, license_data)
+
+            # Extract only CONTENT keys from the license
+            content_keys = []
+            for key in cdm.get_keys(session_id):
+                if key.type == "CONTENT":
+                    kid = key.kid.hex() if isinstance(key.kid, bytes) else str(key.kid)
+                    key_val = key.key.hex() if isinstance(key.key, bytes) else str(key.key)
+
+                    content_keys.append({
+                        'kid': kid.replace('-', '').strip(),
+                        'key': key_val.replace('-', '').strip()
+                    })
+                    logging.info(f"Use kid: {kid}, key: {key_val}")
+
+            # Check if content_keys list is empty
+            if not content_keys:
+                console.print(f"[bold yellow]⚠️ No CONTENT keys found in license.[/bold yellow]")
+                return None
+
+            return content_keys
+        
+        finally:
+            cdm.close(session_id)
+
+    except Exception as e:
+        console.print(f"[bold red]CDM error:[/bold red] {e}")
+        return None

StreamingCommunity/Lib/Downloader/DASH/decrypt.py

@@ -0,0 +1,79 @@
+# 25.07.25
+
+import os
+import subprocess
+import logging
+
+
+# External libraries
+from rich.console import Console
+
+
+# Variable
+console = Console()
+
+
+def decrypt_with_mp4decrypt(encrypted_path, kid, key, output_path=None, cleanup=True):
+    """
+    Decrypt an mp4/m4s file using mp4decrypt.
+
+    Args:
+        encrypted_path (str): Path to encrypted file.
+        kid (str): Hexadecimal KID.
+        key (str): Hexadecimal key.
+        output_path (str): Output decrypted file path (optional).
+        cleanup (bool): If True, remove temporary files after decryption.
+
+    Returns:
+        str: Path to decrypted file, or None if error.
+    """
+
+    # Check if input file exists
+    if not os.path.isfile(encrypted_path):
+        console.print(f"[bold red] Encrypted file not found: {encrypted_path}[/bold red]")
+        return None
+
+    # Check if kid and key are valid hex
+    try:
+        bytes.fromhex(kid)
+        bytes.fromhex(key)
+    except Exception:
+        console.print(f"[bold red] Invalid KID or KEY (not hex).[/bold red]")
+        return None
+
+    if not output_path:
+        output_path = os.path.splitext(encrypted_path)[0] + "_decrypted.mp4"
+
+    key_format = f"{kid.lower()}:{key.lower()}"
+    cmd = ["mp4decrypt", "--key", key_format, encrypted_path, output_path]
+    logging.info(f"Running command: {' '.join(cmd)}")
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+    except Exception as e:
+        console.print(f"[bold red] mp4decrypt execution failed: {e}[/bold red]")
+        return None
+
+    if result.returncode == 0 and os.path.exists(output_path):
+
+        # Cleanup temporary files if requested
+        if cleanup:
+            if os.path.exists(encrypted_path):
+                os.remove(encrypted_path)
+
+            temp_dec = os.path.splitext(encrypted_path)[0] + "_decrypted.mp4"
+
+            # Do not delete the final output!
+            if temp_dec != output_path and os.path.exists(temp_dec):
+                os.remove(temp_dec)
+
+        # Check if output file is not empty
+        if os.path.getsize(output_path) == 0:
+            console.print(f"[bold red] Decrypted file is empty: {output_path}[/bold red]")
+            return None
+
+        return output_path
+
+    else:
+        console.print(f"[bold red] mp4decrypt failed:[/bold red] {result.stderr}")
+        return None

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -0,0 +1,220 @@
+# 25.07.25
+
+import os
+import shutil
+from rich.console import Console
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Lib.FFmpeg.command import join_audios, join_video
+
+
+# Logic class
+from .parser import MPDParser
+from .segments import MPD_Segments
+from .decrypt import decrypt_with_mp4decrypt
+from .cdm_helpher import get_widevine_keys
+
+
+# Config
+ENABLE_AUDIO = config_manager.get_bool('M3U8_DOWNLOAD', 'download_audio')
+DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_audio')
+CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
+FILTER_CUSTOM_REOLUTION = str(config_manager.get('M3U8_PARSER', 'force_resolution')).strip().lower()
+
+
+# Variable
+console = Console()
+
+
+class DASH_Download:
+    def __init__(self, cdm_device, license_url, mpd_url, output_path):
+        self.cdm_device = cdm_device
+        self.license_url = license_url
+        self.mpd_url = mpd_url
+        self.original_output_path = os.path.abspath(str(output_path))
+        self.out_path = os.path.splitext(self.original_output_path)[0]
+        self.parser = None
+        self._setup_temp_dirs()
+
+        self.error = None
+        self.stopped = False
+        self.output_file = None
+
+    def _setup_temp_dirs(self):
+        """
+        Create temporary folder structure under out_path\tmp
+        """
+        self.tmp_dir = os.path.join(self.out_path, "tmp")
+        self.encrypted_dir = os.path.join(self.tmp_dir, "encrypted")
+        self.decrypted_dir = os.path.join(self.tmp_dir, "decrypted")
+        self.optimize_dir = os.path.join(self.tmp_dir, "optimize")
+        
+        os.makedirs(self.encrypted_dir, exist_ok=True)
+        os.makedirs(self.decrypted_dir, exist_ok=True)
+        os.makedirs(self.optimize_dir, exist_ok=True)
+
+    def parse_manifest(self, custom_headers):
+        self.parser = MPDParser(self.mpd_url)
+        self.parser.parse(custom_headers)
+
+        # Video info
+        selected_video, list_available_resolution, filter_custom_resolution, downloadable_video = self.parser.select_video(FILTER_CUSTOM_REOLUTION)
+        console.print(
+            f"[cyan bold]Video    [/cyan bold] [green]Available:[/green] [purple]{', '.join(list_available_resolution)}[/purple] | "
+            f"[red]Set:[/red] [purple]{filter_custom_resolution}[/purple] | "
+            f"[yellow]Downloadable:[/yellow] [purple]{downloadable_video}[/purple]"
+        )
+        self.selected_video = selected_video
+
+        # Audio info (only if enabled)
+        if ENABLE_AUDIO:
+            selected_audio, list_available_audio_langs, filter_custom_audio, downloadable_audio = self.parser.select_audio(DOWNLOAD_SPECIFIC_AUDIO)
+            console.print(
+                f"[cyan bold]Audio    [/cyan bold] [green]Available:[/green] [purple]{', '.join(list_available_audio_langs)}[/purple] | "
+                f"[red]Set:[/red] [purple]{filter_custom_audio}[/purple] | "
+                f"[yellow]Downloadable:[/yellow] [purple]{downloadable_audio}[/purple]"
+            )
+            self.selected_audio = selected_audio
+        else:
+            self.selected_audio = None
+
+    def get_representation_by_type(self, typ):
+        if typ == "video":
+            return getattr(self, "selected_video", None)
+        elif typ == "audio":
+            return getattr(self, "selected_audio", None)
+        return None
+
+    def download_and_decrypt(self, custom_headers=None, custom_payload=None):
+        """
+        Download and decrypt video/audio streams. Sets self.error, self.stopped, self.output_file.
+        Returns True if successful, False otherwise.
+        """
+        self.error = None
+        self.stopped = False
+
+        for typ in ["video", "audio"]:
+            rep = self.get_representation_by_type(typ)
+            if rep:
+                encrypted_path = os.path.join(self.encrypted_dir, f"{rep['id']}_encrypted.m4s")
+
+                downloader = MPD_Segments(
+                    tmp_folder=self.encrypted_dir,
+                    representation=rep,
+                    pssh=self.parser.pssh
+                )
+
+                try:
+                    result = downloader.download_streams()
+
+                    # Check for interruption or failure
+                    if result.get("stopped"):
+                        self.stopped = True
+                        self.error = "Download interrupted"
+                        return False
+                    
+                    if result.get("nFailed", 0) > 0:
+                        self.error = f"Failed segments: {result['nFailed']}"
+                        return False
+                    
+                except Exception as ex:
+                    self.error = str(ex)
+                    return False
+
+                if not self.parser.pssh:
+                    print("No PSSH found: segments are not encrypted, skipping decryption.")
+                    self.download_segments(clear=True)
+                    return True
+
+                keys = get_widevine_keys(
+                    pssh=self.parser.pssh,
+                    license_url=self.license_url,
+                    cdm_device_path=self.cdm_device,
+                    headers=custom_headers,
+                    payload=custom_payload
+                )
+                
+                if not keys:
+                    self.error = f"No key found, cannot decrypt {typ}"
+                    print(self.error)
+                    return False
+
+                key = keys[0]
+                KID = key['kid']
+                KEY = key['key']
+
+                decrypted_path = os.path.join(self.decrypted_dir, f"{typ}.mp4")
+                result_path = decrypt_with_mp4decrypt(
+                    encrypted_path, KID, KEY, output_path=decrypted_path
+                )
+
+                if not result_path:
+                    self.error = f"Decryption of {typ} failed"
+                    print(self.error)
+                    return False
+
+            else:
+                self.error = f"No {typ} found"
+                print(self.error)
+                return False
+
+        return True
+
+    def download_segments(self, clear=False):
+        # Download segments and concatenate them
+        # clear=True: no decryption needed
+        pass
+
+    def finalize_output(self):
+        video_file = os.path.join(self.decrypted_dir, "video.mp4")
+        audio_file = os.path.join(self.decrypted_dir, "audio.mp4")
+
+        # fallback: if one of the two is missing, look in encrypted
+        if not os.path.exists(video_file):
+            for f in os.listdir(self.encrypted_dir):
+                if f.endswith("_encrypted.m4s") and ("video" in f or f.startswith("1_")):
+                    video_file = os.path.join(self.encrypted_dir, f)
+                    break
+        if not os.path.exists(audio_file):
+            for f in os.listdir(self.encrypted_dir):
+                if f.endswith("_encrypted.m4s") and ("audio" in f or f.startswith("0_")):
+                    audio_file = os.path.join(self.encrypted_dir, f)
+                    break
+
+        # Usa il nome file originale per il file finale
+        output_file = self.original_output_path
+
+        if os.path.exists(video_file) and os.path.exists(audio_file):
+            audio_tracks = [{"path": audio_file}]
+            join_audios(video_file, audio_tracks, output_file)
+        elif os.path.exists(video_file):
+            join_video(video_file, output_file, codec=None)
+        else:
+            print("Video file missing, cannot export")
+
+        # Clean up: delete all tmp
+        if os.path.exists(self.tmp_dir):
+            shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+        # Rimuovi la cartella principale se è vuota
+        try:
+            if os.path.exists(self.out_path) and not os.listdir(self.out_path):
+                os.rmdir(self.out_path)
+        except Exception as e:
+            print(f"[WARN] Impossibile eliminare la cartella {self.out_path}: {e}")
+        
+
+        return self.output_file
+
+    def get_status(self):
+        """
+        Returns a dict with 'path', 'error', and 'stopped' for external use.
+        """
+        return {
+            "path": self.output_file,
+            "error": self.error,
+            "stopped": self.stopped
+        }

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, follow_redirects=True)
+        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