StreamingCommunity 3.4.0__py3-none-any.whl → 3.4.2__py3-none-any.whl

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

@@ -16,13 +16,14 @@ class GetSerieInfo:
         self.base_url = "https://www.raiplay.it"
         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()
+        self.season_block_mapping = {}      # Map season number to block_id
+        self.all_seasons_data = []          # Store all seasons before filtering
 
     def collect_info_title(self) -> None:
-        """Get series info including seasons."""
+        """Get series info including seasons from all multimedia blocks."""
         try:
             program_url = f"{self.base_url}/{self.path_id}"
             response = create_client(headers=get_headers()).get(program_url)
@@ -36,76 +37,118 @@ class GetSerieInfo:
             json_data = response.json()
 
             # 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', '')
+            program_info = json_data.get('program_info', {})
+            self.prog_description = program_info.get('vanity', '') or program_info.get('description', '')
+            self.prog_year = program_info.get('year', '')
+            self.series_name = program_info.get('title', '') or program_info.get('name', '')
+            
+            # Collect all seasons from all multimedia blocks
+            self.all_seasons_data = []
+            blocks_found = {}
             
-            # Look for seasons in the 'blocks' property
             for block in json_data.get('blocks', []):
-
-                # Check if block is a season block or episodi block
-                if block.get('type') == 'RaiPlay Multimedia Block':
-                    if block.get('name', '').lower() == 'episodi':
-                        self.publishing_block_id = block.get('id')
-
-                        # 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', []):
-                            self._add_season(season_set, block.get('id'))
+                block_type = block.get('type', '')
+                block_name = block.get('name', 'N/A')
+                block_id = block.get('id', '')
+                
+                # Only process multimedia blocks with sets
+                if block_type == 'RaiPlay Multimedia Block' and 'sets' in block:
+                    sets = block.get('sets', [])
+                    
+                    for season_set in sets:
+                        episode_size = season_set.get('episode_size', {})
+                        episode_count = episode_size.get('number', 0)
+                        
+                        # Only add sets with episodes
+                        if episode_count > 0:
+                            self.all_seasons_data.append({
+                                'season_set': season_set,
+                                'block_id': block_id,
+                                'block_name': block_name
+                            })
+                            
+                            # Track which blocks we found
+                            if block_name not in blocks_found:
+                                blocks_found[block_name] = 0
+                            blocks_found[block_name] += 1
+            
+            # Add all collected seasons without any filtering (oldest first)
+            for season_data in reversed(self.all_seasons_data):
+                self._add_season(
+                    season_data['season_set'],
+                    season_data['block_id'],
+                    season_data['block_name']
+                )
 
         except Exception as e:
             logging.error(f"Unexpected error collecting series info: {e}")
 
-    def _add_season(self, season_set: dict, block_id: str):
+    def _add_season(self, season_set: dict, block_id: str, block_name: str):
+        """Add a season combining set name and block name."""
+        set_name = season_set.get('name', '')
+        season_number = len(self.seasons_manager.seasons) + 1
+        
+        # Store block_id mapping
+        self.season_block_mapping[season_number] = {
+            'block_id': block_id,
+            'set_id': season_set.get('id', '')
+        }
+        
         self.seasons_manager.add_season({
             'id': season_set.get('id', ''),
-            'number': len(self.seasons_manager.seasons) + 1,
-            'name': season_set.get('name', ''),
-            'path': season_set.get('path_id', ''),
-            'episodes_count': season_set.get('episode_size', {}).get('number', 0)
+            'number': season_number,
+            'name': set_name,
+            #'episodes_count': season_set.get('episode_size', {}).get('number', 0),
+            'type': block_name
         })
 
     def collect_info_season(self, number_season: int) -> None:
-        """Get episodes for a specific season."""
+        """Get episodes for a specific season using episodes.json endpoint."""
         try:
             season = self.seasons_manager.get_season_by_number(number_season)
