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

StreamingCommunity/Api/Site/mediasetinfinity/util/get_license.py

@@ -1,20 +1,15 @@
 # 16.03.25
 
-import json
-import time
+import re
+import uuid
 from urllib.parse import urlencode
 import xml.etree.ElementTree as ET
 
 
 # External library
 import httpx
+from bs4 import BeautifulSoup
 from rich.console import Console
-try:
-    from seleniumbase import Driver
-    SELENIUMBASE_AVAILABLE = True
-except ImportError:
-    SELENIUMBASE_AVAILABLE = False
-    Driver = None
 
 
 # Internal utilities
@@ -25,192 +20,91 @@ from StreamingCommunity.Util.headers import get_headers, get_userAgent
 # Variable
 console = Console()
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
-beToken = None
 network_data = []
+class_mediaset_api = None
 
 
-def save_network_data(data):
-    """Save network data and check for beToken"""
-    global network_data
-    
-    # Filter only for login API responses
-    if data.get('method') == 'Network.responseReceived':
-        params = data.get('params', {})
-        response = params.get('response', {})
-        url = response.get('url', '')
+class MediasetAPI:
+    def __init__(self):
+        self.client_id = str(uuid.uuid4())
+        self.headers = get_headers()
+        self.app_name = self.get_app_name()
+        self.beToken = self.generate_betoken()
+        self.sha256Hash = self.getHash2c()
         
-        if "persona/login/v2.0" in url and params.get('type') != 'Preflight':
-            network_data.append(data)
-            console.print(f"[green]Found login API request to: {url}")
-
-
-def generate_betoken(username: str, password: str, sleep_action: float = 1.0) -> str:
-    """Generate beToken using browser automation"""
-    
-    if not SELENIUMBASE_AVAILABLE:
-        console.print("[red]Error: seleniumbase is not installed. Cannot perform browser login.")
-        console.print("[yellow]Install seleniumbase with: pip install seleniumbase")
-        return None
-    
-    if not Driver:
-        console.print("[red]Error: seleniumbase Driver is not available.")
-        return None
-    
-    driver = Driver(uc=True, uc_cdp_events=True, incognito=True, headless=True)
-    
-    try:
-        console.print("[cyan]Launching browser...")
-        be_token_holder = {"token": None}
-        global network_data
-        network_data = []  # Reset network data
-
-        # Load home page
-        console.print("[cyan]Navigating to Mediaset Play...")
-        driver.uc_open_with_reconnect("https://www.mediasetplay.mediaset.it", sleep_action)
+    def get_app_name(self):
+        html = self.fetch_html()
+        soup = BeautifulSoup(html, "html.parser")
+        meta_tag = soup.find('meta', attrs={'name': 'app-name'})
         
-        # Add CDP listeners after opening the page
-        driver.add_cdp_listener(
-            "Network.responseReceived",
-            lambda data: save_network_data(data)
-        )
-        driver.sleep(sleep_action)
-
-        # Accept privacy policy if present
-        try:
-            driver.click("#rti-privacy-accept-btn-screen1-id", timeout=3)
-        except Exception:
-            pass
-
-        # Click Login using the specific div structure
-        console.print("[cyan]Clicking login button...")
-        try:
-            driver.click('div.dwv_v span:contains("Login")', timeout=5)
-        except Exception as e:
-            print(f"Error clicking login: {e}")
-            try:
-                driver.click('div.dwv_v', timeout=3)
-            except Exception:
-                pass
-
-        driver.sleep(sleep_action)
-
-        # Click "Accedi con email e password" using the specific input
-        console.print("[cyan]Clicking email/password login...")
-        try:
-            driver.click('input.gigya-input-submit[value="Accedi con email e password"]', timeout=5)
-        except Exception as e:
-            print(f"Error clicking email login: {e}")
-            return None
-
-        driver.sleep(sleep_action)
-
-        # Fill login credentials using specific IDs
-        console.print("[cyan]Filling login credentials...")
-        try:
-            email_input = 'input[name="username"].gigya-input-text'
-            driver.wait_for_element(email_input, timeout=5)
-            driver.type(email_input, username)
-            
-            password_input = 'input[name="password"].gigya-input-password'
-            driver.wait_for_element(password_input, timeout=5)
-            driver.type(password_input, password)
-            
-        except Exception as e:
-            print(f"Error filling credentials: {e}")
-            return None
-
-        driver.sleep(sleep_action)
-
-        # Click Continue/Procedi using the submit button
-        console.print("[cyan]Clicking continue button...")
-        try:
-            driver.click('input.gigya-input-submit[type="submit"][value="Continua"]', timeout=5)
-        except Exception as e:
-            print(f"Error clicking continue: {e}")
-            return None
-
-        # Wait for login response and parse network data
-        console.print("[cyan]Waiting for login response...")
-        for attempt in range(30):
-            driver.sleep(0.3)
-            
-            # Check network data for beToken - skip preflight requests
-            for data in network_data:
-                if data.get('method') == 'Network.responseReceived':
-                    params = data.get('params', {})
-                    response = params.get('response', {})
-                    url = response.get('url', '')
-                    request_type = params.get('type', '')
-                    
-                    if "persona/login/v2.0" in url and request_type != 'Preflight':
-                        request_id = params.get('requestId')
-                        
-                        if request_id:
-                            try:
-                                response_body = driver.execute_cdp_cmd(
-                                    'Network.getResponseBody', 
-                                    {'requestId': request_id}
-                                )
-                                body = response_body.get('body', '')
-
-                                if body:
-                                    response_data = json.loads(body)
-                                    be_token = response_data.get("response", {}).get("beToken")
-
-                                    if be_token:
-                                        be_token_holder["token"] = be_token
-                                        console.print("[green]Login successful! BeToken found!")
-                                        return be_token
-                                    
-                            except Exception:
-                                continue
-
-        console.print(f"[yellow]Login completed. Total network events captured: {len(network_data)}")
-        return be_token_holder["token"]
+        if meta_tag:
+            return meta_tag.get('content')
         
