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

StreamingCommunity/Api/Site/streamingwatch/series.py

@@ -36,7 +36,7 @@ msg = Prompt()
 console = Console()
 
 
-def download_video(index_season_selected: int, index_episode_selected: int, scrape_serie: GetSerieInfo, proxy=None) -> Tuple[str,bool]:
+def download_video(index_season_selected: int, index_episode_selected: int, scrape_serie: GetSerieInfo) -> Tuple[str,bool]:
     """
     Downloads a specific episode from a specified season.
 
@@ -60,7 +60,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
     mp4_path = os.path.join(site_constant.SERIES_FOLDER, scrape_serie.series_name, f"S{index_season_selected}")
 
     # Retrieve scws and if available master playlist
-    video_source = VideoSource(proxy)
+    video_source = VideoSource()
     master_playlist = video_source.get_m3u8_url(obj_episode.url)
 
     # Download the episode
@@ -76,7 +76,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
     return r_proc['path'], r_proc['stopped']
     
 
-def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, download_all: bool = False, episode_selection: str = None, proxy = None) -> None:
+def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, download_all: bool = False, episode_selection: str = None) -> None:
     """
     Handle downloading episodes for a specific season.
 
@@ -92,7 +92,7 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, dow
 
     if download_all:
         for i_episode in range(1, episodes_count + 1):
-            path, stopped = download_video(index_season_selected, i_episode, scrape_serie, proxy)
+            path, stopped = download_video(index_season_selected, i_episode, scrape_serie)
 
             if stopped:
                 break
@@ -113,12 +113,12 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, dow
 
         # Download selected episodes if not stopped
         for i_episode in list_episode_select:
-            path, stopped = download_video(index_season_selected, i_episode, scrape_serie, proxy)
+            path, stopped = download_video(index_season_selected, i_episode, scrape_serie)
 
             if stopped:
                 break
 
-def download_series(select_season: MediaItem, season_selection: str = None, episode_selection: str = None, proxy = None) -> None:
+def download_series(select_season: MediaItem, season_selection: str = None, episode_selection: str = None) -> None:
     """
     Handle downloading a complete series.
 
@@ -127,7 +127,7 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
         - season_selection (str, optional): Pre-defined season selection that bypasses manual input
         - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
-    scrape_serie = GetSerieInfo(select_season.url, proxy)
+    scrape_serie = GetSerieInfo(select_season.url)
 
     # Get total number of seasons 
     seasons_count = scrape_serie.getNumberSeason()
@@ -154,7 +154,7 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
     for i_season in list_season_select:
         if len(list_season_select) > 1 or index_season_selected == "*":
             # Download all episodes if multiple seasons are selected or if '*' is used
-            download_episode(i_season, scrape_serie, download_all=True, proxy=proxy)
+            download_episode(i_season, scrape_serie, download_all=True)
         else:
             # Otherwise, let the user select specific episodes for the single season
-            download_episode(i_season, scrape_serie, download_all=False, episode_selection=episode_selection, proxy=proxy)
+            download_episode(i_season, scrape_serie, download_all=False, episode_selection=episode_selection)

StreamingCommunity/Api/Site/streamingwatch/site.py

@@ -27,13 +27,12 @@ table_show_manager = TVShowManager()
 max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
-def extract_nonce(proxy) -> str:
+def extract_nonce() -> str:
     """Extract nonce value from the page script"""
     response = httpx.get(
         site_constant.FULL_URL, 
         headers={'user-agent': get_userAgent()}, 
-        timeout=max_timeout,
-        proxy=proxy
+        timeout=max_timeout
     )
     
     soup = BeautifulSoup(response.content, 'html.parser')
@@ -45,7 +44,7 @@ def extract_nonce(proxy) -> str:
     return ""
 
 
-def title_search(query: str, proxy: str) -> int:
+def title_search(query: str) -> int:
     """
     Search for titles based on a search query.
       
@@ -62,7 +61,7 @@ def title_search(query: str, proxy: str) -> int:
     console.print(f"[cyan]Search url: [yellow]{search_url}")
 
     try:
-        _wpnonce = extract_nonce(proxy)
+        _wpnonce = extract_nonce()
         
         if not _wpnonce:
             console.print("[red]Error: Failed to extract nonce")
@@ -81,8 +80,7 @@ def title_search(query: str, proxy: str) -> int:
                 'user-agent': get_userAgent()
             },
             data=data,
-            timeout=max_timeout,
-            proxy=proxy
+            timeout=max_timeout
         )
         response.raise_for_status()
         soup = BeautifulSoup(response.text, 'html.parser')

StreamingCommunity/Api/Site/streamingwatch/util/ScrapeSerie.py

@@ -19,13 +19,13 @@ max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
 class GetSerieInfo:
-    def __init__(self, url, proxy: str = None):
+    def __init__(self, url):
         self.headers = {'user-agent': get_userAgent()}
         self.url = url
         self.seasons_manager = SeasonManager()
         self.series_name = None
         
-        self.client = httpx.Client(headers=self.headers, proxy=proxy, timeout=max_timeout)
+        self.client = httpx.Client(headers=self.headers, timeout=max_timeout)
 
     def collect_info_season(self) -> None:
         """

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,218 @@
+# 25.07.25
+
+import os
+import shutil
+
+
+# External libraries
+from rich.console import Console
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_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
+DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_audio')
+FILTER_CUSTOM_REOLUTION = str(config_manager.get('M3U8_PARSER', 'force_resolution')).strip().lower()
+CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
+
+
+# Variable
+console = Console()
+
+
+class DASH_Downloader:
+    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 
+        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
+
+    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
+        }