StreamingCommunity 3.3.7__py3-none-any.whl → 3.3.9__py3-none-any.whl

StreamingCommunity/Api/Player/supervideo.py

@@ -42,7 +42,7 @@ class VideoSource:
             - str: The response content if successful, None otherwise.
         """
         try:
-            response = requests.get(url, headers=self.headers, timeout=MAX_TIMEOUT, impersonate="chrome110", verify=REQUEST_VERIFY)
+            response = requests.get(url, headers=self.headers, timeout=MAX_TIMEOUT, impersonate="chrome136", verify=REQUEST_VERIFY)
             if response.status_code >= 400:
                 logging.error(f"Request failed with status code: {response.status_code}")
                 return None

StreamingCommunity/Api/Site/animeunity/serie.py

@@ -104,7 +104,7 @@ def download_series(select_title: MediaItem, season_selection: str = None, episo
 
     # Get episode information
     episoded_count = scrape_serie.get_count_episodes()
-    console.print(f"[green]Episodes count:[/green] [red]{episoded_count}[/red]")
+    console.print(f"\n[green]Episodes count:[/green] [red]{episoded_count}[/red]")
     
     # Telegram bot integration
     if episode_selection is None:

StreamingCommunity/Api/Site/animeworld/serie.py

@@ -84,7 +84,7 @@ def download_series(select_title: MediaItem, episode_selection: str = None):
     episodes = scrape_serie.get_episodes() 
 
     # Get episode count
-    console.print(f"[green]Episodes found:[/green] [red]{len(episodes)}[/red]")
+    console.print(f"\n[green]Episodes count:[/green] [red]{len(episodes)}[/red]")
 
     # Display episodes list and get user selection
     if episode_selection is None:

StreamingCommunity/Api/Site/crunchyroll/film.py

@@ -21,7 +21,7 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
 
 # Player
 from StreamingCommunity import DASH_Downloader
-from .util.get_license import get_playback_session, get_auth_token, generate_device_id
+from .util.get_license import get_playback_session, CrunchyrollClient
 
 
 # Variable
@@ -42,14 +42,19 @@ def download_film(select_title: MediaItem) -> str:
     start_message()
     console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
 
+    # Initialize Crunchyroll client
+    client = CrunchyrollClient()
+    if not client.start():
+        console.print("[bold red]Failed to authenticate with Crunchyroll.[/bold red]")
+        return None, True
+
     # Define filename and path for the downloaded video
     mp4_name = os_manager.get_sanitize_file(select_title.name) + ".mp4"
     mp4_path = os.path.join(site_constant.MOVIE_FOLDER, mp4_name.replace(".mp4", ""))
 
     # Generate mpd and license URLs
     url_id = select_title.get('url').split('/')[-1]
-    device_id = generate_device_id()
-    mpd_url, mpd_headers, mpd_list_sub = get_playback_session(get_auth_token(device_id), device_id, url_id)
+    mpd_url, mpd_headers, mpd_list_sub = get_playback_session(client, url_id)
     parsed_url = urlparse(mpd_url)
     query_params = parse_qs(parsed_url.query)
 
@@ -82,4 +87,9 @@ def download_film(select_title: MediaItem) -> str:
         except Exception: 
             pass
 
+    # Delete stream after download
+    token = query_params['playbackGuid'][0]
+    if token:
+        client.delete_active_stream(url_id, token)
+
     return status['path'], status['stopped']

StreamingCommunity/Api/Site/crunchyroll/series.py

@@ -16,7 +16,7 @@ from StreamingCommunity.Util.os import os_manager, get_wvd_path
 
 
 # Logic class
-from .util.ScrapeSerie import GetSerieInfo, delete_stream_episode
+from .util.ScrapeSerie import GetSerieInfo
 from StreamingCommunity.Api.Template.Util import (
     manage_selection, 
     map_episode_title,
@@ -30,7 +30,7 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
 
 # Player
 from StreamingCommunity import DASH_Downloader
-from .util.get_license import get_playback_session, get_auth_token, generate_device_id
+from .util.get_license import get_playback_session
 
 
 # Variable
@@ -52,6 +52,7 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
         - bool: Whether download was stopped
     """
     start_message()
