StreamingCommunity 2.9.7__py3-none-any.whl → 2.9.9__py3-none-any.whl

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

@@ -47,7 +47,6 @@ class GetSerieInfo:
         Returns:
             List[Dict[str, str]]: List of dictionaries containing episode information.
         """
-
         try:
             response = httpx.get(f"{self.url}?area=online", cookies=self.cookies, headers=self.headers, timeout=max_timeout)
             response.raise_for_status()
@@ -81,4 +80,33 @@ class GetSerieInfo:
      
         self.list_episodes = list_dict_episode
         return list_dict_episode
-        
+    
+    
+    # ------------- FOR GUI -------------
+    def getNumberSeason(self) -> int:
+        """
+        Get the total number of seasons available for the series.
+        Note: DDLStreamItaly typically provides content organized as threads, not seasons.
+        """
+        return 1
+    
+    def getEpisodeSeasons(self, season_number: int = 1) -> list:
+        """
+        Get all episodes for a specific season.
+        Note: For DDLStreamItaly, this returns all episodes as they're typically in one list.
+        """     
+        if not self.list_episodes:
+            self.list_episodes = self.get_episode_number()
+            
+        return self.list_episodes
+        
+    def selectEpisode(self, season_number: int = 1, episode_index: int = 0) -> dict:
+        """
+        Get information for a specific episode.
+        """
+        episodes = self.getEpisodeSeasons()
+        if not episodes or episode_index < 0 or episode_index >= len(episodes):
+            logging.error(f"Episode index {episode_index} is out of range")
+            return None
+            
+        return episodes[episode_index]

StreamingCommunity/Api/Site/guardaserie/__init__.py

@@ -30,24 +30,38 @@ msg = Prompt()
 console = Console()
 
 
-def process_search_result(select_title):
+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}
     """
-    download_series(select_title)
+    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)
 
-def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = None):
+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 film, series and anime.
+    Main function of the application for search.
 
     Parameters:
         string_to_search (str, optional): String to search for
-        get_onylDatabase (bool, optional): If True, return only the database object
+        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)
+        process_search_result(select_title, selections)
         return
 
     if string_to_search is None:
@@ -62,7 +76,7 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
 
     if len_database > 0:
         select_title = get_select_title(table_show_manager, media_search_manager)
-        process_search_result(select_title)
+        process_search_result(select_title, selections)
 
     else:
 

StreamingCommunity/Api/Site/guardaserie/series.py

@@ -1,6 +1,7 @@
 # 13.06.24
 
 import os
+import logging
 from typing import Tuple
 
 
@@ -39,22 +40,22 @@ console = Console()
 
 def download_video(index_season_selected: int, index_episode_selected: int, scape_info_serie: GetSerieInfo) -> Tuple[str,bool]:
     """
-    Download a single episode video.
+    Downloads a specific episode from a specified season.
 
     Parameters:
-        - tv_name (str): Name of the TV series.
-        - index_season_selected (int): Index of the selected season.
-        - index_episode_selected (int): Index of the selected episode.
+        - index_season_selected (int): Season number
+        - index_episode_selected (int): Episode index
+        - scape_info_serie (GetSerieInfo): Scraper object with series information
 
-    Return:
-        - str: output path
-        - bool: kill handler status
+    Returns:
+        - str: Path to downloaded file
+        - bool: Whether download was stopped
     """
     start_message()
-    index_season_selected = dynamic_format_number(str(index_season_selected))
 
-    # Get info about episode
-    obj_episode = scape_info_serie.list_episodes[index_episode_selected - 1]
+    # 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"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [bold magenta]{obj_episode.get('name')}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
 
     # Define filename and path for the downloaded video
