StreamingCommunity 3.2.8__py3-none-any.whl → 3.3.0__py3-none-any.whl

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

@@ -1,11 +1,12 @@
 # 16.03.25
 
-import re
+
 import logging
+from urllib.parse import urlparse
 
 
 # External libraries
-import httpx
+from curl_cffi import requests
 from bs4 import BeautifulSoup
 
 
@@ -16,7 +17,7 @@ from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
 
 
 # Logic class
-from .get_license import get_bearer_token, get_playback_url
+from .get_license import get_bearer_token
 
 
 # Variable
@@ -34,197 +35,230 @@ class GetSerieInfo:
         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
-            })
+        self.serie_id = None
+        self.public_id = None
+        self.series_name = ""
+        self.stagioni_disponibili = []
+
+    def _extract_serie_id(self):
+        """Estrae l'ID della serie dall'URL di partenza"""
+        self.serie_id = f"SE{self.url.split('SE')[1]}"
+        print(f"Serie ID: {self.serie_id}")
+        return self.serie_id
+
+    def _get_public_id(self):
+        """Ottiene il public ID tramite l'API watchlist"""
+        bearer_token = get_bearer_token()
+        headers = {
+            'authorization': f'Bearer {bearer_token}',
+            'user-agent': get_userAgent(),
+        }
 
-            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)
-                    })
+        response = requests.get(
+            'https://api-ott-prod-fe.mediaset.net/PROD/play/userlist/watchlist/v2.0',
+            headers=headers,
+            impersonate="chrome",
+            allow_redirects=True
+        )
+
+        if response.status_code == 401:
+            print("Token scaduto, rinnovare il token")
+
+        if response.status_code == 200:
+            data = response.json()
+            self.public_id = data['response']['entries'][0]['media'][0]['publicUrl'].split("/")[4]
+            print(f"Public id: {self.public_id}")
+            return self.public_id
+        
         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
+            logging.error(f"Failed to get public ID: {response.status_code}")
+            return None
 
-                    elif len(numbers) == 1:
-                        # If only one, use it as episode
-                        ep_num = numbers[0]
+    def _get_series_data(self):
+        """Ottiene i dati della serie tramite l'API"""
+        headers = {
+            'User-Agent': get_userAgent(),
+        }
+        params = {'byGuid': self.serie_id}
+
+        response = requests.get(
+            f'https://feed.entertainment.tv.theplatform.eu/f/{self.public_id}/mediaset-prod-all-series-v2',
+            params=params,
+            headers=headers,
+            impersonate="chrome",
+            allow_redirects=True
+        )
+        print("Risposta per _get_series_data:", response.status_code)
+
+        if response.status_code == 200:
+            return response.json()
+        else:
+            logging.error(f"Failed to get series data: {response.status_code}")
+            return None
 
-                if season_num is None or ep_num is None:
-                    continue
+    def _process_available_seasons(self, data):
+        """Processa le stagioni disponibili dai dati della serie"""
+        if not data or not data.get('entries'):
+            logging.error("No series data found")
+            return []
 
-                season_name = entry.get("mediasetprogram$brandTitle") or f"Stagione {season_num}"
+        entry = data['entries'][0]
+        self.series_name = entry.get('title', '')
+        
+        seriesTvSeasons = entry.get('seriesTvSeasons', [])
+        availableTvSeasonIds = entry.get('availableTvSeasonIds', [])
+
+        stagioni_disponibili = []
+
+        for url in availableTvSeasonIds:
+            season = next((s for s in seriesTvSeasons if s['id'] == url), None)
+            if season:
+                stagioni_disponibili.append({
+                    'tvSeasonNumber': season['tvSeasonNumber'],
+                    'url': url,
+                    'id': str(url).split("/")[-1],
+                    'guid': season['guid']
+                })
+            else:
+                logging.warning(f"Season URL not found: {url}")
 