+    client = scrape_serie.client
 
     # Get episode information
     obj_episode = scrape_serie.selectEpisode(index_season_selected, index_episode_selected-1)
@@ -64,10 +65,8 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
 
     # Generate mpd and license URLs
     url_id = obj_episode.get('url').split('/')[-1]
-    device_id = generate_device_id()
-    token_mpd = get_auth_token(device_id)
     
-    mpd_url, mpd_headers, mpd_list_sub = get_playback_session(token_mpd, device_id, url_id)
+    mpd_url, mpd_headers, mpd_list_sub = get_playback_session(client, url_id)
     parsed_url = urlparse(mpd_url)
     query_params = parse_qs(parsed_url.query)
 
@@ -101,7 +100,8 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
             pass
 
     # Delete episode stream
-    delete_stream_episode(url_id, query_params['playbackGuid'][0], mpd_headers)
+    token = query_params['playbackGuid'][0]
+    client.delete_active_stream(url_id, token)
 
     return status['path'], status['stopped']
 

StreamingCommunity/Api/Site/crunchyroll/site.py

@@ -10,14 +10,13 @@ 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
 
 
 # Logic class
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
-from .util.get_license import get_auth_token, generate_device_id
+from .util.get_license import CrunchyrollClient
 
 
 # Variable
@@ -40,9 +39,16 @@ def title_search(query: str) -> int:
     media_search_manager.clear()
     table_show_manager.clear()
 
-    # Check if x_cr_tab_id or etp_rt is present
-    if config_manager.get_dict("SITE_LOGIN", "crunchyroll")['x_cr_tab_id'] is None or config_manager.get_dict("SITE_LOGIN", "crunchyroll")['x_cr_tab_id'] == "" or config_manager.get_dict("SITE_LOGIN", "crunchyroll")['etp_rt'] is None or config_manager.get_dict("SITE_LOGIN", "crunchyroll")['etp_rt'] == "":
-        console.print("[bold red] x_cr_tab_id or etp_rt is missing or empty.[/bold red]")
+    # Check if device_id or etp_rt is present
+    config = config_manager.get_dict("SITE_LOGIN", "crunchyroll")
+    if not config.get('device_id') or not config.get('etp_rt'):
+        console.print("[bold red] device_id or etp_rt is missing or empty in config.json.[/bold red]")
+        sys.exit(0)
+
+    # Initialize Crunchyroll client
+    client = CrunchyrollClient()
+    if not client.start():
+        console.print("[bold red] Failed to authenticate with Crunchyroll.[/bold red]")
         sys.exit(0)
 
     # Build new Crunchyroll API search URL
@@ -57,8 +63,7 @@ def title_search(query: str) -> int:
         "locale": "it-IT"
     }
 
-    headers = get_headers()
-    headers['authorization'] = f"Bearer {get_auth_token(generate_device_id()).access_token}"
+    headers = client._get_headers()
 
     console.print(f"[cyan]Search url: [yellow]{api_url}")
 
@@ -68,7 +73,7 @@ def title_search(query: str) -> int:
             params=params,
             headers=headers,
             timeout=max_timeout,
-            impersonate="chrome110"
+            impersonate="chrome136"
         )
         response.raise_for_status()
 

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

@@ -8,10 +8,9 @@ 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
+from .get_license import CrunchyrollClient
 
 
 # Variable
@@ -27,7 +26,7 @@ def get_series_seasons(series_id, headers, params):
         url,
         params=params,
         headers=headers,
-        impersonate="chrome110"
+        impersonate="chrome136"
     )
     return response
 