-
-            # Se stai leggendo questo codice spieami perche hai fatto cosi.
-            url = f"{self.base_url}/{self.path_id.replace('.json', '')}/{self.publishing_block_id}/{season.id}/episodes.json"
+            block_info = self.season_block_mapping[number_season]
+            block_id = block_info['block_id']
+            set_id = block_info['set_id']
+            
+            # Build episodes endpoint URL
+            base_path = self.path_id.replace('.json', '')
+            url = f"{self.base_url}/{base_path}/{block_id}/{set_id}/episodes.json"
+            
             response = create_client(headers=get_headers()).get(url)
             response.raise_for_status()
             
             episodes_data = response.json()
-            cards = []
             
-            # Extract episodes from different possible structures 
-            if 'seasons' in episodes_data:
-                for season_data in episodes_data.get('seasons', []):
-                    for episode_set in season_data.get('episodes', []):
-                        cards.extend(episode_set.get('cards', []))
+            # Navigate nested structure to find cards
+            cards = []
+            seasons = episodes_data.get('seasons', [])
+            if seasons:
+                for season_data in seasons:
+                    episodes = season_data.get('episodes', [])
+                    for episode in episodes:
+                        cards.extend(episode.get('cards', []))
             
+            # Fallback to direct cards if nested structure not found
             if not cards:
                 cards = episodes_data.get('cards', [])
 
             # Add episodes to season
             for ep in cards:
+                video_url = ep.get('video_url', '')
+                mpd_id = ''
+                if video_url and '=' in video_url:
+                    mpd_id = video_url.split("=")[1].strip()
+                
+                weblink = ep.get('weblink', '') or ep.get('url', '')
+                episode_url = f"{self.base_url}{weblink}" if weblink else ''
+                
                 episode = {
                     'id': ep.get('id', ''),
                     'number': ep.get('episode', ''),
-                    'name': ep.get('episode_title', '') or ep.get('toptitle', ''),
-                    'duration': ep.get('duration', ''),
-                    'url': f"{self.base_url}{ep.get('weblink', '')}" if 'weblink' in ep else f"{self.base_url}{ep.get('url', '')}",
-                    'mpd_id': ep.get('video_url').split("=")[1].strip()
+                    'name': ep.get('episode_title', '') or ep.get('name', '') or ep.get('toptitle', ''),
+                    'duration': ep.get('duration', '') or ep.get('duration_in_minutes', ''),
+                    'url': episode_url,
+                    'mpd_id': mpd_id
                 }
                 season.episodes.add(episode)
 

StreamingCommunity/Api/Site/streamingcommunity/series.py

@@ -21,7 +21,8 @@ from StreamingCommunity.Api.Template.Util import (
     map_episode_title, 
     validate_selection, 
     validate_episode_selection, 
-    display_episodes_list
+    display_episodes_list,
+    display_seasons_list
 )
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
@@ -166,9 +167,6 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
     if site_constant.TELEGRAM_BOT:
         bot = get_bot_instance()
 
-    # 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:
         if site_constant.TELEGRAM_BOT:
@@ -188,10 +186,8 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
             )
 
         else:
-            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"
-            )
+            index_season_selected = display_seasons_list(scrape_serie.seasons_manager)
+
     else:
         index_season_selected = season_selection
         console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
@@ -211,7 +207,6 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
 
         if len(list_season_select) > 1 or index_season_selected == "*":
             download_episode(season_number, scrape_serie, video_source, download_all=True)
-            
         else:
             download_episode(season_number, scrape_serie, video_source, download_all=False, episode_selection=episode_selection)
 
@@ -221,4 +216,4 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
         # Get script_id
         script_id = TelegramSession.get_session()
         if script_id != "unknown":
-            TelegramSession.deleteScriptId(script_id)
+            TelegramSession.deleteScriptId(script_id)

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

@@ -64,7 +64,6 @@ class GetSerieInfo:
                     'number': season_data.get('number', 0),
                     'name': f"Season {season_data.get('number', 0)}",
                     'slug': season_data.get('slug', ''),
-                    'type': title_data.get('type', '')
                 })
 
         except Exception as e:

StreamingCommunity/Api/Site/streamingwatch/series.py

@@ -21,7 +21,8 @@ from StreamingCommunity.Api.Template.Util import (
     map_episode_title,
     validate_selection, 
     validate_episode_selection, 
-    display_episodes_list
+    display_episodes_list,
+    display_seasons_list
 )
 from StreamingCommunity.Api.Template.config_loader import site_constant
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
@@ -134,20 +135,11 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
         - 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"
