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

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

@@ -0,0 +1,218 @@
+# 16.03.25
+
+import logging
+
+
+# External libraries
+from curl_cffi import requests
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
+from .get_license import get_auth_token, generate_device_id
+
+
+# Variable
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+def get_series_seasons(series_id, headers, params):
+    """
+    Fetches the seasons for a given series ID from Crunchyroll.
+    """
+    url = f'https://www.crunchyroll.com/content/v2/cms/series/{series_id}/seasons'
+    response = requests.get(
+        url,
+        params=params,
+        headers=headers,
+        impersonate="chrome110"
+    )
+    return response
+
+
+def get_season_episodes(season_id, headers, params):
+    """
+    Fetches the episodes for a given season ID from Crunchyroll.
+    """
+    url = f'https://www.crunchyroll.com/content/v2/cms/seasons/{season_id}/episodes'
+    response = requests.get(
+        url,
+        params=params,
+        headers=headers,
+        impersonate="chrome110"
+    )
+    return response
+
+
+class GetSerieInfo:
+    def __init__(self, series_id):
+        """
+        Initialize the GetSerieInfo class for scraping TV series information using Crunchyroll API.
+        
+        Args:
+            - series_id (str): The Crunchyroll series ID.
+        """
+        self.series_id = series_id
+        self.seasons_manager = SeasonManager()
+        self.headers = get_headers()
+        self.headers['authorization'] = f"Bearer {get_auth_token(generate_device_id()).access_token}"
+        self.params = {
+            'force_locale': '',
+            'preferred_audio_language': 'it-IT',
+            'locale': 'it-IT',
+        }
+        self.series_name = None
+        self._episodes_cache = {}
+
+    def collect_season(self) -> None:
+        """
+        Retrieve all seasons using Crunchyroll API, but NOT episodes.
+        """
+        response = get_series_seasons(self.series_id, self.headers, self.params)
+
+        if response.status_code != 200:
+            logging.error(f"Failed to fetch seasons for series {self.series_id}")
+            return
+
+        # Get the JSON response 
+        data = response.json()
+        seasons = data.get("data", [])
+
+        # Set series name from first season if available
+        if seasons:
+            self.series_name = seasons[0].get("series_title") or seasons[0].get("title")
+
+        for season in seasons:
+            season_num = season.get("season_number", 0)
+            season_name = season.get("title", f"Season {season_num}")
+
+            self.seasons_manager.add_season({
+                'number': season_num,
+                'name': season_name,
+                'id': season.get('id')
+            })
+
+    def _fetch_episodes_for_season(self, season_number: int):
+        """
+        Fetch and cache episodes for a specific season number.
+        """
+        season = self.seasons_manager.get_season_by_number(season_number)
+
+        if not season or getattr(season, 'id', None) is None:
+            logging.error(f"Season {season_number} not found or missing id.")
+            return []
+
+        season_id = season.id
+        ep_response = get_season_episodes(season_id, self.headers, self.params)
+        if ep_response.status_code != 200:
+            logging.error(f"Failed to fetch episodes for season {season_id}")
+            return []
+
+        ep_data = ep_response.json()
+        episodes = ep_data.get("data", [])
+        episode_list = []
+
+        for ep in episodes:
+            ep_num = ep.get("episode_number")
+            ep_title = ep.get("title", f"Episodio {ep_num}")
+            ep_id = ep.get("id")
+            ep_url = f"https://www.crunchyroll.com/watch/{ep_id}"
+            
+            episode_list.append({
+                'number': ep_num,
+                'name': ep_title,
+                'url': ep_url,
+                'duration': int(ep.get('duration_ms', 0) / 60000),
+            })
+            
+        self._episodes_cache[season_number] = episode_list
+        return episode_list
+
+    def _get_episode_audio_locales_and_urls(self, episode_id):
+        """
+        Fetch available audio locales and their URLs for a given episode ID.
+        Returns: (audio_locales, urls_by_locale)
+        """
+        url = f'https://www.crunchyroll.com/content/v2/cms/objects/{episode_id}'
+        headers = self.headers.copy()
+        params = {
+            'ratings': 'true',
+            'locale': 'it-IT',
+        }
+        response = requests.get(
+            url,
+            params=params,
+            headers=headers,
+            impersonate="chrome110"
+        )
+
+        if response.status_code != 200:
+            logging.warning(f"Failed to fetch audio locales for episode {episode_id}")
+            return [], {}
+        
+        data = response.json()
+        try:
+            versions = data["data"][0]['episode_metadata'].get("versions", [])
+
+            audio_locales = []
+            urls_by_locale = {}
+
+            for v in versions:
+                locale = v.get("audio_locale")
+                guid = v.get("guid")
+
+                if locale and guid:
+                    audio_locales.append(locale)
+                    urls_by_locale[locale] = f"https://www.crunchyroll.com/it/watch/{guid}"
+                    #print(f"Locale: {locale}, URL: {urls_by_locale[locale]}")
+
+            return audio_locales, urls_by_locale
+        
+        except Exception as e:
+            logging.error(f"Error parsing audio locales for episode {episode_id}: {e}")
+            return [], {}
+
+    # ------------- 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 (fetches only when needed).
+        """
+        if not self.seasons_manager.seasons:
+            self.collect_season()
+        if season_number not in self._episodes_cache:
+            episodes = self._fetch_episodes_for_season(season_number)
+        else:
+            episodes = self._episodes_cache[season_number]
+        return episodes
+
+    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
+
+        episode = episodes[episode_index]
+        episode_id = episode.get("url", "").split("/")[-1] if "url" in episode else None
+
+        # Update only the episode URL if available in it-IT or en-US
+        _, urls_by_locale = self._get_episode_audio_locales_and_urls(episode_id)
+        new_url = urls_by_locale.get("it-IT") or urls_by_locale.get("en-US")
+
+        if new_url:
+            episode["url"] = new_url
+
+        return episode

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

@@ -0,0 +1,227 @@
+# 28.07.25
+
+import uuid
+from dataclasses import dataclass, field
+from typing import Optional,  Dict, Any
+
+
+# External library
+from curl_cffi.requests import Session
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_userAgent, get_headers
+
+
+# Variable
+device_id = None
+auth_basic = 'bm9haWhkZXZtXzZpeWcwYThsMHE6'
+etp_rt = config_manager.get_dict("SITE_LOGIN", "crunchyroll")['etp_rt']
+x_cr_tab_id = config_manager.get_dict("SITE_LOGIN", "crunchyroll")['x_cr_tab_id']
+
+
+@dataclass
+class Token:
+    access_token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    expires_in: Optional[int] = None
+    token_type: Optional[str] = None
+    scope: Optional[str] = None
+    country: Optional[str] = None
+    account_id: Optional[str] = None
+    profile_id: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Account:
+    account_id: Optional[str] = None
+    external_id: Optional[str] = None
+    email: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class Profile:
+    profile_id: Optional[str] = None
+    email: Optional[str] = None
+    profile_name: Optional[str] = None
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+
+
+def generate_device_id():
+    global device_id
+
+    if device_id is not None:
+        return device_id
+    
+    device_id = str(uuid.uuid4())
+    return device_id
+
+
+def get_auth_token(device_id):
+    with Session(impersonate="chrome110") as session:
+        cookies = {
+            'etp_rt': etp_rt,
+        }
+        response = session.post(
+            'https://www.crunchyroll.com/auth/v1/token',
+            headers={
+                'authorization': f'Basic {auth_basic}',
+                'user-agent': get_userAgent(),
+            },
+            data={
+                'device_id': device_id,
+                'device_type': 'Chrome on Windows',
+                'grant_type': 'etp_rt_cookie',
+            },
+            cookies=cookies
+        )
+        if response.status_code == 400:
+            print("Error 400: Please enter a correct 'etp_rt' value in config.json. You can find the value in the request headers.")
+
+        # Get the JSON response
+        data = response.json()
+        known = {
+            'access_token', 'refresh_token', 'expires_in', 'token_type', 'scope',
+            'country', 'account_id', 'profile_id'
+        }
+        extra = {k: v for k, v in data.items() if k not in known}
+        return Token(
+            access_token=data.get('access_token'),
+            refresh_token=data.get('refresh_token'),
+            expires_in=data.get('expires_in'),
+            token_type=data.get('token_type'),
+            scope=data.get('scope'),
+            country=data.get('country'),
+            account_id=data.get('account_id'),
+            profile_id=data.get('profile_id'),
+            extra=extra
+        )
+
+
+def get_account(token: Token, device_id):
+    with Session(impersonate="chrome110") as session:
+        country = (token.country or "IT")
+        cookies = {
+            'device_id': device_id,
+            'c_locale': f'{country.lower()}-{country.upper()}',
+        }
+        response = session.get(
+            'https://www.crunchyroll.com/accounts/v1/me',
+            headers={
+                'authorization': f'Bearer {token.access_token}',
+                'user-agent': get_userAgent(),
+            },
+            cookies=cookies
+        )
+        response.raise_for_status()
+
+        # Get the JSON response
+        data = response.json()
+        known = {
+            'account_id', 'external_id', 'email'
+        }
+        extra = {k: v for k, v in data.items() if k not in known}
+        return Account(
+            account_id=data.get('account_id'),
+            external_id=data.get('external_id'),
+            email=data.get('email'),
+            extra=extra
+        )
+
+
+def get_profiles(token: Token, device_id):
+    with Session(impersonate="chrome110") as session:
+        country = token.country
+        cookies = {
+            'device_id': device_id,
+            'c_locale': f'{country.lower()}-{country.upper()}',
+        }
+        response = session.get(
+            'https://www.crunchyroll.com/accounts/v1/me/multiprofile',
+            headers={
+                'authorization': f'Bearer {token.access_token}',
+                'user-agent': get_userAgent(),
+            },
+            cookies=cookies
+        )
+        response.raise_for_status()
+
+        # Get the JSON response
+        data = response.json()
+        profiles = []
+        for p in data.get('profiles', []):
+            known = {
+                'profile_id', 'email', 'profile_name'
+            }
+            extra = {k: v for k, v in p.items() if k not in known}
+            profiles.append(Profile(
+                profile_id=p.get('profile_id'),
+                email=p.get('email'),
+                profile_name=p.get('profile_name'),
+                extra=extra
+            ))
+        return profiles
+
+
+def cr_login_session(device_id: str, email: str, password: str):
+    """
+    Esegue una richiesta di login a Crunchyroll SSO usando curl_cffi.requests.
+    """
+    cookies = {
+        'device_id': device_id,
+    }
+    data = (
+        f'{{"email":"{email}","password":"{password}","eventSettings":{{}}}}'
+    )
+    with Session(impersonate="chrome110") as session:
+        response = session.post(
+            'https://sso.crunchyroll.com/api/login',
+            cookies=cookies,
+            headers=get_headers(),
+            data=data
+        )
+        response.raise_for_status()
+        return response
+
+
+def get_playback_session(token: Token, device_id: str, url_id: str):
+    """
+    Crea una sessione per ottenere i dati di playback da Crunchyroll.
+    """
+    cookies = {
+        'device_id': device_id,
+        'etp_rt': etp_rt
+    }
+    headers = {
+        'authorization': f'Bearer {token.access_token}',
+        'user-agent': get_userAgent(),
+        'x-cr-tab-id': x_cr_tab_id
+    }
+
+    with Session(impersonate="chrome110") as session:
+        response = session.get(
+            f'https://www.crunchyroll.com/playback/v3/{url_id}/web/chrome/play',
+            cookies=cookies,
+            headers=headers
+        )
+
+        if (response.status_code == 403):
+            raise Exception("Playback is Rejected: The current subscription does not have access to this content")
+        
+        if (response.status_code == 420):
+            raise Exception("TOO_MANY_ACTIVE_STREAMS. Wait a few minutes and try again.")
+
+        response.raise_for_status()
+
+        # Get the JSON response
+        data = response.json()
+        
+        if data.get('error') == 'Playback is Rejected':
+            raise Exception("Playback is Rejected: Premium required")
+        
+        url = data.get('url')
+        return url, headers

StreamingCommunity/Api/Site/guardaserie/site.py

@@ -59,9 +59,8 @@ def title_search(query: str) -> int:
 
     # Create soup and find table
     soup = BeautifulSoup(response.text, "html.parser")
-    table_content = soup.find('div', class_="recent-posts")
 
-    for serie_div in table_content.find_all('div', class_='post-thumb'):
+    for serie_div in soup.find_all('div', class_='entry'):
         try:
             
             title = serie_div.find('a').get("title")

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

@@ -40,26 +40,27 @@ class GetSerieInfo:
         Retrieves the number of seasons of a TV series.
 
         Returns:
-            int: Number of seasons of the TV series.
+            int: Number of seasons of the TV series. Returns -1 if parsing fails.
         """
         try:
-
             # Make an HTTP request to the series URL
             response = httpx.get(self.url, headers=self.headers, timeout=max_timeout, follow_redirects=True)
             response.raise_for_status()
 
+            # Find the seasons container
             soup = BeautifulSoup(response.text, "html.parser")
-
             table_content = soup.find('div', class_="tt_season")
             seasons_number = len(table_content.find_all("li"))
-            self.tv_name = soup.find("h1", class_="entry-title").get_text(strip=True)
+            
+            # Try to get the title, with fallback
+            title_element = soup.find("h1", class_="entry-title")
+            self.tv_name = title_element.get_text(strip=True) if title_element else "Unknown Title"
 
             return seasons_number
 
         except Exception as e:
-            logging.error(f"Error parsing HTML page: {e}")
-
-        return -1
+            logging.error(f"Error parsing HTML page: {str(e)}")
+            return -1
 
     def get_episode_number(self, n_season: int) -> List[Dict[str, str]]:
         """
@@ -88,7 +89,7 @@ class GetSerieInfo:
             for episode_div in episode_content:
                 index = episode_div.find("a").get("data-num")
                 link = episode_div.find("a").get("data-link")
-                name = episode_div.find("a").get("data-title")
+                name = episode_div.find("a").get("data-num")
 
                 obj_episode = {
                     'number': index,

StreamingCommunity/Api/Site/mediasetinfinity/__init__.py

@@ -0,0 +1,96 @@
+# 21.05.24
+
+
+# External library
+from rich.console import Console
+from rich.prompt import Prompt
+
+
+# Internal utilities
+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
+
+
+# Logic class
+from .site import title_search, table_show_manager, media_search_manager
+from .series import download_series
+from .film import download_film
+
+
+# Variable
+indice = 3
+_useFor = "Film_&_Serie"
+_priority = 0
+_engineDownload = "hls"
+_deprecate = False
+
+msg = Prompt()
+console = Console()
+
+
+def get_user_input(string_to_search: str = None):
+    """
+    Asks the user to input a search term.
+    """
+    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()
+
+    return msg.ask(f"\n[purple]Insert a word to search in [green]{site_constant.SITE_NAME}").strip()
+
+def process_search_result(select_title, selections=None):
+    """
+    Handles the search result and initiates the download for either a film or series.
+    
+    Parameters:
+        select_title (MediaItem): The selected media item
+        selections (dict, optional): Dictionary containing selection inputs that bypass manual input
+                                    {'season': season_selection, 'episode': episode_selection}
+    """
+    if select_title.type == 'tv':
+        season_selection = None
+        episode_selection = None
+        
+        if selections:
+            season_selection = selections.get('season')
+            episode_selection = selections.get('episode')
+
+        download_series(select_title, season_selection, episode_selection)
+
+    else:
+        download_film(select_title)
+
+def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = None, selections: dict = None):
+    """
+    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}
+    """
+    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)
+
+    # 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)
+        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()

StreamingCommunity/Api/Site/mediasetinfinity/film.py

@@ -0,0 +1,76 @@
+# 21.05.24
+
+import os
+from typing import Tuple
+
+
+# External library
+from rich.console import Console
+
+
+# Internal utilities
+from StreamingCommunity.Util.os import os_manager, get_wvd_path
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Lib.Downloader.DASH.downloader import DASH_Download
+
+
+# Logic class
+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
+console = Console()
+
+
+def download_film(select_title: MediaItem) -> Tuple[str, bool]:
+    """
+    Downloads a film using the provided film ID, title name, and domain.
+
+    Parameters:
+        - select_title (MediaItem): The selected media item.
+
+    Return:
+        - str: output path if successful, otherwise None
+    """
+    start_message()
+    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
+
+    # 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", ""))
+
+    # Generate mpd and license URLs
+    bearer = get_bearer_token()
+    playback_json = get_playback_url(bearer, select_title.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=mp4_path,
+    )
+    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']