@@ -41,30 +40,10 @@ def get_season_episodes(season_id, headers, params):
         url,
         params=params,
         headers=headers,
-        impersonate="chrome110"
+        impersonate="chrome136"
     )
     return response
 
-def delete_stream_episode(episode_id, stream_id, headers):
-    """
-    Deletes a specific stream episode by episode ID and stream ID.
-    """
-    url = f'https://www.crunchyroll.com/playback/v1/token/{episode_id}/{stream_id}'
-    headers = get_headers()
-    
-    response = requests.delete(
-        url,
-        headers=headers,
-        impersonate="chrome110"
-    )
-    
-    if response.status_code == 204:
-        return True
-    
-    else:
-        logging.error(f"Failed to delete stream episode: {response.status_code} - {response.text}")
-        return False
-
 
 class GetSerieInfo:
     def __init__(self, series_id):
@@ -76,8 +55,13 @@ class GetSerieInfo:
         """
         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}"
+        
+        # Initialize Crunchyroll client
+        self.client = CrunchyrollClient()
+        if not self.client.start():
+            raise Exception("Failed to authenticate with Crunchyroll")
+        
+        self.headers = self.client._get_headers()
         self.params = {
             'force_locale': '',
             'preferred_audio_language': 'it-IT',
@@ -104,13 +88,10 @@ class GetSerieInfo:
         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}")
-
+        for i, season in enumerate(seasons, start=1):
             self.seasons_manager.add_season({
-                'number': season_num,
-                'name': season_name,
+                'number': i,
+                'name': season.get("title", f"Season {i}"),
                 'id': season.get('id')
             })
 
@@ -119,15 +100,10 @@ class GetSerieInfo:
         Fetch and cache episodes for a specific season number.
         """
         season = self.seasons_manager.get_season_by_number(season_number)
+        ep_response = get_season_episodes(season.id, self.headers, self.params)
 
-        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}")
+            logging.error(f"Failed to fetch episodes for season {season.id}")
             return []
 
         ep_data = ep_response.json()
@@ -165,7 +141,7 @@ class GetSerieInfo:
             url,
             params=params,
             headers=headers,
-            impersonate="chrome110"
+            impersonate="chrome136"
         )
 
         if response.status_code != 200:
@@ -186,7 +162,6 @@ class GetSerieInfo:
                 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
         

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

@@ -1,12 +1,7 @@
 # 28.07.25
 
-import uuid
-from dataclasses import dataclass, field
-from typing import Optional,  Dict, Any
-
-
-# External library
-from curl_cffi.requests import Session
+from typing import Tuple, List, Dict
+from curl_cffi import requests
 
 
 # Internal utilities
@@ -15,119 +10,130 @@ from StreamingCommunity.Util.headers import get_userAgent
 
 
 # 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)
-
+PUBLIC_TOKEN = "bm9haWhkZXZtXzZpeWcwYThsMHE6"
 
 
-def generate_device_id():
-    global device_id
-
-    if device_id is not None:
-        return device_id
-    
-    device_id = str(uuid.uuid4())
-    return device_id
-
+class CrunchyrollClient:
+    def __init__(self) -> None:
+        config = config_manager.get_dict("SITE_LOGIN", "crunchyroll")
+        self.device_id = config.get('device_id')
+        self.etp_rt = config.get('etp_rt')
+        self.locale = "it-IT"
+        
+        self.access_token = None
+        self.refresh_token = None
+        self.account_id = None
 