-                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")
-                    })
+        # Ordina le stagioni dalla più vecchia alla più nuova
+        stagioni_disponibili.sort(key=lambda s: s['tvSeasonNumber'])
+        
+        return stagioni_disponibili
+
+    def _build_season_page_urls(self, stagioni_disponibili):
+        """Costruisce gli URL delle pagine delle stagioni"""
+        parsed_url = urlparse(self.url)
+        base_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
+        series_slug = parsed_url.path.strip('/').split('/')[-1].split('_')[0]
+
+        for season in stagioni_disponibili:
+            page_url = f"{base_url}/fiction/{series_slug}/{series_slug}{season['tvSeasonNumber']}_{self.serie_id},{season['guid']}"
+            season['page_url'] = page_url
+
+    def _extract_season_sb_ids(self, stagioni_disponibili):
+        """Estrae gli ID sb dalle pagine delle stagioni"""
+        for season in stagioni_disponibili:
+            response_page = requests.get(
+                season['page_url'],
+                headers={'User-Agent': get_userAgent()},
+                impersonate="chrome",
+                allow_redirects=True
+            )
+            print("Risposta per _extract_season_sb_ids:", response_page.status_code)
+
+            soup = BeautifulSoup(response_page.text, 'html.parser')
+            
+            # Prova prima con 'Episodi', poi con 'Puntate intere'
+            link = soup.find('a', string='Episodi')
+            if not link:
+                print("Using word: Puntate intere")
+                link = soup.find('a', string='Puntate intere')
+            
+            if link and link.has_attr('href'):
+                if not link.string == 'Puntate intere':
+                    print("Using word: Episodi")
+                season['sb'] = link['href'].split(',')[-1]
+            else:
+                logging.warning(f"Link 'Episodi' o 'Puntate intere' non trovato per stagione {season['tvSeasonNumber']}")
 
-    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
+    def _get_season_episodes(self, season):
+        """Ottiene gli episodi per una stagione specifica"""
+        if not season.get('sb'):
+            return
 
-            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
+        episode_headers = {
+            'origin': 'https://mediasetinfinity.mediaset.it',
+            'referer': 'https://mediasetinfinity.mediaset.it/',
+            'user-agent': get_userAgent(),
+        }
         params = {
-            'byCustomValue': "{subBrandId}{" + str(self.subBrandId) + "}",
+            'byCustomValue': "{subBrandId}{" + str(season["sb"].replace('sb', '')) + "}",
             'sort': ':publishInfo_lastPublished|asc,tvSeasonEpisodeNumber|asc',
             'range': '0-100',
         }
+        episode_url = f"https://feed.entertainment.tv.theplatform.eu/f/{self.public_id}/mediaset-prod-all-programs-v2"
 
-        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", [])
+        episode_response = requests.get(episode_url, headers=episode_headers, params=params, impersonate="chrome"
+                    , allow_redirects=True)
+        print("Risposta per _get_season_episodes:", episode_response.status_code)
+        
+        if episode_response.status_code == 200:
+            episode_data = episode_response.json()
+            season['episodes'] = []
+            
+            for entry in episode_data.get('entries', []):
+                episode_info = {
+                    'id': entry.get('guid'),
+                    'title': entry.get('title'),
+                    'duration': int(entry.get('mediasetprogram$duration', 0) / 60) if entry.get('mediasetprogram$duration') else 0,
+                    'url': entry.get('media', [{}])[0].get('publicUrl') if entry.get('media') else None
+                }
+                season['episodes'].append(episode_info)
+            
+            print(f"Found {len(season['episodes'])} episodes for season {season['tvSeasonNumber']}")
+        else:
+            logging.error(f"Failed to get episodes for season {season['tvSeasonNumber']}: {episode_response.status_code}")
 
