Fix SeasonManager for "guardaserie"

Author: Arrowar

StreamingCommunity/Api/Site/guardaserie/series.py

@@ -40,14 +40,14 @@
 extension_output = config_manager.get("M3U8_CONVERSION", "extension")
 
 
-def download_video(index_season_selected: int, index_episode_selected: int, scape_info_serie: GetSerieInfo) -> Tuple[str,bool]:
+def download_video(index_season_selected: int, index_episode_selected: int, scrape_serie: GetSerieInfo) -> Tuple[str,bool]:
     """
     Downloads a specific episode from a specified season.
 
     Parameters:
         - index_season_selected (int): Season number
         - index_episode_selected (int): Episode index
-        - scape_info_serie (GetSerieInfo): Scraper object with series information
+        - scrape_serie (GetSerieInfo): Scraper object with series information
 
     Returns:
         - str: Path to downloaded file
@@ -56,13 +56,13 @@ def download_video(index_season_selected: int, index_episode_selected: int, scap
     start_message()
 
     # Get episode information
-    obj_episode = scape_info_serie.selectEpisode(index_season_selected, index_episode_selected-1)
-    index_season_selected = dynamic_format_number(str(index_season_selected))
-    console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{scape_info_serie.tv_name}[/cyan] \\ [bold magenta]{obj_episode.get('name')}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
+    obj_episode = scrape_serie.selectEpisode(index_season_selected, index_episode_selected-1)
+    index_season_selected_formatted = dynamic_format_number(str(index_season_selected))
+    console.print(f"\n[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{scrape_serie.tv_name}[/cyan] \\ [bold magenta]{obj_episode.get('name')}[/bold magenta] ([cyan]S{index_season_selected_formatted}E{index_episode_selected}[/cyan]) \n")
 
     # Define filename and path for the downloaded video
-    mp4_name = f"{map_episode_title(scape_info_serie.tv_name, index_season_selected, index_episode_selected, obj_episode.get('name'))}.{extension_output}"
-    mp4_path = os.path.join(site_constant.SERIES_FOLDER, scape_info_serie.tv_name, f"S{index_season_selected}")
+    mp4_name = f"{map_episode_title(scrape_serie.tv_name, index_season_selected_formatted, index_episode_selected, obj_episode.get('name'))}.{extension_output}"
+    mp4_path = os.path.join(site_constant.SERIES_FOLDER, scrape_serie.tv_name, f"S{index_season_selected_formatted}")
 
     # Setup video source
     video_source = VideoSource(obj_episode.get('url'))
@@ -85,40 +85,38 @@ def download_video(index_season_selected: int, index_episode_selected: int, scap
     return hls_process['path'], hls_process['stopped']
 
 
-def download_episode(scape_info_serie: GetSerieInfo, index_season_selected: int, download_all: bool = False, episode_selection: str = None) -> None:
+def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, download_all: bool = False, episode_selection: str = None) -> None:
     """
     Handle downloading episodes for a specific season.
 
     Parameters:
-        - scape_info_serie (GetSerieInfo): Scraper object with series information
         - index_season_selected (int): Season number
+        - scrape_serie (GetSerieInfo): Scraper object with series information
         - download_all (bool): Whether to download all episodes
         - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
-    # Get episodes for the selected season
-    episodes = scape_info_serie.get_episode_number(index_season_selected)
+    # Get episodes for the selected season using the new method
+    episodes = scrape_serie.getEpisodeSeasons(index_season_selected)
     episodes_count = len(episodes)
 
     if episodes_count == 0:
         console.print(f"[red]No episodes found for season {index_season_selected}")
         return
 
     if download_all:
-        
         # Download all episodes in the season
         for i_episode in range(1, episodes_count + 1):
-            path, stopped = download_video(index_season_selected, i_episode, scape_info_serie)
+            path, stopped = download_video(index_season_selected, i_episode, scrape_serie)
 
             if stopped:
                 break
 
         console.print(f"\n[red]End downloaded [yellow]season: [red]{index_season_selected}.")
 
     else:
-
         # Display episodes list and manage user selection
         if episode_selection is None:
-            last_command = display_episodes_list(scape_info_serie.list_episodes)
+            last_command = display_episodes_list(episodes)
         else:
             last_command = episode_selection
             console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