-    finally:
-        driver.quit()
+    def getHash256(self):
+        return self.sha256Hash
+    
+    def getBearerToken(self):
+        return self.beToken
+
+    def generate_betoken(self):
+        json_data = {
+            'appName': self.app_name,
+            'client_id': self.client_id,
+        }
+        response = httpx.post(
+            'https://api-ott-prod-fe.mediaset.net/PROD/play/idm/anonymous/login/v2.0',
+            headers=self.headers,
+            json=json_data,
+        )
+        return response.json()['response']['beToken']
+
+    def fetch_html(self, timeout=10):
+        r = httpx.get("https://mediasetinfinity.mediaset.it/", timeout=timeout, headers=self.headers)
+        r.raise_for_status()
+        return r.text
+
+    def find_relevant_script(self, html):
+        soup = BeautifulSoup(html, "html.parser")
+        return [s.get_text() for s in soup.find_all("script") if "imageEngines" in s.get_text()]
+
+    def extract_pairs_from_scripts(self, scripts):
+        # Chi ha inventato questo metodo di offuscare le chiavi merita di essere fustigato in piazza.
+        relevant_part = scripts[0].replace('\\"', '').split('...Option')[1].split('imageEngines')[0]
+        pairs = {}
+        for match in re.finditer(r'([a-f0-9]{64}):\$(\w+)', relevant_part):
+            pairs[match.group(1)] = f"${match.group(2)}"
+        return pairs
+
+    def getHash2c(self):
+        html = self.fetch_html()
+        scripts = self.find_relevant_script(html)[0:1]
+        pairs = self.extract_pairs_from_scripts(scripts)
+        return next((h for h, k in pairs.items() if k == "$2a"), None)
+
+    def generate_request_headers(self):
+        return {
+            'authorization': self.beToken,
+            'user-agent': self.headers['user-agent'],
+            'x-m-device-id': self.client_id,
+            'x-m-platform': 'WEB',
+            'x-m-property': 'MPLAY',
+            'x-m-sid': self.client_id
+        }
 
 
 def get_bearer_token():
     """
     Gets the BEARER_TOKEN for authentication.
-
-    Returns:
-        str: The bearer token string.
+    Anche i manifestanti per strada dio bellissimo.
     """