-        # Use the unified parsing function
-        self._parse_entries(entries, single_season=single_season)
+    def collect_season(self) -> None:
+        """
+        Retrieve all episodes for all seasons using the new Mediaset Infinity API.
+        """
+        try:
+            # Step 1: Extract serie ID from URL
+            self._extract_serie_id()
+            
+            # Step 2: Get public ID
+            if not self._get_public_id():
+                logging.error("Failed to get public ID")
+                return
+                
+            # Step 3: Get series data
+            data = self._get_series_data()
+            if not data:
+                logging.error("Failed to get series data")
+                return
+                
+            # Step 4: Process available seasons
+            self.stagioni_disponibili = self._process_available_seasons(data)
+            if not self.stagioni_disponibili:
+                logging.error("No seasons found")
+                return
+                
+            # Step 5: Build season page URLs
+            self._build_season_page_urls(self.stagioni_disponibili)
+            
+            # Step 6: Extract sb IDs from season pages
+            self._extract_season_sb_ids(self.stagioni_disponibili)
+            
+            # Step 7: Get episodes for each season
+            for season in self.stagioni_disponibili:
+                self._get_season_episodes(season)
+                
+            # Step 8: Populate seasons manager
+            self._populate_seasons_manager()
+            
+        except Exception as e:
+            logging.error(f"Error in collect_season: {str(e)}")
+
+    def _populate_seasons_manager(self):
+        """Popola il seasons_manager con i dati raccolti"""
+        for season_data in self.stagioni_disponibili:
+            season_obj = self.seasons_manager.add_season({
+                'number': season_data['tvSeasonNumber'],
+                'name': f"Stagione {season_data['tvSeasonNumber']}"
+            })
+            
+            if season_obj and season_data.get('episodes'):
+                for idx, episode in enumerate(season_data['episodes'], 1):
+                    season_obj.episodes.add({
+                        'id': episode['id'],
+                        'number': idx,
+                        'name': episode['title'],
+                        'url': episode['url'],
+                        'duration': episode['duration']
+                    })
 
     # ------------- FOR GUI -------------
     def getNumberSeason(self) -> int:

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

@@ -15,8 +15,6 @@ from StreamingCommunity.Util.headers import get_headers, get_userAgent
 
 # Variable
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
-bearer_token = None
-playback_json = None
 
 
 def get_bearer_token():
@@ -26,29 +24,7 @@ def get_bearer_token():
     Returns:
         str: The bearer token string.
     """
-    global bearer_token
-
-    if bearer_token:
-        return bearer_token
-    
-    LOGIN_URL = "https://api-ott-prod-fe.mediaset.net/PROD/play/idm/anonymous/login/v2.0"
-
-    try:
-        response = httpx.post(
-            LOGIN_URL,
-            json={'client_id': 'client_id', 'appName': 'embed//mediasetplay-embed'},
-            follow_redirects=True,
-            timeout=MAX_TIMEOUT
-        )
-        response.raise_for_status()
-
-        # Extract the bearer token from the response
-        data = response.json()
-        bearer_token = data["response"]["beToken"]
-        return bearer_token
-    
-    except Exception as e:
-        raise RuntimeError(f"Failed to get bearer token: {e}")
+    return config_manager.get_dict("SITE_LOGIN", "mediasetinfinity")["beToken"]
 
 def get_playback_url(BEARER_TOKEN, CONTENT_ID):
     """
@@ -61,11 +37,6 @@ def get_playback_url(BEARER_TOKEN, CONTENT_ID):
     Returns:
         dict: The playback JSON object.
     """
-    global playback_json
-
-    if playback_json is not None:
-        return playback_json
-
     headers = get_headers()
     headers['authorization'] = f'Bearer {BEARER_TOKEN}'
     
@@ -190,7 +161,7 @@ def get_tracking_info(BEARER_TOKEN, PLAYBACK_JSON):
         results = parse_smil_for_tracking_and_video(smil_xml)
         return results
     
-    except Exception as e:
+    except Exception:
         return None
 
 def generate_license_url(BEARER_TOKEN, tracking_info):

StreamingCommunity/Api/Site/raiplay/__init__.py

@@ -10,6 +10,7 @@ from rich.prompt import Prompt
 from StreamingCommunity.Api.Template import get_select_title
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
 
 # Logic class
@@ -22,7 +23,7 @@ from .film import download_film
 indice = 5
 _useFor = "Film_&_Serie"
 _priority = 0
-_engineDownload = "hls"
+_engineDownload = "hls_dash"
 _deprecate = False
 
 msg = Prompt()
@@ -44,6 +45,14 @@ def process_search_result(select_title, selections=None):
         selections (dict, optional): Dictionary containing selection inputs that bypass manual input
                                     {'season': season_selection, 'episode': episode_selection}
     """
+    if not select_title:
+        if site_constant.TELEGRAM_BOT:
+            bot = get_bot_instance()
+            bot.send_message("No title selected or selection cancelled.", None)
+        else:
+            console.print("[yellow]No title selected or selection cancelled.")
+        return
+    
     if select_title.type == 'tv':
         season_selection = None
         episode_selection = None
