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

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

@@ -5,21 +5,15 @@ import logging
 
 
 # External libraries
-import httpx
 from bs4 import BeautifulSoup
 
 
 # Internal utilities
-from StreamingCommunity.Util.headers import get_userAgent
-from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
 
 
-# Variable
-max_timeout = config_manager.get_int("REQUESTS", "timeout")
-ssl_verify = config_manager.get_bool("REQUESTS", "verify")
-
-
 class GetSerieInfo:
     def __init__(self, url, media_id: int = None, series_name: str = None):
         """
@@ -31,7 +25,7 @@ class GetSerieInfo:
             - series_name (str, optional): Name of the TV series
         """
         self.is_series = False
-        self.headers = {'user-agent': get_userAgent()}
+        self.headers = get_headers()
         self.url = url
         self.media_id = media_id
         self.seasons_manager = SeasonManager()
@@ -48,12 +42,7 @@ class GetSerieInfo:
             Exception: If there's an error fetching series information
         """
         try:
-            response = httpx.get(
-                url=f"{self.url}/titles/{self.media_id}-{self.series_name}",
-                headers=self.headers,
-                timeout=max_timeout,
-                verify=ssl_verify
-            )
+            response = create_client(headers=self.headers).get(f"{self.url}/titles/{self.media_id}-{self.series_name}")
             response.raise_for_status()
 
             # Extract series info from JSON response
@@ -98,17 +87,13 @@ class GetSerieInfo:
             if not season:
                 logging.error(f"Season {number_season} not found")
                 return
-            
-            response = httpx.get(
-                url=f'{self.url}/titles/{self.media_id}-{self.series_name}/season-{number_season}', 
-                headers={
-                    'User-Agent': self.headers['user-agent'],
-                    'x-inertia': 'true',
-                    'x-inertia-version': self.version,
-                },
-                timeout=max_timeout,
-                verify=ssl_verify
-            )
+
+            custom_headers = self.headers.copy()
+            custom_headers.update({
+                'x-inertia': 'true',
+                'x-inertia-version': self.version,
+            })
+            response = create_client(headers=custom_headers).get(f"{self.url}/titles/{self.media_id}-{self.series_name}/season-{number_season}")
 
             # Extract episodes from JSON response
             json_response = response.json().get('props', {}).get('loadedSeason', {}).get('episodes', [])

StreamingCommunity/Api/Site/streamingwatch/__init__.py

@@ -3,6 +3,7 @@
 import sys
 import subprocess
 
+
 # External library
 from rich.console import Console
 from rich.prompt import Prompt

StreamingCommunity/Api/Site/streamingwatch/film.py

@@ -9,6 +9,7 @@ from rich.console import Console
 
 # Internal utilities
 from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Util.message import start_message
 
 
@@ -24,6 +25,7 @@ from StreamingCommunity.Api.Player.hdplayer import VideoSource
 
 # Variable
 console = Console()
+extension_output = config_manager.get("M3U8_CONVERSION", "extension")
 
 
 def download_film(select_title: MediaItem) -> str:
@@ -45,8 +47,8 @@ def download_film(select_title: MediaItem) -> str:
     master_playlist = video_source.get_m3u8_url(select_title.url)
 
     # Define the filename and path for the downloaded film
-    title_name = os_manager.get_sanitize_file(select_title.name) + ".mp4"
-    mp4_path = os.path.join(site_constant.MOVIE_FOLDER, title_name.replace(".mp4", ""))
+    title_name = os_manager.get_sanitize_file(select_title.name, select_title.date) + extension_output
+    mp4_path = os.path.join(site_constant.MOVIE_FOLDER, title_name.replace(extension_output, ""))
 
     # Download the film using the m3u8 playlist, and output filename
     hls_process = HLS_Downloader(

StreamingCommunity/Api/Site/streamingwatch/series.py

@@ -53,7 +53,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
 
     # Get episode information
     obj_episode = scrape_serie.selectEpisode(index_season_selected, index_episode_selected-1)
-    console.print(f"\n[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{scrape_serie.series_name}[/cyan] \\ [bold magenta]{obj_episode.name}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
+    console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{scrape_serie.series_name}[/cyan] \\ [bold magenta]{obj_episode.name}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
 
     # Define filename and path for the downloaded video
     mp4_name = f"{map_episode_title(scrape_serie.series_name, index_season_selected, index_episode_selected, obj_episode.name)}.mp4"

StreamingCommunity/Api/Site/streamingwatch/site.py

@@ -4,13 +4,12 @@ import re
 
 
 # External libraries
-import httpx
 from bs4 import BeautifulSoup
 from rich.console import Console
 
 
 # Internal utilities
-from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Util.headers import get_userAgent
 from StreamingCommunity.Util.table import TVShowManager
 
@@ -24,18 +23,13 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
 console = Console()
 media_search_manager = MediaManager()
 table_show_manager = TVShowManager()
-max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
 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
-    )
-    
+    response = create_client(headers={'user-agent': get_userAgent()}).get(site_constant.FULL_URL)
     soup = BeautifulSoup(response.content, 'html.parser')
+
     script = soup.find('script', id='live-search-js-extra')
     if script:
         match = re.search(r'"admin_ajax_nonce":"([^"]+)"', script.text)
@@ -73,15 +67,7 @@ def title_search(query: str) -> int:
             '_wpnonce': _wpnonce
         }
 
-        response = httpx.post(
-            search_url,
-            headers={
-                'origin': site_constant.FULL_URL,
-                'user-agent': get_userAgent()
-            },
-            data=data,
-            timeout=max_timeout
-        )
+        response = create_client(headers={'origin': site_constant.FULL_URL, 'user-agent': get_userAgent()}).post(search_url, data=data)
         response.raise_for_status()
         soup = BeautifulSoup(response.text, 'html.parser')
 

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

@@ -11,12 +11,9 @@ from bs4 import BeautifulSoup
 # Internal utilities
 from StreamingCommunity.Util.headers import get_userAgent
 from StreamingCommunity.Util.http_client import create_client
-from StreamingCommunity.Util.config_json import config_manager
 from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager, Episode
 
 
-# Variable
-max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
 class GetSerieInfo:

StreamingCommunity/Api/Template/config_loader.py

@@ -56,13 +56,6 @@ class SiteConstant:
             base_path = os.path.join(base_path, self.SITE_NAME)
         return os.path.join(base_path, config_manager.get('OUT_FOLDER', 'anime_folder_name'))
     
-    @property
-    def COOKIE(self):
-        try:
-            return config_manager.get_dict('SITE_EXTRA', self.SITE_NAME)
-        except KeyError:
-            return None
-    
     @property
     def TELEGRAM_BOT(self):
         return config_manager.get_bool('DEFAULT', 'telegram_bot')

StreamingCommunity/Lib/Downloader/DASH/cdm_helpher.py

@@ -5,7 +5,7 @@ import logging
 
 
 # External libraries
-import httpx
+from curl_cffi import requests
 from rich.console import Console
 from pywidevine.cdm import Cdm
 from pywidevine.device import Device
@@ -39,8 +39,13 @@ def get_widevine_keys(pssh, license_url, cdm_device_path, headers=None, payload=
             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)
+            # Send license request using curl_cffi
+            try:
+                # response = httpx.post(license_url, data=challenge, headers=req_headers, content=payload)
+                response = requests.post(license_url, data=challenge, headers=req_headers, json=payload, impersonate="chrome124")
+            except Exception as e:
+                console.print(f"[bold red]Request error:[/bold red] {e}")
+                return None
 
             if response.status_code != 200:
                 console.print(f"[bold red]License error:[/bold red] {response.status_code}, {response.text}")

StreamingCommunity/Lib/Downloader/DASH/decrypt.py

@@ -3,24 +3,30 @@
 import os
 import subprocess
 import logging
+import threading
+import time
 
 
 # External libraries
 from rich.console import Console
+from tqdm import tqdm
 
 
 # Internal utilities
 from StreamingCommunity.Util.os import get_mp4decrypt_path
+from StreamingCommunity.Util.color import Colors
 
 # Variable
 console = Console()
 
 
-def decrypt_with_mp4decrypt(encrypted_path, kid, key, output_path=None, cleanup=True):
+# NOTE!: SAREBBE MEGLIO FARLO PER OGNI FILE DURANTE IL DOWNLOAD ... MA PER ORA LO LASCIO COSI
+def decrypt_with_mp4decrypt(type, encrypted_path, kid, key, output_path=None, cleanup=True):
     """
     Decrypt an mp4/m4s file using mp4decrypt.
 
     Args:
+        type (str): Type of file ('video' or 'audio').
         encrypted_path (str): Path to encrypted file.
         kid (str): Hexadecimal KID.
         key (str): Hexadecimal key.
@@ -47,15 +53,63 @@ def decrypt_with_mp4decrypt(encrypted_path, kid, key, output_path=None, cleanup=
     if not output_path:
         output_path = os.path.splitext(encrypted_path)[0] + "_decrypted.mp4"
 
+    # Get file size for progress tracking
+    file_size = os.path.getsize(encrypted_path)
+    
     key_format = f"{kid.lower()}:{key.lower()}"
     cmd = [get_mp4decrypt_path(), "--key", key_format, encrypted_path, output_path]
     logging.info(f"Running command: {' '.join(cmd)}")
 
+    # Create progress bar with custom format
+    bar_format = (
+        f"{Colors.YELLOW}DECRYPT{Colors.CYAN} {type}{Colors.WHITE}: "
+        f"{Colors.MAGENTA}{{bar:40}} "
+        f"{Colors.LIGHT_GREEN}{{n_fmt}}{Colors.WHITE}/{Colors.CYAN}{{total_fmt}} "
+        f"{Colors.DARK_GRAY}[{Colors.YELLOW}{{elapsed}}{Colors.WHITE} < {Colors.CYAN}{{remaining}}{Colors.DARK_GRAY}] "
+        f"{Colors.WHITE}{{postfix}}"
+    )
+    
+    progress_bar = tqdm(
+        total=100,
+        bar_format=bar_format,
+        unit="",
+        ncols=150
+    )
+    
+    def monitor_output_file():
+        """Monitor output file growth and update progress bar."""
+        last_size = 0
+        while True:
+            if os.path.exists(output_path):
+                current_size = os.path.getsize(output_path)
+                if current_size > 0:
+                    progress_percent = min(int((current_size / file_size) * 100), 100)
+                    progress_bar.n = progress_percent
+                    progress_bar.refresh()
+                    
+                    if current_size == last_size and current_size > 0:
+                        # File stopped growing, likely finished
+                        break
+                    
+                    last_size = current_size
+            
+            time.sleep(0.1)
+    
+    # Start monitoring thread
+    monitor_thread = threading.Thread(target=monitor_output_file, daemon=True)
+    monitor_thread.start()
+
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
     except Exception as e:
+        progress_bar.close()
         console.print(f"[bold red] mp4decrypt execution failed: {e}[/bold red]")
         return None
+    
+    # Ensure progress bar reaches 100%
+    progress_bar.n = 100
+    progress_bar.refresh()
+    progress_bar.close()
 
     if result.returncode == 0 and os.path.exists(output_path):
 

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -1,7 +1,6 @@
 # 25.07.25
 
 import os
-import time
 import shutil
 
 
@@ -13,7 +12,7 @@ from rich.table import Table
 
 # Internal utilities
 from StreamingCommunity.Util.config_json import config_manager
-from StreamingCommunity.Util.os import internet_manager
+from StreamingCommunity.Util.os import os_manager, internet_manager, get_wvd_path
 from StreamingCommunity.Util.http_client import create_client
 from StreamingCommunity.Util.headers import get_userAgent
 
@@ -32,11 +31,11 @@ from ...FFmpeg import print_duration_table, join_audios, join_video, join_subtit
 # Config
 DOWNLOAD_SPECIFIC_AUDIO = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_audio')
 DOWNLOAD_SPECIFIC_SUBTITLE = config_manager.get_list('M3U8_DOWNLOAD', 'specific_list_subtitles')
-ENABLE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'download_subtitle')
 MERGE_SUBTITLE = config_manager.get_bool('M3U8_DOWNLOAD', 'merge_subs')
 FILTER_CUSTOM_REOLUTION = str(config_manager.get('M3U8_CONVERSION', 'force_resolution')).strip().lower()
 CLEANUP_TMP = config_manager.get_bool('M3U8_DOWNLOAD', 'cleanup_tmp_folder')
 RETRY_LIMIT = config_manager.get_int('REQUESTS', 'max_retry')