-    global beToken
-
-    # Read beToken from config if already present
-    beToken = config_manager.get_dict("SITE_LOGIN", "mediasetinfinity")["beToken"]
-    if beToken is not None and len(beToken) != 0:
-        return beToken
-        
-    username = config_manager.get_dict("SITE_LOGIN", "mediasetinfinity").get("username", "")
-    password = config_manager.get_dict("SITE_LOGIN", "mediasetinfinity").get("password", "")
-    
-    if username and password:
-        if not SELENIUMBASE_AVAILABLE:
-            console.print("[yellow]Warning: seleniumbase not available. Cannot perform automatic login.")
-            console.print("[yellow]Please manually obtain beToken and set it in config.")
-            return config_manager.get_dict("SITE_LOGIN", "mediasetinfinity")["beToken"]
-        
-        beToken = generate_betoken(username, password)
-        
-        if beToken is not None:
-
-            # Save current beToken
-            current_value = config_manager.get("SITE_LOGIN", "mediasetinfinity", dict)
-            current_value["beToken"] = beToken
-            config_manager.set_key("SITE_LOGIN", "mediasetinfinity", current_value)
-            config_manager.save_config()
-
-            return beToken
+    global class_mediaset_api
+    if class_mediaset_api is None:
+        class_mediaset_api = MediasetAPI()
+    return class_mediaset_api
             
-    return config_manager.get_dict("SITE_LOGIN", "mediasetinfinity")["beToken"]
 
 
-def get_playback_url(BEARER_TOKEN, CONTENT_ID):
+def get_playback_url(CONTENT_ID):
     """
     Gets the playback URL for the specified content.
 
@@ -222,7 +116,7 @@ def get_playback_url(BEARER_TOKEN, CONTENT_ID):
         dict: The playback JSON object.
     """
     headers = get_headers()