@@ -129,7 +127,7 @@ def download_episode(scape_info_serie: GetSerieInfo, index_season_selected: int,
 
         # Download selected episodes
         for i_episode in list_episode_select:
-            path, stopped = download_video(index_season_selected, i_episode, scape_info_serie)
+            path, stopped = download_video(index_season_selected, i_episode, scrape_serie)
 
             if stopped:
                 break
@@ -148,7 +146,9 @@ def download_series(dict_serie: MediaItem, season_selection: str = None, episode
 
     # Create class
     scrape_serie = GetSerieInfo(dict_serie)
-    seasons_count = scrape_serie.get_seasons_number()
+    
+    # Get number of seasons
+    seasons_count = scrape_serie.getNumberSeason()
 
     # If season_selection is provided, use it instead of asking for input
     if season_selection is None:
@@ -163,7 +163,19 @@ def download_series(dict_serie: MediaItem, season_selection: str = None, episode
 
     # 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_episode(scrape_serie, i_season, download_all=True)
-        else:
-            download_episode(scrape_serie, i_season, download_all=False, episode_selection=episode_selection)
+        try:
+            season = scrape_serie.seasons_manager.get_season_by_number(i_season)
+            if not season:
+                console.print(f"[red]Season {i_season} not found! Available seasons: {[s.number for s in scrape_serie.seasons_manager.seasons]}")
+                continue
+            
+            season_number = season.number
+
+            if len(list_season_select) > 1 or index_season_selected == "*":
+                download_episode(season_number, scrape_serie, download_all=True)
+            else:
+                download_episode(season_number, scrape_serie, download_all=False, episode_selection=episode_selection)
+                
+        except Exception as e:
+            console.print(f"[red]Error processing season {i_season}: {str(e)}")
+            continue

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

@@ -11,29 +11,29 @@
 # Internal utilities
 from StreamingCommunity.Util.headers import get_userAgent
 from StreamingCommunity.Util.http_client import create_client
+from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
 
 
 # Logic class
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
 
 
-
 class GetSerieInfo:
     def __init__(self, dict_serie: MediaItem) -> None:
         """
         Initializes the GetSerieInfo object with default values.
 
         Parameters:
-            dict_serie (MediaItem): Dictionary containing series information (optional).
+            dict_serie (MediaItem): Dictionary containing series information.
         """
         self.headers = {'user-agent': get_userAgent()}
         self.url = dict_serie.url
         self.tv_name = None
-        self.list_episodes = None
+        self.seasons_manager = SeasonManager()
 
     def get_seasons_number(self) -> int:
         """
-        Retrieves the number of seasons of a TV series.
+        Retrieves the number of seasons of a TV series and populates the seasons_manager.
 
         Returns:
             int: Number of seasons of the TV series. Returns -1 if parsing fails.
@@ -45,20 +45,30 @@ def get_seasons_number(self) -> int:
             # 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"))
+            season_elements = table_content.find_all("li")
 
             # Try to get the title, with fallback
             self.tv_name = soup.find('h1', class_="front_title").get_text(strip=True) if soup.find('h1', class_="front_title") else "Unknown Series"
 
-            return seasons_number
+            # Clear existing seasons and add new ones to SeasonManager
+            self.seasons_manager.seasons = []
+            for idx, season_element in enumerate(season_elements, start=1):
+                self.seasons_manager.add_season({
+                    'id': idx,
+                    'number': idx,
+                    'name': f"Season {idx}",
+                    'slug': f"season-{idx}",
+                })
+
+            return len(season_elements)
 
         except Exception as e:
             logging.error(f"Error parsing HTML page: {str(e)}")
             return -1
 
     def get_episode_number(self, n_season: int) -> List[Dict[str, str]]:
         """
-        Retrieves the number of episodes for a specific season.
+        Retrieves the episodes for a specific season.
 
         Parameters:
             n_season (int): The season number.
@@ -78,6 +88,12 @@ def get_episode_number(self, n_season: int) -> List[Dict[str, str]]:
             episode_content = table_content.find_all("li")
             list_dict_episode = []
 
+            # Get the season from seasons_manager
+            season = self.seasons_manager.get_season_by_number(n_season)
+            
+            if season:
+                season.episodes.episodes = []
+
             for episode_div in episode_content:
                 index = episode_div.find("a").get("data-num")
                 link = episode_div.find("a").get("data-link")
@@ -86,33 +102,47 @@ def get_episode_number(self, n_season: int) -> List[Dict[str, str]]:
                 obj_episode = {
                     'number': index,
                     'name': name,
-                    'url': link
+                    'url': link,
+                    'id': index
                 }
 
                 list_dict_episode.append(obj_episode)
+                
+                # Add episode to the season in seasons_manager
+                if season:
+                    season.episodes.add(obj_episode)
 
-            self.list_episodes = list_dict_episode
             return list_dict_episode
 
         except Exception as e:
             logging.error(f"Error parsing HTML page: {e}")
 
         return []
 
-
     # ------------- FOR GUI -------------
     def getNumberSeason(self) -> int:
         """
         Get the total number of seasons available for the series.
         """
-        return self.get_seasons_number()
+        if not self.seasons_manager.seasons:
+            return self.get_seasons_number()
+        return len(self.seasons_manager.seasons)
 
     def getEpisodeSeasons(self, season_number: int) -> list:
         """
         Get all episodes for a specific season.
         """
-        episodes = self.get_episode_number(season_number)
-        return episodes
+        season = self.seasons_manager.get_season_by_number(season_number)
+        
+        if not season:
+            logging.error(f"Season {season_number} not found")
+            return []
+        
+        # If episodes are not loaded yet, fetch them
+        if not season.episodes.episodes:
+            self.get_episode_number(season_number)
+        
+        return season.episodes.episodes
 
     def selectEpisode(self, season_number: int, episode_index: int) -> dict:
         """