-def get_auth_token(device_id):
-    with Session(impersonate="chrome110") as session:
-        cookies = {
-            'etp_rt': etp_rt,
+    def _get_headers(self) -> Dict:
+        headers = {
+            'user-agent': get_userAgent(),
         }
-        response = session.post(
+        if self.access_token:
+            headers['authorization'] = f'Bearer {self.access_token}'
+        return headers
+    
+    def _get_cookies(self) -> Dict:
+        cookies = {'device_id': self.device_id}
+        if self.etp_rt:
+            cookies['etp_rt'] = self.etp_rt
+        return cookies
+
+    def start(self) -> bool:
+        """Autorizza il client"""
+        headers = self._get_headers()
+        headers['authorization'] = f'Basic {PUBLIC_TOKEN}'
+        headers['content-type'] = 'application/x-www-form-urlencoded'
+        
+        response = requests.post(
             'https://www.crunchyroll.com/auth/v1/token',
-            headers={
-                'authorization': f'Basic {auth_basic}',
-                'user-agent': get_userAgent(),
-            },
+            cookies=self._get_cookies(),
+            headers=headers,
             data={
-                'device_id': device_id,
+                'device_id': self.device_id,
                 'device_type': 'Chrome on Windows',
                 'grant_type': 'etp_rt_cookie',
             },
-            cookies=cookies
+            impersonate="chrome136"
         )
+        
         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_playback_session(token: Token, device_id: str, url_id: str):
-    """
-    Crea una sessione per ottenere i dati di playback e sottotitoli 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
+            return False
+            
+        result = response.json()
+        self.access_token = result.get('access_token')
+        self.refresh_token = result.get('refresh_token')
+        self.account_id = result.get('account_id')
+        
+        return True
+
+    def get_streams(self, media_id: str) -> Dict:
+        """Ottieni gli stream disponibili"""
+        response = requests.get(
+            f'https://www.crunchyroll.com/playback/v3/{media_id}/web/chrome/play',
+            cookies=self._get_cookies(),
+            headers=self._get_headers(),
+            params={'locale': self.locale},
+            impersonate="chrome136"
         )
-
-        if (response.status_code == 403):
+        
+        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):
+        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')
-        
-        subtitles = []
-        if 'subtitles' in data:
-            subtitles = [
-                {'language': lang, 'url': info['url'], 'format': info.get('format')}
-                for lang, info in data['subtitles'].items()
-            ]
-        
-        return url, headers, subtitles
+        return data
+
+    def delete_active_stream(self, media_id: str, token: str) -> bool:
+        """Elimina uno stream attivo"""
+        response = requests.delete(
+            f'https://www.crunchyroll.com/playback/v1/token/{media_id}/{token}',
+            cookies=self._get_cookies(),
+            headers=self._get_headers(),
+            impersonate="chrome136"
+        )
+        response.raise_for_status()
+        return response.status_code in [200, 204]
+
+
+def get_playback_session(client: CrunchyrollClient, url_id: str) -> Tuple[str, Dict, List[Dict]]:
+    """
+    Return the playback session details including the MPD URL, headers, and subtitles.
+    
+    Parameters:
+        - client: Instance of CrunchyrollClient
+        - url_id: ID of the media to fetch
+    """
+    data = client.get_streams(url_id)
+    url = data.get('url')
+    
+    # Collect subtitles if available
+    subtitles = []
+    if 'subtitles' in data:
+        collected = []
+        for lang, info in data['subtitles'].items():
+            sub_url = info.get('url')
+
+            if not sub_url:
+                continue
+            
+            collected.append({
+                'language': lang, 
+                'url': sub_url, 
+                'format': info.get('format')
+            })
+
+        if collected:
+            subtitles = collected
+    
+    # Return the MPD URL, headers, and subtitles
+    headers = client._get_headers()
+    return url, headers, subtitles

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

@@ -79,7 +79,7 @@ class MediasetAPI:
         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)
+        return list(pairs.keys())[-5]
 
     def generate_request_headers(self):
         return {

StreamingCommunity/Api/Site/raiplay/series.py

@@ -166,16 +166,7 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
         - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
     start_message()
-
-    # Extract program name from path_id
-    program_name = None
-    if select_season.path_id:
-        parts = select_season.path_id.strip('/').split('/')
-        if len(parts) >= 2:
-            program_name = parts[-1].split('.')[0]
-
-    # Init scraper
-    scrape_serie = GetSerieInfo(program_name)
+    scrape_serie = GetSerieInfo(select_season.path_id)
 
     # Get seasons info
     scrape_serie.collect_info_title()

StreamingCommunity/Api/Site/raiplay/site.py

@@ -30,24 +30,13 @@ def determine_media_type(item):
     using GetSerieInfo.
     """
     try:
-        # Extract program name from path_id
-        program_name = None
-        if item.get('path_id'):
-            parts = item['path_id'].strip('/').split('/')
-            if len(parts) >= 2:
-                program_name = parts[-1].split('.')[0]
-
-        if not program_name:
-            return "film"
-
-        # Dio stranamente guarda che giro bisogna fare per avere il tipo di media.
-        scraper = GetSerieInfo(program_name)
+        scraper = GetSerieInfo(item.get('path_id'))
         scraper.collect_info_title()
         return scraper.prog_tipology, scraper.prog_description, scraper.prog_year
     
     except Exception as e:
         console.print(f"[red]Error determining media type: {e}[/red]")
-        return "film"
+        return None, None, None
 
 
 def title_search(query: str) -> int:
@@ -97,6 +86,9 @@ def title_search(query: str) -> int:
     # Process each item and add to media manager
     for item in data:
         media_type, prog_description, prog_year = determine_media_type(item)
+        if media_type is None:
+            continue
+
         media_search_manager.add_media({
             'id': item.get('id', ''),
             'name': item.get('titolo', ''),

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

@@ -18,12 +18,12 @@ max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
 class GetSerieInfo:
-    def __init__(self, program_name: str):
+    def __init__(self, path_id: str):
         """Initialize the GetSerieInfo class."""
         self.base_url = "https://www.raiplay.it"
-        self.program_name = program_name
-        self.series_name = program_name
-        self.prog_tipology = None
+        self.path_id = path_id
+        self.series_name = None
+        self.prog_tipology = "film"
         self.prog_description = None
         self.prog_year = None
         self.seasons_manager = SeasonManager()
@@ -31,24 +31,21 @@ class GetSerieInfo:
     def collect_info_title(self) -> None:
         """Get series info including seasons."""
         try:
-            program_url = f"{self.base_url}/programmi/{self.program_name}.json"
+            program_url = f"{self.base_url}/{self.path_id}"
             response = httpx.get(url=program_url, headers=get_headers(), timeout=max_timeout)
             
             # If 404, content is not yet available
             if response.status_code == 404:
-                logging.info(f"Content not yet available: {self.program_name}")
+                logging.info(f"Content not yet available: {program_url}")
                 return
                 
             response.raise_for_status()
             json_data = response.json()
 
-            # 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
+            # Get basic program info
             self.prog_description = json_data.get('program_info', '').get('vanity', '')
             self.prog_year = json_data.get('program_info', '').get('year', '')
+            self.series_name = json_data.get('program_info', '').get('title', '')
             
             # Look for seasons in the 'blocks' property
             for block in json_data.get('blocks', []):
@@ -60,11 +57,14 @@ class GetSerieInfo:
 
                         # Extract seasons from sets array
                         for season_set in block.get('sets', []):
+                            self.prog_tipology = "tv"
+
                             if 'stagione' in season_set.get('name', '').lower():
                                 self._add_season(season_set, block.get('id'))
                                 
                     elif 'stagione' in block.get('name', '').lower():
                         self.publishing_block_id = block.get('id')
+                        self.prog_tipology = "tv"
 
                         # Extract season directly from block's sets
                         for season_set in block.get('sets', []):
@@ -88,7 +88,7 @@ class GetSerieInfo:
             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"
+            url = f"{self.base_url}/{self.path_id.replace(".json", "")}/{self.publishing_block_id}/{season.id}/episodes.json"
             response = httpx.get(url=url, headers=get_headers(), timeout=max_timeout)
             response.raise_for_status()