@@ -80,24 +81,23 @@ def download_video(index_season_selected: int, index_episode_selected: int, scap
     return r_proc['path'], r_proc['stopped']
 
 
-def download_episode(scape_info_serie: GetSerieInfo, index_season_selected: int, download_all: bool = False) -> None:
+def download_episode(scape_info_serie: GetSerieInfo, index_season_selected: int, download_all: bool = False, episode_selection: str = None) -> None:
     """
-    Download all episodes of a season.
+    Handle downloading episodes for a specific season.
 
     Parameters:
-        - tv_name (str): Name of the TV series.
-        - index_season_selected (int): Index of the selected season.
-        - download_all (bool): Download all seasons episodes
+        - scape_info_serie (GetSerieInfo): Scraper object with series information
+        - index_season_selected (int): Season number
+        - download_all (bool): Whether to download all episodes
+        - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
-
-    # Start message and collect information about episodes
-    start_message()
-    list_dict_episode = scape_info_serie.get_episode_number(index_season_selected)
-    episodes_count = len(list_dict_episode)
+    # Get episodes for the selected season
+    episodes = scape_info_serie.get_episode_number(index_season_selected)
+    episodes_count = len(episodes)
 
     if download_all:
-
-        # Download all episodes without asking
+        
+        # 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)
 
@@ -109,14 +109,15 @@ def download_episode(scape_info_serie: GetSerieInfo, index_season_selected: int,
     else:
 
         # Display episodes list and manage user selection
-        last_command = display_episodes_list(scape_info_serie.list_episodes)
+        if episode_selection is None:
+            last_command = display_episodes_list(scape_info_serie.list_episodes)
+        else:
+            last_command = episode_selection
+            console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
+        
+        # Validate the selection
         list_episode_select = manage_selection(last_command, episodes_count)
-
-        try:
-            list_episode_select = validate_episode_selection(list_episode_select, episodes_count)
-        except ValueError as e:
-            console.print(f"[red]{str(e)}")
-            return
+        list_episode_select = validate_episode_selection(list_episode_select, episodes_count)
 
         # Download selected episodes
         for i_episode in list_episode_select:
@@ -126,46 +127,47 @@ def download_episode(scape_info_serie: GetSerieInfo, index_season_selected: int,
                 break
 
 
-def download_series(dict_serie: MediaItem) -> None:
+def download_series(dict_serie: MediaItem, season_selection: str = None, episode_selection: str = None) -> None:
     """
-    Download all episodes of a TV series.
+    Handle downloading a complete series.
 
     Parameters:
-        - dict_serie (MediaItem): obj with url name type and score
+        - dict_serie (MediaItem): Series metadata from search
+        - season_selection (str, optional): Pre-defined season selection that bypasses manual input
+        - episode_selection (str, optional): Pre-defined episode selection that bypasses manual input
     """
-
-    # Start message and set up video source
     start_message()
 
-    # Init class
-    scape_info_serie = GetSerieInfo(dict_serie)
-
-    # Collect information about seasons
-    seasons_count = scape_info_serie.get_seasons_number()
+    # Create class
+    scrape_serie = GetSerieInfo(dict_serie)
 
+    # Get season count
+    seasons_count = scrape_serie.get_seasons_number()
+    
     # Prompt user for season selection and download episodes
     console.print(f"\n[green]Seasons found: [red]{seasons_count}")
-    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"
-    )
-    
-    # Manage and validate the selection
-    list_season_select = manage_selection(index_season_selected, seasons_count)
 
-    try:
-        list_season_select = validate_selection(list_season_select, seasons_count)
-    except ValueError as e:
-        console.print(f"[red]{str(e)}")
-        return
+    # 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"
+        )
+    else:
+        index_season_selected = season_selection
+        console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
+
+    # Validate the selection
+    list_season_select = manage_selection(index_season_selected, seasons_count)
+    list_season_select = validate_selection(list_season_select, seasons_count)
 
     # 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(scape_info_serie, i_season, download_all=True)
+            download_episode(scrape_serie, i_season, download_all=True)
         else:
 
             # Otherwise, let the user select specific episodes for the single season
-            download_episode(scape_info_serie, i_season, download_all=False)
+            download_episode(scrape_serie, i_season, download_all=False, episode_selection=episode_selection)

StreamingCommunity/Api/Site/guardaserie/site.py

@@ -62,9 +62,10 @@ def title_search(query: str) -> int:
             link = serie_div.find('a').get("href")
 
             serie_info = {
-                'name': title,
+                'name': title.replace("streaming guardaserie", ""),
                 'url': link,
-                'type': 'tv'
+                'type': 'tv',
+                'image': f"{site_constant.FULL_URL}/{serie_div.find('img').get('src')}",
             }
 
             media_search_manager.add_media(serie_info)

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

@@ -104,4 +104,30 @@ class GetSerieInfo:
         except Exception as e:
             logging.error(f"Error parsing HTML page: {e}")
 
-        return []
+        return []
+
+
+    # ------------- FOR GUI -------------
+    def getNumberSeason(self) -> int:
+        """
+        Get the total number of seasons available for the series.
+        """
+        return self.get_seasons_number()
+    
+    def getEpisodeSeasons(self, season_number: int) -> list:
+        """
+        Get all episodes for a specific season.
+        """
+        episodes = self.get_episode_number(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
+            
+        return episodes[episode_index]

StreamingCommunity/Api/Site/raiplay/__init__.py

@@ -0,0 +1,93 @@
+# 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 = 8
+_useFor = "film_serie"
+_deprecate = False
+_priority = 3
+_engineDownload = "hls"
+
+msg = Prompt()
+console = Console()
+
+
+def get_user_input(string_to_search: str = None):
+    """
+    Asks the user to input a search term.
+    """
+    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)
+        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/raiplay/film.py

@@ -0,0 +1,65 @@
+# 3.12.23
+
+import os
+from typing import Tuple
+
+
+# External library
+import httpx
+from rich.console import Console
+
+
+# Internal utilities
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Lib.Downloader import HLS_Downloader
+from StreamingCommunity.Util.headers import get_headers
+
+
+# Logic class
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Api.Player.mediapolisvod import VideoSource
+
+
+# Variable
+console = Console()
+
+
+def download_film(select_title: MediaItem) -> Tuple[str, bool]:
+    """
+    Downloads a film using the provided MediaItem information.
+
+    Parameters:
+        - select_title (MediaItem): The media item containing film information
+
+    Return:
+        - str: Path to downloaded file
+        - bool: Whether download was stopped
+    """
+    start_message()
+    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [cyan]{select_title.name}[/cyan] \n")
+
+    # Extract m3u8 URL from the film's URL
+    response = httpx.get(select_title.url + ".json", headers=get_headers(), timeout=10)
+    first_item_path =  "https://www.raiplay.it" + response.json().get("first_item_path")
+    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", ""))
+
+    # 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
+
+    return r_proc['path'], r_proc['stopped']

StreamingCommunity/Api/Site/raiplay/series.py

@@ -0,0 +1,162 @@
+# 3.12.23
+
+import os
+from typing import Tuple
+
+
+# External library
+from rich.console import Console
+from rich.prompt import Prompt
+
+
+# Internal utilities
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Lib.Downloader import HLS_Downloader
+
+# Logic class
+from .util.ScrapeSerie import GetSerieInfo
+from StreamingCommunity.Api.Template.Util import (
+    manage_selection, 
+    map_episode_title,
+    validate_selection, 
+    validate_episode_selection, 
+    display_episodes_list
+)
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Api.Player.mediapolisvod import VideoSource
+
+
+# Variable
+msg = Prompt()
+console = Console()
+
+
+def download_video(index_season_selected: int, index_episode_selected: int, scrape_serie: GetSerieInfo) -> Tuple[str,bool]:
+    """
+    Downloads a specific episode from the specified season.
+
+    Parameters:
+        - index_season_selected (int): Season number
+        - index_episode_selected (int): Episode index
+        - scrape_serie (GetSerieInfo): Scraper object with series information
+
+    Returns:
+        - str: Path to downloaded file
+        - bool: Whether download was stopped
+    """
+    start_message()
+
+    # Get episode information
+    obj_episode = scrape_serie.selectEpisode(index_season_selected, index_episode_selected-1)
+    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [bold magenta]{obj_episode.name}[/bold magenta] ([cyan]S{index_season_selected}E{index_episode_selected}[/cyan]) \n")
+
+    # Get streaming URL
+    master_playlist = VideoSource.extract_m3u8_url(obj_episode.url)
+
+    # Define filename and path
+    mp4_name = f"{map_episode_title(scrape_serie.series_name, index_season_selected, index_episode_selected, obj_episode.name)}.mp4"
+    mp4_path = os.path.join(site_constant.SERIES_FOLDER, scrape_serie.series_name, f"S{index_season_selected}")
+
+    # Download the episode
+    r_proc = HLS_Downloader(
+        m3u8_url=master_playlist,
+        output_path=os.path.join(mp4_path, mp4_name)
+    ).start()
+
+    if r_proc['error'] is not None:
+        try: os.remove(r_proc['path'])
+        except: pass
+
+    return r_proc['path'], r_proc['stopped']
+
+
+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:
+        - 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 = scrape_serie.getEpisodeSeasons(index_season_selected)
+    episodes_count = len(episodes)
+
+    if download_all:
+        for i_episode in range(1, episodes_count + 1):
+            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(episodes)
+        else:
+            last_command = episode_selection
+            console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
+
+        # Validate the selection
+        list_episode_select = manage_selection(last_command, episodes_count)
+        list_episode_select = validate_episode_selection(list_episode_select, episodes_count)
+
+        # Download selected episodes if not stopped
+        for i_episode in list_episode_select:
+            path, stopped = download_video(index_season_selected, i_episode, scrape_serie)
+            if stopped:
+                break
+
+def download_series(select_season: MediaItem, season_selection: str = None, episode_selection: str = None) -> None:
+    """
+    Handle downloading a complete series.
+
+    Parameters:
+        - select_season (MediaItem): Series metadata from search
+        - season_selection (str, optional): Pre-defined season selection that bypasses manual input
+        - 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)
+
+    # Get seasons info
+    scrape_serie.collect_info_title()
+    seasons_count = len(scrape_serie.seasons_manager)
+    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"
+        )
+
+    else:
+        index_season_selected = season_selection
+        console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
+
+    # Validate the selection
+    list_season_select = manage_selection(index_season_selected, seasons_count)
+    list_season_select = validate_selection(list_season_select, seasons_count)
+
+    # Loop through the selected seasons and download episodes
+    for season_number in list_season_select:
+        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)