+EXTENSION_OUTPUT = config_manager.get("M3U8_CONVERSION", "extension")
 
 
 # Variable
@@ -44,25 +43,31 @@ console = Console()
 
 
 class DASH_Downloader:
-    def __init__(self, cdm_device, license_url, mpd_url, mpd_sub_list: list = None, output_path: str = None):
+    def __init__(self, license_url, mpd_url, mpd_sub_list: list = None, output_path: str = None):
         """
         Initialize the DASH Downloader with necessary parameters.
 
         Parameters:
-            - cdm_device (str): Path to the CDM device for decryption.
             - license_url (str): URL to obtain the license for decryption.
             - mpd_url (str): URL of the MPD manifest file.
             - mpd_sub_list (list): List of subtitle dicts with keys: 'language', 'url', 'format'.
             - output_path (str): Path to save the final output file.
         """
-        self.cdm_device = cdm_device
+        self.cdm_device = get_wvd_path()
         self.license_url = license_url
         self.mpd_url = mpd_url
         self.mpd_sub_list = mpd_sub_list or []
-        self.out_path = os.path.splitext(os.path.abspath(str(output_path)))[0]
+        self.out_path = os.path.splitext(os.path.abspath(os_manager.get_sanitize_path(output_path)))[0]
         self.original_output_path = output_path
         self.file_already_exists = os.path.exists(self.original_output_path)
         self.parser = None