@@ -68,26 +77,52 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
         selections (dict, optional): Dictionary containing selection inputs that bypass manual input
                                     {'season': season_selection, 'episode': episode_selection}
     """
+    """
+    Main function of the application for search.
+
+    Parameters:
+        string_to_search (str, optional): String to search for
+        get_onlyDatabase (bool, optional): If True, return only the database object
+        direct_item (dict, optional): Direct item to process (bypass search)
+        selections (dict, optional): Dictionary containing selection inputs that bypass manual input
+                                    {'season': season_selection, 'episode': episode_selection}
+    """
+    bot = None
+    if site_constant.TELEGRAM_BOT:
+        bot = get_bot_instance()
+    
     if direct_item:
         select_title = MediaItem(**direct_item)
         process_search_result(select_title, selections)
         return
-
-    if string_to_search is None:
-        string_to_search = msg.ask(f"\n[purple]Insert a word to search in [green]{site_constant.SITE_NAME}").strip()
-
-    # Search on database
-    len_database = title_search(string_to_search)
+    
+    # Get the user input for the search term
+    actual_search_query = get_user_input(string_to_search)
+
+    # Handle cases where user input is empty, or 'back' was handled (sys.exit or None return)
+    if not actual_search_query:
+        if bot:
+            if actual_search_query is None: # Specifically for timeout from bot.ask or failed restart
+                bot.send_message("Search term not provided or operation cancelled. Returning.", None)
+        return
+    
+    # Perform the database search
+    len_database = title_search(actual_search_query)
 
     # If only the database is needed, return the manager
     if get_onlyDatabase:
         return media_search_manager
-    
+
     if len_database > 0:
-        select_title = get_select_title(table_show_manager, media_search_manager,len_database)
+        select_title = get_select_title(table_show_manager, media_search_manager, len_database)
         process_search_result(select_title, selections)
     
     else:
-        # If no results are found, ask again
-        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
-        search()
+        if bot:
+            bot.send_message(f"No results found for: '{actual_search_query}'", None)
+        else:
+            console.print(f"\n[red]Nothing matching was found for[white]: [purple]{actual_search_query}")
+
+        # Do not call search() recursively here to avoid infinite loops on no results.
+        # The flow should return to the caller (e.g., main menu in run.py).
+        return

StreamingCommunity/Api/Site/raiplay/film.py

@@ -1,6 +1,7 @@
 # 21.05.24
 
 import os
+import sys
 from typing import Tuple
 
 
@@ -12,16 +13,18 @@ from rich.console import Console
 # Internal utilities
 from StreamingCommunity.Util.os import os_manager
 from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.os import get_wvd_path
 from StreamingCommunity.Util.message import start_message
 
 
 # Logic class
+from .util.get_license import generate_license_url
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
 
 
 # Player
-from StreamingCommunity import HLS_Downloader
+from StreamingCommunity import HLS_Downloader, DASH_Downloader
 from StreamingCommunity.Api.Player.mediapolisvod import VideoSource
 
 
@@ -49,17 +52,46 @@ def download_film(select_title: MediaItem) -> Tuple[str, bool]:
     master_playlist = VideoSource.extract_m3u8_url(first_item_path)
 
     # 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", ""))
+    mp4_name = os_manager.get_sanitize_file(select_title.name) + ".mp4"
+    mp4_path = os.path.join(site_constant.MOVIE_FOLDER, mp4_name.replace(".mp4", ""))
+
+    # HLS
+    if ".mpd" not in master_playlist:
+        r_proc = HLS_Downloader(
+            m3u8_url=master_playlist,
+            output_path=os.path.join(mp4_path, mp4_name)
+        ).start()
+
+    # 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,
+            license_url=license_url,
+            mpd_url=master_playlist,
+            output_path=os.path.join(mp4_path, mp4_name),
+        )
+        dash_process.parse_manifest(custom_headers=get_headers())
+        
+        if dash_process.download_and_decrypt():
+            dash_process.finalize_output()
+
+        # Get final output path and status
+        r_proc = dash_process.get_status()
 
-    # Download the film using the m3u8 playlist, and output filename
-    r_proc = HLS_Downloader(
-        m3u8_url=master_playlist,
-        output_path=os.path.join(mp4_path, title_name)
-    ).start()
 
     if r_proc['error'] is not None:
-        try: os.remove(r_proc['path'])
-        except: pass
+        try: 
+            os.remove(r_proc['path'])
+        except Exception: 
+            pass
 
     return r_proc['path'], r_proc['stopped']