-        )
-
+        index_season_selected = display_seasons_list(scrape_serie.seasons_manager)
     else:
         index_season_selected = season_selection
         console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
@@ -159,8 +151,6 @@ def download_series(select_season: MediaItem, season_selection: str = None, epis
     # 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/Template/Util/__init__.py

@@ -6,7 +6,8 @@ from .manage_ep import (
     validate_episode_selection, 
     validate_selection, 
     dynamic_format_number,
-    display_episodes_list
+    display_episodes_list,
+    display_seasons_list
 )
 
 __all__ = [
@@ -15,5 +16,6 @@ __all__ = [
     "validate_episode_selection",
     "validate_selection",
     "dynamic_format_number",
-    "display_episodes_list"
+    "display_episodes_list",
+    display_seasons_list
 ]

StreamingCommunity/Api/Template/Util/manage_ep.py

@@ -1,6 +1,7 @@
 # 19.06.24
 
 import sys
+import time
 import logging
 from typing import List
 
@@ -209,6 +210,71 @@ def validate_episode_selection(list_episode_select: List[int], episodes_count: i
             list_episode_select = list(map(int, input_episodes.split(',')))
 
 
+def display_seasons_list(seasons_manager) -> str:
+    """
+    Display seasons list and handle user input.
+
+    Parameters:
+        - seasons_manager: Manager object containing seasons information.
+
+    Returns:
+        last_command (str): Last command entered by the user.
+    """
+    if len(seasons_manager.seasons) == 1:
+        console.print("\n[green]Only one season available, selecting it automatically[/green]")
+        time.sleep(1)
+        return "1"
+    
+    # Set up table for displaying seasons
+    table_show_manager = TVShowManager()
+
+    # Check if 'type' and 'id' attributes exist in the first season
+    has_type = hasattr(seasons_manager.seasons[0], 'type') and (seasons_manager.seasons[0].type) is not None and str(seasons_manager.seasons[0].type) != ''
+    has_id = hasattr(seasons_manager.seasons[0], 'id') and (seasons_manager.seasons[0].id) is not None and str(seasons_manager.seasons[0].id) != ''
+
+    # Add columns to the table
+    column_info = {
+        "Index": {'color': 'red'},
+        "Name": {'color': 'yellow'}
+    }
+
+    if has_type:
+        column_info["Type"] = {'color': 'magenta'}
+    
+    if has_id:
+        column_info["ID"] = {'color': 'cyan'}
+
+    table_show_manager.add_column(column_info)
+
+    # Populate the table with seasons information
+    for i, season in enumerate(seasons_manager.seasons):
+        season_name = season.name if hasattr(season, 'name') else 'N/A'
+        season_info = {
+            'Index': str(i + 1),
+            'Name': season_name
+        }
+
+        # Add 'Type' and 'ID' if they exist
+        if has_type:
+            season_type = season.type if hasattr(season, 'type') else 'N/A'
+            season_info['Type'] = season_type
+        
+        if has_id:
+            season_id = season.id if hasattr(season, 'id') else 'N/A'
+            season_info['ID'] = season_id
+
+        table_show_manager.add_tv_show(season_info)
+
+    # Run the table and handle user input
+    last_command = table_show_manager.run()
+
+    if last_command in ("q", "quit"):
+        console.print("\n[red]Quit ...")
+        sys.exit(0)
+
+    return last_command
+
+
 def display_episodes_list(episodes_manager) -> str:
     """
     Display episodes list and handle user input.

StreamingCommunity/Lib/Downloader/DASH/downloader.py

@@ -2,11 +2,12 @@
 
 import os
 import shutil
+import logging
+from typing import Optional, Dict
 
 
 # External libraries
 from rich.console import Console
-from rich.panel import Panel
 from rich.table import Table
 
 
@@ -73,6 +74,10 @@ class DASH_Downloader:
         self.error = None
         self.stopped = False
         self.output_file = None
+        
+        # For progress tracking
+        self.current_downloader: Optional[MPD_Segments] = None
+        self.current_download_type: Optional[str] = None
 
     def _setup_temp_dirs(self):
         """
@@ -269,6 +274,10 @@ class DASH_Downloader:
                     pssh=self.parser.pssh
                 )
 
+                # Set current downloader for progress tracking
+                self.current_downloader = video_downloader
+                self.current_download_type = 'video'
+
                 try:
                     result = video_downloader.download_streams(description="Video")
                     
@@ -288,6 +297,10 @@ class DASH_Downloader:
                 except Exception as ex:
                     self.error = str(ex)
                     return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
 
                 # Decrypt video
                 decrypted_path = os.path.join(self.decrypted_dir, "video.mp4")
@@ -321,6 +334,10 @@ class DASH_Downloader:
                     limit_segments=video_segments_count if video_segments_count > 0 else None
                 )
 
+                # Set current downloader for progress tracking
+                self.current_downloader = audio_downloader
+                self.current_download_type = f"audio_{audio_language}"
+
                 try:
                     result = audio_downloader.download_streams(description=f"Audio {audio_language}")
 
@@ -337,6 +354,10 @@ class DASH_Downloader:
                 except Exception as ex:
                     self.error = str(ex)
                     return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
 
                 # Decrypt audio
                 decrypted_path = os.path.join(self.decrypted_dir, "audio.mp4")
@@ -385,6 +406,10 @@ class DASH_Downloader:
                     pssh=self.parser.pssh
                 )
                 