+
+        # Added defaults to avoid AttributeError when no subtitles/audio/video are present
+        # Non la soluzione migliore ma evita crash in assenza di audio/video/subs
+        self.selected_subs = []
+        self.selected_video = None
+        self.selected_audio = None
+
         self._setup_temp_dirs()
 
         self.error = None
@@ -189,49 +194,28 @@ class DASH_Downloader:
         Download subtitle files based on configuration with retry mechanism.
         Returns True if successful or if no subtitles to download, False on critical error.
         """
-        if not ENABLE_SUBTITLE or not self.selected_subs:
-            return True
-        
-        headers = {'User-Agent': get_userAgent()}
-        client = create_client(headers=headers)
+        client = create_client(headers={'User-Agent': get_userAgent()})
         
         for sub in self.selected_subs:
-            language = sub.get('language', 'unknown')
-            url = sub.get('url')
-            fmt = sub.get('format', 'vtt')
-            
-            if not url:
-                console.print(f"[yellow]Warning: No URL for subtitle {language}[/yellow]")
-                continue
-            
-            # Retry mechanism for downloading subtitles
-            success = False
-            for attempt in range(RETRY_LIMIT):
-                try:
-                    # Download subtitle
-                    response = client.get(url)
-                    response.raise_for_status()
-                    
-                    # Save subtitle file
-                    sub_filename = f"{language}.{fmt}"
-                    sub_path = os.path.join(self.subs_dir, sub_filename)
-                    
-                    with open(sub_path, 'wb') as f:
-                        f.write(response.content)
-                    
-                    success = True
-                    break
+            try:
+                language = sub.get('language', 'unknown')
+                fmt = sub.get('format', 'vtt')
+
+                # Download subtitle
+                response = client.get(sub.get('url'))
+                response.raise_for_status()
+                
+                # Save subtitle file and make request
+                sub_filename = f"{language}.{fmt}"
+                sub_path = os.path.join(self.subs_dir, sub_filename)
+                
+                with open(sub_path, 'wb') as f:
+                    f.write(response.content)
                     
-                except Exception as e:
-                    if attempt < RETRY_LIMIT - 1:
-                        console.print(f"[yellow]Attempt {attempt + 1}/{RETRY_LIMIT} failed for subtitle {language}: {e}. Retrying...[/yellow]")
-                        time.sleep(1.5 ** attempt)
-                    else:
-                        console.print(f"[yellow]Warning: Failed to download subtitle {language} after {RETRY_LIMIT} attempts: {e}[/yellow]")
+            except Exception as e:
+                console.print(f"[red]Error downloading subtitle {language}: {e}[/red]")
+                return False
             
-            if not success:
-                continue
-        
         return True
 
     def download_and_decrypt(self, custom_headers=None, custom_payload=None):
@@ -249,7 +233,6 @@ class DASH_Downloader:
 
         # Fetch keys immediately after obtaining PSSH
         if not self.parser.pssh:
-            console.print("[red]No PSSH found: segments are not encrypted, skipping decryption.")
             self.download_segments(clear=True)
             return True
 
@@ -309,7 +292,7 @@ class DASH_Downloader:
                 # Decrypt video
                 decrypted_path = os.path.join(self.decrypted_dir, "video.mp4")
                 result_path = decrypt_with_mp4decrypt(
-                    encrypted_path, KID, KEY, output_path=decrypted_path
+                    "Video", encrypted_path, KID, KEY, output_path=decrypted_path
                 )
 
                 if not result_path:
@@ -358,7 +341,7 @@ class DASH_Downloader:
                 # Decrypt audio
                 decrypted_path = os.path.join(self.decrypted_dir, "audio.mp4")
                 result_path = decrypt_with_mp4decrypt(
-                    encrypted_path, KID, KEY, output_path=decrypted_path
+                    f"Audio {audio_language}", encrypted_path, KID, KEY, output_path=decrypted_path
                 )
 
                 if not result_path:
@@ -374,9 +357,110 @@ class DASH_Downloader:
         return True
 
     def download_segments(self, clear=False):
-        # Download segments and concatenate them
-        # clear=True: no decryption needed
-        pass
+        """
+        Download video/audio segments without decryption (for clear content).
+        
+        Parameters:
+            clear (bool): If True, content is not encrypted and doesn't need decryption
+        """
+        if not clear:
+            console.print("[yellow]Warning: download_segments called with clear=False[/yellow]")
+            return False
+        
+        video_segments_count = 0
+        
+        # Download subtitles
+        self.download_subtitles()
+        
+        # Download video
+        video_rep = self.get_representation_by_type("video")
+        if video_rep:
+            encrypted_path = os.path.join(self.encrypted_dir, f"{video_rep['id']}_encrypted.m4s")
+            
+            # If m4s file doesn't exist, start downloading
+            if not os.path.exists(encrypted_path):
+                video_downloader = MPD_Segments(
+                    tmp_folder=self.encrypted_dir,
+                    representation=video_rep,
+                    pssh=self.parser.pssh
+                )
+                
+                try:
+                    result = video_downloader.download_streams(description="Video")
+                    
+                    # Store the video segment count for limiting audio
+                    video_segments_count = video_downloader.get_segments_count()
+                    
+                    # 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)
+                    console.print(f"[red]Error downloading video: {ex}[/red]")
+                    return False
+            
+            # NO DECRYPTION: just copy/move to decrypted folder
+            decrypted_path = os.path.join(self.decrypted_dir, "video.mp4")
+            if os.path.exists(encrypted_path) and not os.path.exists(decrypted_path):
+                shutil.copy2(encrypted_path, decrypted_path)
+
+        else:
+            self.error = "No video found"
+            console.print(f"[red]{self.error}[/red]")
+            return False
+        
+        # Download audio with segment limiting
+        audio_rep = self.get_representation_by_type("audio")
+        if audio_rep:
+            encrypted_path = os.path.join(self.encrypted_dir, f"{audio_rep['id']}_encrypted.m4s")
+            
+            # If m4s file doesn't exist, start downloading
+            if not os.path.exists(encrypted_path):
+                audio_language = audio_rep.get('language', 'Unknown')
+                
+                audio_downloader = MPD_Segments(
+                    tmp_folder=self.encrypted_dir,
+                    representation=audio_rep,
+                    pssh=self.parser.pssh,
+                    limit_segments=video_segments_count if video_segments_count > 0 else None
+                )
+                
+                try:
+                    result = audio_downloader.download_streams(description=f"Audio {audio_language}")
+                    
+                    # 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)
+                    console.print(f"[red]Error downloading audio: {ex}[/red]")
+                    return False
+            
+            # NO DECRYPTION: just copy/move to decrypted folder
+            decrypted_path = os.path.join(self.decrypted_dir, "audio.mp4")
+            if os.path.exists(encrypted_path) and not os.path.exists(decrypted_path):
+                shutil.copy2(encrypted_path, decrypted_path)
+                
+        else:
+            self.error = "No audio found"
+            console.print(f"[red]{self.error}[/red]")
+            return False
+        
+        return True
 
     def finalize_output(self):
         """
@@ -408,8 +492,8 @@ class DASH_Downloader:
             console.print("[red]Video file missing, cannot export[/red]")
             return None
         
-        # Merge subtitles if enabled and available
-        if MERGE_SUBTITLE and ENABLE_SUBTITLE and self.selected_subs:
+        # Merge subtitles if available
+        if MERGE_SUBTITLE and self.selected_subs:
 
             # Check which subtitle files actually exist
             existing_sub_tracks = []
@@ -448,7 +532,7 @@ class DASH_Downloader:
         
         # Handle failed sync case
         if use_shortest:
-            new_filename = output_file.replace(".mp4", "_failed_sync.mp4")
+            new_filename = output_file.replace(EXTENSION_OUTPUT, f"_failed_sync{EXTENSION_OUTPUT}")
             if os.path.exists(output_file):
                 os.rename(output_file, new_filename)
                 output_file = new_filename