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

StreamingCommunity/Api/Site/mediasetinfinity/series.py

@@ -0,0 +1,177 @@
+# 16.03.25
+
+import os
+from typing import Tuple
+
+
+# External library
+from rich.console import Console
+from rich.prompt import Prompt
+
+
+# Internal utilities
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.os import get_wvd_path
+from StreamingCommunity.Lib.Downloader.DASH.downloader import DASH_Download
+
+
+# Logic class
+from .util.ScrapeSerie import GetSerieInfo
+from StreamingCommunity.Api.Template.Util import (
+    manage_selection, 
+    map_episode_title,
+    validate_selection, 
+    validate_episode_selection, 
+    display_episodes_list
+)
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from .util.fix_mpd import get_manifest
+from .util.get_license import get_bearer_token, get_playback_url, get_tracking_info, generate_license_url
+
+
+# Variable
+msg = Prompt()
+console = Console()
+
+
+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.
+
+    Parameters:
+        - index_season_selected (int): Season number
+        - index_episode_selected (int): Episode index
+        - scrape_serie (GetSerieInfo): Scraper object with series information
+
+    Returns:
+        - str: Path to downloaded file
+        - bool: Whether download was stopped
+    """
+    start_message()
+
+    # 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] → [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"
+    mp4_path = os_manager.get_sanitize_path(os.path.join(site_constant.SERIES_FOLDER, scrape_serie.series_name, f"S{index_season_selected}"))
+
+    # Generate mpd and license URLs
+    bearer = get_bearer_token()
+    playback_json = get_playback_url(bearer, obj_episode.url.split('_')[-1])
+    tracking_info = get_tracking_info(bearer, playback_json)[0]
+
+    license_url = generate_license_url(bearer, tracking_info)
+    mpd_url = get_manifest(tracking_info['video_src'])
+
+    # Download the episode
+    r_proc = DASH_Download(
+        cdm_device=get_wvd_path(),
+        license_url=license_url,
+        mpd_url=mpd_url,
+        output_path=os.path.join(mp4_path, mp4_name),
+    )
+    r_proc.parse_manifest(custom_headers=get_headers())
+
+    if r_proc.download_and_decrypt():
+        r_proc.finalize_output()
+
+    # Get final output path and status
+    status = r_proc.get_status()
+
+    if status['error'] is not None and status['path']:
+        try: os.remove(status['path'])
+        except Exception: pass
+
+    return status['path'], status['stopped']
+    
+
+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.
+
+    Parameters:
+        - index_season_selected (int): Season number
+        - scrape_serie (GetSerieInfo): Scraper object with series information
+        - download_all (bool): Whether to download all episodes
+        - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
+    """
+    # Get episodes for the selected season
+    episodes = scrape_serie.getEpisodeSeasons(index_season_selected)
+    episodes_count = len(episodes)
+
+    if download_all:
+        for i_episode in range(1, episodes_count + 1):
+            path, stopped = download_video(index_season_selected, i_episode, scrape_serie)
+
+            if stopped:
+                break
+
+        console.print(f"\n[red]End downloaded [yellow]season: [red]{index_season_selected}.")
+
+    else:
+        if episode_selection is not None:
+            last_command = episode_selection
+            console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
+
+        else:
+            last_command = display_episodes_list(episodes)
+        
+        # Prompt user for episode selection
+        list_episode_select = manage_selection(last_command, episodes_count)
+        list_episode_select = validate_episode_selection(list_episode_select, episodes_count)
+
+        # Download selected episodes if not stopped
+        for i_episode in list_episode_select:
+            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) -> None:
+    """
+    Handle downloading a complete series.
+
+    Parameters:
+        - select_season (MediaItem): Series metadata from search
+        - 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)
+
+    # Get total number of seasons 
+    seasons_count = scrape_serie.getNumberSeason()
+
+    # Prompt user for season selection and download episodes
+    console.print(f"\n[green]Seasons found: [red]{seasons_count}")
+
+    # If season_selection is provided, use it instead of asking for input
+    if season_selection is None:
+        index_season_selected = msg.ask(
+            "\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
+            "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end"
+        )
+
+    else:
+        index_season_selected = season_selection
+        console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
+
+    # Validate the selection
+    list_season_select = manage_selection(index_season_selected, seasons_count)
+    list_season_select = validate_selection(list_season_select, seasons_count)
+    
+    # Loop through the selected seasons and download episodes
+    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)
+        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)

StreamingCommunity/Api/Site/mediasetinfinity/site.py

@@ -0,0 +1,112 @@
+# 25.07.25
+
+# External libraries
+import httpx
+from rich.console import Console
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.table import TVShowManager
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
+
+
+# Logic class
+from .util.get_license import get_bearer_token
+
+
+# Variable
+console = Console()
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+def title_search(query: str) -> int:
+    """
+    Search for titles based on a search query.
+      
+    Parameters:
+        - query (str): The query to search for.
+
+    Returns:
+        int: The number of titles found.
+    """
+    media_search_manager.clear()
+    table_show_manager.clear()
+
+    search_url = f'https://api-ott-prod-fe.mediaset.net/PROD/play/reco/anonymous/v2.0'
+    console.print(f"[cyan]Search url: [yellow]{search_url}")
+
+    params = {
+        'uxReference': 'filteredSearch',
+        'shortId': '',
+        'query': query.strip(),
+        'params': 'channel≈;variant≈',
+        'contentId': '',
+        'property': 'search',
+        'tenant': 'play-prod-v2',
+        'userContext': 'iwiAeyJwbGF0Zm9ybSI6IndlYiJ9Aw==',
+        'aresContext': '',
+        'page': '1',
+        'hitsPerPage': '8',
+        'clientId': 'client_id'
+    }
+
+    headers = get_headers()
+    headers['authorization'] = f'Bearer {get_bearer_token()}'
+
+    try:
+        response = httpx.get(
+            search_url, 
+            headers=headers, 
+            params=params,
+            timeout=max_timeout, 
+            follow_redirects=True
+        )
+
+        response.raise_for_status()
+    except Exception as e:
+        console.print(f"[red]Site: {site_constant.SITE_NAME}, request search error: {e}")
+        return 0
+
+    # Parse response
+    resp_json = response.json()
+    blocks = resp_json.get('response', {}).get('blocks', [])
+    items = []
+    for block in blocks:
+        if 'items' in block:
+            items.extend(block['items'])
+        elif 'results' in block and 'items' in block['results']:
+            items.extend(block['results']['items'])
+    
+    # Process items
+    for item in items:
+
+        # Get the media type
+        program_type = item.get('programType', '') or item.get('programtype', '')
+        program_type = program_type.lower()
+        
+        if program_type in ('movie', 'film'):
+            media_type = 'film'
+            page_url = item.get('mediasetprogram$videoPageUrl', '')
+        elif program_type in ('series', 'serie'):
+            media_type = 'tv'
+            page_url = item.get('mediasetprogram$pageUrl', '')
+        else:
+            continue
+
+        if page_url and page_url.startswith('//'):
+            page_url = f"https:{page_url}"
+
+        media_search_manager.add_media({
+            'id': item.get('guid', '') or item.get('_id', ''),
+            'name': item.get('title', ''),
+            'type': media_type,
+            'url': page_url,
+            'image': None,
+        })
+
+    return media_search_manager.get_length()

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

@@ -0,0 +1,259 @@
+# 16.03.25
+
+import re
+import logging
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_headers, get_userAgent
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
+
+
+# Logic class
+from .get_license import get_bearer_token, get_playback_url
+
+
+# Variable
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+class GetSerieInfo:
+    def __init__(self, url):
+        """
+        Initialize the GetSerieInfo class for scraping TV series information.
+        
+        Args:
+            - url (str): The URL of the streaming site.
+        """
+        self.headers = get_headers()
+        self.url = url
+        self.seasons_manager = SeasonManager()
+        self.subBrandId = None
+        self.id_media = None
+        self.current_url = None
+
+    def _extract_subbrand_id(self, soup):
+        """
+        Extract subBrandId from the chapter link in the main page.
+        Searches all <a> tags to see if one has 'capitoli_' in the href.
+        """
+        for a_tag in soup.find_all("a", href=True):
+            href = a_tag["href"]
+
+            if "capitoli_" in href:
+                match = re.search(r"sb(\d+)", href)
+                if match:
+                    return match.group(1)
+                match = re.search(r",sb(\d+)", href)
+                if match:
+                    return match.group(1)
+                
+        return None
+
+    def _find_video_href_and_id(self, soup):
+        """
+        Search for the first <a> with href containing '/video/' and return (current_url, id_media).
+        Always builds the absolute URL.
+        """
+        for a_tag in soup.find_all("a", href=True):
+            href = a_tag["href"]
+            if "/video/" in href:
+                if href.startswith("http"):
+                    current_url = href
+                else:
+                    current_url = "https://mediasetinfinity.mediaset.it" + href
+
+                bearer = get_bearer_token()
+                playback_json = get_playback_url(bearer, current_url.split('_')[-1])
+                id_media = str(playback_json['url']).split("/s/")[1].split("/")[0]
+
+                return current_url, id_media
+        return None, None
+
+    def _parse_entries(self, entries, single_season=False):
+        """
+        Populate seasons and episodes from the JSON entries.
+        If single_season=True, creates only one season and adds all episodes there.
+        """
+        if not entries:
+            self.series_name = ""
+            return
+
+        self.series_name = entries[0].get("mediasetprogram$auditelBrandName", "")
+
+        if single_season:
+            logging.info("Single season mode enabled.")
+            season_num = 1
+            season_name = "Stagione 1"
+            current_season = self.seasons_manager.add_season({
+                'number': season_num,
+                'name': season_name
+            })
+
+            for idx, entry in enumerate(entries, 1):
+                title = entry.get("title", "")
+                video_page_url = entry.get("mediasetprogram$videoPageUrl", "")
+
+                if video_page_url.startswith("//"):
+                    episode_url = "https:" + video_page_url
+                else:
+                    episode_url = video_page_url
+                    
+                if current_season:
+                    current_season.episodes.add({
+                        'number': idx,
+                        'name': title,
+                        'url': episode_url,
+                        'duration': int(entry.get("mediasetprogram$duration", 0) / 60)
+                    })
+        else:
+            seasons_dict = {}
+
+            logging.info("Multi season mode")
+            for entry in entries:
+
+                # Use JSON fields directly instead of regex
+                season_num = entry.get("tvSeasonNumber")
+                ep_num = entry.get("tvSeasonEpisodeNumber")
+
+                # Extract numbers from title if season_num or ep_num are None
+                if season_num is None or ep_num is None:
+                    title = entry.get("title", "")
+
+                    # Find all numbers in the title
+                    numbers = [int(n) for n in re.findall(r"\d+", title)]
+                    if len(numbers) == 2:
+                        season_num, ep_num = numbers
+
+                    elif len(numbers) == 1:
+                        # If only one, use it as episode
+                        ep_num = numbers[0]
+
+                if season_num is None or ep_num is None:
+                    continue
+
+                season_name = entry.get("mediasetprogram$brandTitle") or f"Stagione {season_num}"
+
+                if season_num not in seasons_dict:
+                    current_season = self.seasons_manager.add_season({
+                        'number': season_num,
+                        'name': season_name
+                    })
+                    seasons_dict[season_num] = current_season
+
+                else:
+                    current_season = seasons_dict[season_num]
+
+                video_page_url = entry.get("mediasetprogram$videoPageUrl", "")
+                if video_page_url.startswith("//"):
+                    episode_url = "https:" + video_page_url
+                else:
+                    episode_url = video_page_url
+
+                if current_season:
+                    current_season.episodes.add({
+                        'number': ep_num,
+                        'name': entry.get("title", ""),
+                        'url': episode_url,
+                        'duration': entry.get("mediasetprogram$duration")
+                    })
+
+    def collect_season(self) -> None:
+        """
+        Retrieve all episodes for all seasons using the Mediaset Infinity API.
+        """
+        response = httpx.get(self.url, headers=self.headers, follow_redirects=True, timeout=max_timeout)
+        soup = BeautifulSoup(response.text, "html.parser")
+
+        # Find current_url and id_media from the first <a> with /video/
+        self.current_url, found_id_media = self._find_video_href_and_id(soup)
+        if found_id_media:
+            self.id_media = found_id_media
+
+        self.subBrandId = self._extract_subbrand_id(soup)
+        single_season = False
+        if self.subBrandId is None:
+            episodi_link = None
+            for h2_tag in soup.find_all("h2", class_=True):
+                a_tag = h2_tag.find("a", href=True)
+                if a_tag and "/episodi_" in a_tag["href"]:
+                    episodi_link = a_tag["href"]
+                    break
+
+            if episodi_link:
+                match = re.search(r"sb(\d+)", episodi_link)
+                if match:
+                    self.subBrandId = match.group(1)
+
+                single_season = True
+
+            else:
+                puntate_link = None
+                for a_tag in soup.find_all("a", href=True):
+                    href = a_tag["href"]
+                    if "puntateintere" in href and "sb" in href:
+                        puntate_link = href
+                        break
+
+                if puntate_link:
+                    match = re.search(r"sb(\d+)", puntate_link)
+                    if match:
+                        self.subBrandId = match.group(1)
+
+                    single_season = True
+                else:
+                    print("No /episodi_ or puntateintere link found.")
+
+        # Step 2: JSON request
+        params = {
+            'byCustomValue': "{subBrandId}{" + str(self.subBrandId) + "}",
+            'sort': ':publishInfo_lastPublished|asc,tvSeasonEpisodeNumber|asc',
+            'range': '0-100',
+        }
+
+        json_url = f'https://feed.entertainment.tv.theplatform.eu/f/{self.id_media}/mediaset-prod-all-programs-v2'
+        json_resp = httpx.get(json_url, headers={'user-agent': get_userAgent()}, params=params, timeout=max_timeout, follow_redirects=True)
+
+        data = json_resp.json()
+        entries = data.get("entries", [])
+
+        # Use the unified parsing function
+        self._parse_entries(entries, single_season=single_season)
+
+    # ------------- FOR GUI -------------
+    def getNumberSeason(self) -> int:
+        """
+        Get the total number of seasons available for the series.
+        """
+        if not self.seasons_manager.seasons:
+            self.collect_season()
+            
+        return len(self.seasons_manager.seasons)
+    
+    def getEpisodeSeasons(self, season_number: int) -> list:
+        """
+        Get all episodes for a specific season.
+        """
+        if not self.seasons_manager.seasons:
+            self.collect_season()
+            
+        # Get season directly by its number
+        season = self.seasons_manager.get_season_by_number(season_number)
+        return season.episodes.episodes if season else []
+        
+    def selectEpisode(self, season_number: int, episode_index: int) -> dict:
+        """
+        Get information for a specific episode in a specific season.
+        """
+        episodes = self.getEpisodeSeasons(season_number)
+        if not episodes or episode_index < 0 or episode_index >= len(episodes):
+            logging.error(f"Episode index {episode_index} is out of range for season {season_number}")
+            return None
+            
+        return episodes[episode_index]

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

@@ -0,0 +1,64 @@
+# 16.03.25
+
+from urllib.parse import urlparse, urlunparse
+
+
+# External library
+import httpx
+
+
+def try_mpd(url, qualities):
+    """
+    Given a url containing one of the qualities (hd/hr/sd), try to replace it with the others and check which manifest exists.
+    """
+    parsed = urlparse(url)
+    path_parts = parsed.path.rsplit('/', 1)
+
+    if len(path_parts) != 2:
+        return None
+    
+    dir_path, filename = path_parts
+
+    # Find the current quality in the filename
+    def replace_quality(filename, old_q, new_q):
+        if f"{old_q}_" in filename:
+            return filename.replace(f"{old_q}_", f"{new_q}_", 1)
+        elif filename.startswith(f"{old_q}_"):
+            return f"{new_q}_" + filename[len(f"{old_q}_") :]
+        return filename
+
+    for q in qualities:
+
+        # Search for which quality is present in the filename
+        for old_q in qualities:
+            if f"{old_q}_" in filename or filename.startswith(f"{old_q}_"):
+                new_filename = replace_quality(filename, old_q, q)
+                break
+
+        else:
+            new_filename = filename  # No quality found, use original filename
+
+        new_path = f"{dir_path}/{new_filename}"
+        mpd_url = urlunparse(parsed._replace(path=new_path)).strip()
+
+        try:
+            r = httpx.head(mpd_url, timeout=5)
+            if r.status_code == 200:
+                return mpd_url
+            
+        except Exception:
+            pass
+
+    return None
+
+def get_manifest(base):
+    """
+    Try to get the manifest URL by checking different qualities.
+    """
+    manifest_qualities = ["hd", "hr", "sd"]
+
+    mpd_url = try_mpd(base, manifest_qualities)
+    if not mpd_url:
+        exit(1)
+
+    return mpd_url