+                # Set current downloader for progress tracking
+                self.current_downloader = video_downloader
+                self.current_download_type = 'video'
+                
                 try:
                     result = video_downloader.download_streams(description="Video")
                     
@@ -405,6 +430,10 @@ class DASH_Downloader:
                     self.error = str(ex)
                     console.print(f"[red]Error downloading video: {ex}[/red]")
                     return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
             
             # NO DECRYPTION: just copy/move to decrypted folder
             decrypted_path = os.path.join(self.decrypted_dir, "video.mp4")
@@ -432,6 +461,10 @@ class DASH_Downloader:
                     limit_segments=video_segments_count if video_segments_count > 0 else None
                 )
                 
+                # Set current downloader for progress tracking
+                self.current_downloader = audio_downloader
+                self.current_download_type = f"audio_{audio_language}"
+                
                 try:
                     result = audio_downloader.download_streams(description=f"Audio {audio_language}")
                     
@@ -449,6 +482,10 @@ class DASH_Downloader:
                     self.error = str(ex)
                     console.print(f"[red]Error downloading audio: {ex}[/red]")
                     return False
+                
+                finally:
+                    self.current_downloader = None
+                    self.current_download_type = None
             
             # NO DECRYPTION: just copy/move to decrypted folder
             decrypted_path = os.path.join(self.decrypted_dir, "audio.mp4")
@@ -542,20 +579,7 @@ class DASH_Downloader:
         if os.path.exists(output_file):
             file_size = internet_manager.format_file_size(os.path.getsize(output_file))
             duration = print_duration_table(output_file, description=False, return_string=True)
-
-            panel_content = (
-                f"[cyan]File size: [bold red]{file_size}[/bold red]\n"
-                f"[cyan]Duration: [bold]{duration}[/bold]\n"
-                f"[cyan]Output: [bold]{os.path.abspath(output_file)}[/bold]"
-            )
-
-            print("")
-            console.print(Panel(
-                panel_content,
-                title=f"{os.path.basename(output_file.replace('.mp4', ''))}",
-                border_style="green"
-            ))
-
+            console.print(f"[yellow]Output [red]{os.path.abspath(output_file)} [cyan]with size [red]{file_size} [cyan]and duration [red]{duration}")
         else:
             console.print(f"[red]Output file not found: {output_file}")
 
@@ -591,4 +615,19 @@ class DASH_Downloader:
             "path": self.output_file,
             "error": self.error,
             "stopped": self.stopped
-        }
+        }
+    
+    def get_progress_data(self) -> Optional[Dict]:
+        """Get current download progress data."""
+        if not self.current_downloader:
+            return None
+
+        try:
+            progress = self.current_downloader.get_progress_data()
+            if progress:
+                progress['download_type'] = self.current_download_type
+            return progress
+            
+        except Exception as e:
+            logging.error(f"Error getting progress data: {e}")
+            return None