-    headers['authorization'] = f'Bearer {BEARER_TOKEN}'
+    headers['authorization'] = f'Bearer {class_mediaset_api.getBearerToken()}'
     
     json_data = {
         'contentId': CONTENT_ID,
@@ -254,75 +148,101 @@ def get_playback_url(BEARER_TOKEN, CONTENT_ID):
     except Exception as e:
         raise RuntimeError(f"Failed to get playback URL: {e}")
 
-
-def parse_tracking_data(tracking_value):
+def parse_smil_for_media_info(smil_xml):
     """
-    Parses the trackingData string into a dictionary.
-
-    Args:
-        tracking_value (str): The tracking data string.
-
-    Returns:
-        dict: Parsed tracking data.
-    """
-    return dict(item.split('=', 1) for item in tracking_value.split('|') if '=' in item)
-
-
-def parse_smil_for_tracking_and_video(smil_xml):
-    """
-    Extracts all video_src and trackingData pairs from the SMIL.
+    Extracts video streams with quality info and subtitle streams from SMIL.
 
     Args:
         smil_xml (str): The SMIL XML as a string.
 
     Returns:
-        list: A list of dicts: {'video_src': ..., 'tracking_info': ...}
-    """
-    results = []
+        dict: {
+            'videos': [{'url': str, 'quality': str, 'clipBegin': str, 'clipEnd': str, 'tracking_data': dict}, ...],
+            'subtitles': [{'url': str, 'lang': str, 'type': str}, ...]
+        }
+    """   
     root = ET.fromstring(smil_xml)
     ns = {'smil': root.tag.split('}')[0].strip('{')}
-
-    # Search all <par>
+    
+    videos = []
+    subtitles_raw = []
+    
+    # Process all <par> elements
     for par in root.findall('.//smil:par', ns):
-        video_src = None
-        tracking_info = None
-
-        # Search <video> inside <par>
-        video_elem = par.find('.//smil:video', ns)
-        if video_elem is not None:
-            video_src = video_elem.attrib.get('src')
 
-        # Search <ref> inside <par>
+        # Extract video information from <ref>
         ref_elem = par.find('.//smil:ref', ns)
         if ref_elem is not None:
-            # Search <param name="trackingData">
+            url = ref_elem.attrib.get('src')
+            title = ref_elem.attrib.get('title', '')
+            
+            # Parse tracking data inline
+            tracking_data = {}
             for param in ref_elem.findall('.//smil:param', ns):
                 if param.attrib.get('name') == 'trackingData':
-                    tracking_value = param.attrib.get('value')
-                    if tracking_value:
-                        tracking_info = parse_tracking_data(tracking_value)
+                    tracking_value = param.attrib.get('value', '')
+                    tracking_data = dict(item.split('=', 1) for item in tracking_value.split('|') if '=' in item)
                     break
+            
+            if url and url.endswith('.mpd'):
+                video_info = {
+                    'url': url,
+                    'title': title,
+                    'tracking_data': tracking_data
+                }
+                videos.append(video_info)
+    
+        # Extract subtitle information from <textstream>
+        for textstream in par.findall('.//smil:textstream', ns):
+            sub_url = textstream.attrib.get('src')
+            lang = textstream.attrib.get('lang', 'unknown')
+            sub_type = textstream.attrib.get('type', 'unknown')
+            
+            if sub_url:
+                subtitle_info = {
+                    'url': sub_url,
+                    'language': lang,
+                    'type': sub_type
+                }
+                subtitles_raw.append(subtitle_info)
+    
+    # Filter subtitles: prefer VTT, fallback to SRT
+    subtitles_by_lang = {}
+    for sub in subtitles_raw:
+        lang = sub['language']
+        if lang not in subtitles_by_lang:
+            subtitles_by_lang[lang] = []
+        subtitles_by_lang[lang].append(sub)
+    
+    subtitles = []
+    for lang, subs in subtitles_by_lang.items():
+        vtt_subs = [s for s in subs if s['type'] == 'text/vtt']
+        if vtt_subs:
+            subtitles.append(vtt_subs[0])  # Take first VTT
+            
+        else:
+            srt_subs = [s for s in subs if s['type'] == 'text/srt']
+            if srt_subs:
+                subtitles.append(srt_subs[0])  # Take first SRT
+    
+    return {
+        'videos': videos,
+        'subtitles': subtitles
+    }
 
-        if video_src and tracking_info:
-            results.append({'video_src': video_src, 'tracking_info': tracking_info})
-
-    return results
-
-
-def get_tracking_info(BEARER_TOKEN, PLAYBACK_JSON):
+def get_tracking_info(PLAYBACK_JSON):
     """
-    Retrieves tracking information from the playback JSON.
+    Retrieves media information including videos and subtitles from the playback JSON.
 
     Args:
-        BEARER_TOKEN (str): The authentication token.
         PLAYBACK_JSON (dict): The playback JSON object.
 
     Returns:
-        list or None: List of tracking info dicts, or None if request fails.
+        dict or None: {'videos': [...], 'subtitles': [...]}, or None if request fails.
     """
     params = {
         "format": "SMIL",
-        "auth": BEARER_TOKEN,
+        "auth": class_mediaset_api.getBearerToken(),
         "formats": "MPEG-DASH",
         "assetTypes": "HR,browser,widevine,geoIT|geoNo:HR,browser,geoIT|geoNo:SD,browser,widevine,geoIT|geoNo:SD,browser,geoIT|geoNo:SS,browser,widevine,geoIT|geoNo:SS,browser,geoIT|geoNo",
         "balance": "true",
@@ -344,31 +264,29 @@ def get_tracking_info(BEARER_TOKEN, PLAYBACK_JSON):
         )
         response.raise_for_status()
 
-        smil_xml = response.text
-        time.sleep(0.2)
-        results = parse_smil_for_tracking_and_video(smil_xml)
+        results = parse_smil_for_media_info(response.text)
         return results
     
-    except Exception:
+    except Exception as e:
+        print(f"Error fetching tracking info: {e}")
         return None
 
 
-def generate_license_url(BEARER_TOKEN, tracking_info):
+def generate_license_url(tracking_info):
     """
     Generates the URL to obtain the Widevine license.
 
     Args:
-        BEARER_TOKEN (str): The authentication token.
         tracking_info (dict): The tracking info dictionary.
 
     Returns:
         str: The full license URL.
     """
     params = {
-        'releasePid': tracking_info['tracking_info'].get('pid'),
-        'account': f"http://access.auth.theplatform.com/data/Account/{tracking_info['tracking_info'].get('aid')}",
+        'releasePid': tracking_info['tracking_data'].get('pid'),
+        'account': f"http://access.auth.theplatform.com/data/Account/{tracking_info['tracking_data'].get('aid')}",
         'schema': '1.0',
-        'token': BEARER_TOKEN,
+        'token': class_mediaset_api.getBearerToken(),
     }
     
     return f"{'https://widevine.entitlement.theplatform.eu/wv/web/ModularDrm/getRawWidevineLicense'}?{urlencode(params)}"

StreamingCommunity/Api/Site/raiplay/film.py

@@ -1,7 +1,6 @@
 # 21.05.24
 
 import os
-import sys
 from typing import Tuple
 
 
@@ -44,7 +43,7 @@ def download_film(select_title: MediaItem) -> Tuple[str, bool]:
         - bool: Whether download was stopped
     """
     start_message()
-    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
+    console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
 
     # Extract m3u8 URL from the film's URL
     response = httpx.get(select_title.url + ".json", headers=get_headers(), timeout=10)
@@ -64,17 +63,10 @@ def download_film(select_title: MediaItem) -> Tuple[str, bool]:
 
     # MPD
     else:
-
-        # Check CDM file before usage
-        cdm_device_path = get_wvd_path()
-        if not cdm_device_path or not isinstance(cdm_device_path, (str, bytes, os.PathLike)) or not os.path.isfile(cdm_device_path):
-            console.print(f"[bold red] CDM file not found or invalid path: {cdm_device_path}[/bold red]")
-            sys.exit(0)
-
         license_url = generate_license_url(select_title.mpd_id)
 
         dash_process = DASH_Downloader(
-            cdm_device=cdm_device_path,
+            cdm_device=get_wvd_path(),
             license_url=license_url,
             mpd_url=master_playlist,
             output_path=os.path.join(mp4_path, mp4_name),

StreamingCommunity/Api/Site/raiplay/series.py

@@ -1,7 +1,6 @@
 # 21.05.24
 
 import os
-import sys
 from typing import Tuple
 
 
@@ -58,7 +57,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"[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")
+    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
     mp4_name = f"{map_episode_title(scrape_serie.series_name, index_season_selected, index_episode_selected, obj_episode.name)}.mp4"
@@ -85,13 +84,6 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
 
     # MPD
     else:
-
-        # Check CDM file before usage
-        cdm_device_path = get_wvd_path()
-        if not cdm_device_path or not isinstance(cdm_device_path, (str, bytes, os.PathLike)) or not os.path.isfile(cdm_device_path):
-            console.print(f"[bold red] CDM file not found or invalid path: {cdm_device_path}[/bold red]")
-            sys.exit(0)
-
         full_license_url = generate_license_url(obj_episode.mpd_id)
         license_headers = {
             'nv-authorizations': full_license_url.split("?")[1].split("=")[1],
@@ -99,7 +91,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
         }
 
         dash_process = DASH_Downloader(
-            cdm_device=cdm_device_path,
+            cdm_device=get_wvd_path(),
             license_url=full_license_url.split("?")[0],
             mpd_url=master_playlist,
             output_path=os.path.join(mp4_path, mp4_name),

StreamingCommunity/Api/Site/raiplay/site.py

@@ -40,6 +40,7 @@ def determine_media_type(item):
         if not program_name:
             return "film"
 
+        # Dio stranamente guarda che giro bisogna fare per avere il tipo di media.
         scraper = GetSerieInfo(program_name)
         scraper.collect_info_title()
         return scraper.prog_tipology, scraper.prog_description, scraper.prog_year

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

@@ -41,7 +41,12 @@ class GetSerieInfo:
                 
             response.raise_for_status()
             json_data = response.json()
-            self.prog_tipology = "tv" if "tv" in json_data.get('track_info').get('typology') else "film"
+
+            # Dio santissimo ma chi ha fatto le cose cosi di merda.
+            type_check_1 = "tv" if json_data.get('program_info', {}).get('layout', 'single') == 'multi' else "film"
+            #type_check_2 = "tv" if "tv" in json_data.get('track_info', {}).get('typology', '') else "film"
+
+            self.prog_tipology = type_check_1
             self.prog_description = json_data.get('program_info', '').get('vanity', '')
             self.prog_year = json_data.get('program_info', '').get('year', '')
             
@@ -82,6 +87,7 @@ class GetSerieInfo:
         try:
             season = self.seasons_manager.get_season_by_number(number_season)
 
+            # Se stai leggendo questo codice spieami perche hai fatto cosi.
             url = f"{self.base_url}/programmi/{self.program_name}/{self.publishing_block_id}/{season.id}/episodes.json"
             response = httpx.get(url=url, headers=get_headers(), timeout=max_timeout)
             response.raise_for_status()

StreamingCommunity/Api/Site/streamingcommunity/film.py

@@ -52,7 +52,7 @@ def download_film(select_title: MediaItem) -> str:
 
     # Start message and display film information
     start_message()
-    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
+    console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
 
     # Init class
     video_source = VideoSource(f"{site_constant.FULL_URL}/it", False, select_title.id)

StreamingCommunity/Api/Site/streamingcommunity/series.py

@@ -55,7 +55,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"[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")
+    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")
 
     if site_constant.TELEGRAM_BOT:
         bot = get_bot_instance()

StreamingCommunity/Api/Site/streamingwatch/film.py

@@ -38,7 +38,7 @@ def download_film(select_title: MediaItem) -> str:
         - str: output path
     """
     start_message()
-    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
+    console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
 
     # Get master playlists
     video_source = VideoSource()

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"[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")
+    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")
 
     # 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"