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

StreamingCommunity/Api/Player/ddl.py

@@ -18,21 +18,13 @@ max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
 class VideoSource:
-    def __init__(self, cookie) -> None:
+    def __init__(self, url, cookie) -> None:
         """
         Initializes the VideoSource object with default values.
         """
         self.headers = {'user-agent': get_userAgent()}
-        self.cookie = cookie
-
-    def setup(self, url: str) -> None:
-        """
-        Sets up the video source with the provided URL.
-
-        Parameters:
-            - url (str): The URL of the video source.
-        """
         self.url = url
+        self.cookie = cookie
 
     def make_request(self, url: str) -> str:
         """

StreamingCommunity/Api/Player/mediapolisvod.py

@@ -0,0 +1,64 @@
+# 11.04.25
+
+
+# External libraries
+import httpx
+
+
+# Internal utilities
+from StreamingCommunity.Util.config_json import config_manager
+from StreamingCommunity.Util.headers import get_headers
+
+
+# Variable
+MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
+
+
+class VideoSource:
+   
+    @staticmethod
+    def extract_m3u8_url(video_url: str) -> str:
+        """Extract the m3u8 streaming URL from a RaiPlay video URL."""
+        if not video_url.endswith('.json'):
+            if '/video/' in video_url:
+                video_id = video_url.split('/')[-1].split('.')[0]
+                video_path = '/'.join(video_url.split('/')[:-1])
+                video_url = f"{video_path}/{video_id}.json"
+
+            else:
+                return "Error: Unable to determine video JSON URL"
+                        
+        try:
+            response = httpx.get(video_url, headers=get_headers(), timeout=MAX_TIMEOUT)
+            if response.status_code != 200:
+                return f"Error: Failed to fetch video data (Status: {response.status_code})"
+                
+            video_data = response.json()
+            content_url = video_data.get("video").get("content_url")
+            
+            if not content_url:
+                return "Error: No content URL found in video data"
+                
+            # Extract the element key
+            if "=" in content_url:
+                element_key = content_url.split("=")[1]
+            else:
+                return "Error: Unable to extract element key"
+                
+            # Request the stream URL
+            params = {
+                'cont': element_key,
+                'output': '62',
+            }
+            stream_response = httpx.get('https://mediapolisvod.rai.it/relinker/relinkerServlet.htm', params=params, headers=get_headers(), timeout=MAX_TIMEOUT)
+            
+            if stream_response.status_code != 200:
+                return f"Error: Failed to fetch stream URL (Status: {stream_response.status_code})"
+                
+            # Extract the m3u8 URL
+            stream_data = stream_response.json()
+            m3u8_url = stream_data.get("video")[0] if "video" in stream_data else None
+            return m3u8_url
+            
+        except Exception as e:
+            return f"Error: {str(e)}"

StreamingCommunity/Api/Player/sweetpixel.py

@@ -16,9 +16,9 @@ from StreamingCommunity.Util.headers import get_userAgent
 MAX_TIMEOUT = config_manager.get_int("REQUESTS", "timeout")
 
 
-class AnimeWorldPlayer:
+class VideoSource:
     def __init__(self, full_url, episode_data, session_id, csrf_token):
-        """Initialize the AnimeWorldPlayer with session details, episode data, and URL."""
+        """Initialize the VideoSource with session details, episode data, and URL."""
         self.session_id = session_id
         self.csrf_token = csrf_token
         self.episode_data = episode_data
@@ -33,7 +33,7 @@ class AnimeWorldPlayer:
             timeout=MAX_TIMEOUT
         )
 
-    def get_download_link(self):
+    def get_playlist(self):
         """Fetch the download link from AnimeWorld using the episode link."""
         try:
             # Make a POST request to the episode link and follow any redirects

StreamingCommunity/Api/Player/vixcloud.py

@@ -24,26 +24,20 @@ console = Console()
 
 
 class VideoSource:
-    def __init__(self, url: str, is_series: bool):
+    def __init__(self, url: str, is_series: bool, media_id: int = None):
         """
         Initialize video source for streaming site.
         
         Args:
             - url (str): The URL of the streaming site.
             - is_series (bool): Flag for series or movie content
+            - media_id (int, optional): Unique identifier for media item
         """
         self.headers = {'user-agent': get_userAgent()}
         self.url = url
         self.is_series = is_series
-
-    def setup(self, media_id: int):
-        """
-        Configure media-specific context.
-        
-        Args:
-            media_id (int): Unique identifier for media item
-        """
         self.media_id = media_id
+        self.iframe_src = None
 
     def get_iframe(self, episode_id: int) -> None:
         """
@@ -164,6 +158,7 @@ class VideoSourceAnime(VideoSource):
         self.headers = {'user-agent': get_userAgent()}
         self.url = url
         self.src_mp4 = None
+        self.iframe_src = None
 
     def get_embed(self, episode_id: int):
         """

StreamingCommunity/Api/Site/1337xx/__init__.py

@@ -39,7 +39,7 @@ def process_search_result(select_title):
 
 def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: 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

StreamingCommunity/Api/Site/altadefinizione/__init__.py

@@ -57,27 +57,43 @@ def get_user_input(string_to_search: str = None):
 
     return string_to_search
 
-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}
     """
     if select_title.type == 'tv':
-        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)
+    
     else:
         download_film(select_title)
 
-def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = None):
+# search("Game of Thrones", selections={"season": "1", "episode": "1-3"})
+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
         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
     
     # Get the user input for the search term
@@ -95,7 +111,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:
         console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
@@ -105,4 +121,4 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
 
         # If no results are found, ask again
         string_to_search = get_user_input()
-        search()
+        search(string_to_search, get_onlyDatabase, None, selections)

StreamingCommunity/Api/Site/altadefinizione/film.py

@@ -42,7 +42,6 @@ def download_film(select_title: MediaItem) -> str:
     Return:
         - str: output path if successful, otherwise None
     """
-
     if site_constant.TELEGRAM_BOT:
         bot = get_bot_instance()
         bot.send_message(f"Download in corso:\n{select_title.name}", None)

StreamingCommunity/Api/Site/altadefinizione/series.py

@@ -19,8 +19,7 @@ from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance, Teleg
 from .util.ScrapeSerie import GetSerieInfo
 from StreamingCommunity.Api.Template.Util import (
     manage_selection, 
-    map_episode_title, 
-    dynamic_format_number, 
+    map_episode_title,
     validate_selection, 
     validate_episode_selection, 
     display_episodes_list
@@ -40,23 +39,24 @@ console = Console()
 
 def download_video(index_season_selected: int, index_episode_selected: int, scrape_serie: GetSerieInfo) -> Tuple[str,bool]:
     """
-    Download a single episode video.
+    Downloads a specific episode from a specified season.
 
     Parameters:
-        - 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
+        - scrape_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 = scrape_serie.seasons_manager.get_season_by_number(int(index_season_selected)).episodes.get(index_episode_selected-1)
+    # 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")
 
+    # Telegram integration
     if site_constant.TELEGRAM_BOT:
         bot = get_bot_instance()
 
@@ -93,21 +93,21 @@ def download_video(index_season_selected: int, index_episode_selected: int, scra
     return r_proc['path'], r_proc['stopped']
     
 
-def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, download_all: bool = False) -> None:
+def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, download_all: bool = False, episode_selection: str = None) -> None:
     """
-    Download episodes of a selected season.
+    Handle downloading episodes for a specific season.
 
     Parameters:
-        - index_season_selected (int): Index of the selected season.
-        - download_all (bool): Download all episodes in the season.
+        - 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
     """
-    start_message()
-    obj_episodes = scrape_serie.seasons_manager.get_season_by_number(index_season_selected).episodes
-    episodes_count = len(obj_episodes.episodes)
+    # Get episodes for the selected season
+    episodes = scrape_serie.getEpisodeSeasons(index_season_selected)
+    episodes_count = len(episodes)
 
     if download_all:
-
-        # Download all episodes without asking
         for i_episode in range(1, episodes_count + 1):
             path, stopped = download_video(index_season_selected, i_episode, scrape_serie)
 
@@ -117,16 +117,16 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, dow
         console.print(f"\n[red]End downloaded [yellow]season: [red]{index_season_selected}.")
 
     else:
+        if episode_selection is not None:
+            last_command = episode_selection
+            console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
 
-        # Display episodes list and manage user selection
-        last_command = display_episodes_list(obj_episodes.episodes)
+        else:
+            last_command = display_episodes_list(episodes)
+        
+        # Prompt user for episode 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 if not stopped
         for i_episode in list_episode_select:
@@ -135,69 +135,65 @@ def download_episode(index_season_selected: int, scrape_serie: GetSerieInfo, dow
             if stopped:
                 break
 
-def download_series(select_season: MediaItem) -> None:
+def download_series(select_season: MediaItem, season_selection: str = None, episode_selection: str = None) -> None:
     """
-    Download episodes of a TV series based on user selection.
+    Handle downloading a complete series.
 
     Parameters:
-        - select_season (MediaItem): Selected media item (TV series).
+        - 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
     """
-    if site_constant.TELEGRAM_BOT:
-        bot = get_bot_instance()
-
-    start_message()
-
-    # Init class
     scrape_serie = GetSerieInfo(select_season.url)
 
-    # Collect information about seasons
-    scrape_serie.collect_season()
-    seasons_count = len(scrape_serie.seasons_manager)
+    # Get total number of seasons 
+    seasons_count = scrape_serie.getNumberSeason()
+    
+    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 site_constant.TELEGRAM_BOT:
-        console.print("\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")
-
-        bot.send_message(f"Stagioni trovate: {seasons_count}", None)
-
-        index_season_selected = bot.ask(
-            "select_title_episode",
-            "Menu di selezione delle stagioni\n\n"
-            "- Inserisci il numero della stagione (ad esempio, 1)\n"
-            "- Inserisci * per scaricare tutte le stagioni\n"
-            "- Inserisci un intervallo di stagioni (ad esempio, 1-2) per scaricare da una stagione all'altra\n"
-            "- Inserisci (ad esempio, 3-*) per scaricare dalla stagione specificata fino alla fine della serie",
-            None
-        )
+    # If season_selection is provided, use it instead of asking for input
+    if season_selection is None:
+        if site_constant.TELEGRAM_BOT:
+            console.print("\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")
+
+            bot.send_message(f"Stagioni trovate: {seasons_count}", None)
+
+            index_season_selected = bot.ask(
+                "select_title_episode",
+                "Menu di selezione delle stagioni\n\n"
+                "- Inserisci il numero della stagione (ad esempio, 1)\n"
+                "- Inserisci * per scaricare tutte le stagioni\n"
+                "- Inserisci un intervallo di stagioni (ad esempio, 1-2) per scaricare da una stagione all'altra\n"
+                "- Inserisci (ad esempio, 3-*) per scaricare dalla stagione specificata fino alla fine della serie",
+                None
+            )
 
+        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"
+            )
     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 = season_selection
+        console.print(f"\n[cyan]Using provided season selection: [yellow]{season_selection}")
 
-    # Manage and validate the selection
+    # 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
+    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(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)
+            download_episode(i_season, scrape_serie, download_all=False, episode_selection=episode_selection)
 
     if site_constant.TELEGRAM_BOT:
         bot.send_message(f"Finito di scaricare tutte le serie e episodi", None)
@@ -205,4 +201,4 @@ def download_series(select_season: MediaItem) -> None:
         # Get script_id
         script_id = TelegramSession.get_session()
         if script_id != "unknown":
-            TelegramSession.deleteScriptId(script_id)
+            TelegramSession.deleteScriptId(script_id)

StreamingCommunity/Api/Site/altadefinizione/site.py

@@ -78,7 +78,8 @@ def title_search(query: str) -> int:
         media_search_manager.add_media({
             'url': url,
             'name': title,
-            'type': tipo
+            'type': tipo,
+            'image': f"{site_constant.FULL_URL}{movie_div.find('img', class_='layer-image').get('data-src')}"
         })
 
         if site_constant.TELEGRAM_BOT:

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

@@ -1,5 +1,8 @@
 # 16.03.25
 
+import logging
+
+
 # External libraries
 import httpx
 from bs4 import BeautifulSoup
@@ -15,7 +18,6 @@ from StreamingCommunity.Api.Player.Helper.Vixcloud.util import SeasonManager
 max_timeout = config_manager.get_int("REQUESTS", "timeout")
 
 
-
 class GetSerieInfo:
     def __init__(self, url):
         """
@@ -69,4 +71,37 @@ class GetSerieInfo:
                         'number': ep_idx,
                         'name': episode_name,
                         'url': episode_url
-                    })
+                    })
+
+
+    # ------------- 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.
+        """
+        if not self.seasons_manager.seasons:
+            self.collect_season()
+            
+        # Get season directly by its number
+        season = self.seasons_manager.get_season_by_number(season_number)
+        return season.episodes.episodes if season else []
+        
+    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/animeunity/__init__.py

@@ -18,7 +18,8 @@ from StreamingCommunity.TelegramHelp.telegram_bot import get_bot_instance
 
 # Logic class
 from .site import title_search, media_search_manager, table_show_manager
-from .film_serie import download_film, download_series
+from .film import download_film
+from .serie import download_series
 
 
 # Variable
@@ -56,24 +57,42 @@ def get_user_input(string_to_search: str = None):
 
     return string_to_search
 
-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)
+    if select_title.type == 'Movie' or select_title.type == 'OVA':
+        download_film(select_title)
+
+    else:
+        season_selection = None
+        episode_selection = None
 
-def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_item: dict = 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, 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_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
 
     # Get the user input for the search term
@@ -82,7 +101,7 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
     # Perform the database search
     len_database = title_search(string_to_search)
 
-    ##If only the database is needed, return the manager
+    # If only the database is needed, return the manager
     if get_onlyDatabase:
         return media_search_manager
     
@@ -91,8 +110,8 @@ 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:
         console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
 
@@ -101,4 +120,4 @@ def search(string_to_search: str = None, get_onlyDatabase: bool = False, direct_
 
         # If no results are found, ask again
         string_to_search = get_user_input()
-        search()
+        search(string_to_search, get_onlyDatabase, None, selections)

StreamingCommunity/Api/Site/animeunity/film.py

@@ -0,0 +1,40 @@
+# 11.03.24
+
+# External library
+from rich.console import Console
+
+
+# Logic class
+from .serie import download_episode
+from .util.ScrapeSerie import ScrapeSerieAnime
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Api.Player.vixcloud import VideoSourceAnime
+
+
+# Variable
+console = Console()
+
+
+def download_film(select_title: MediaItem):
+    """
+    Function to download a film.
+
+    Parameters:
+        - id_film (int): The ID of the film.
+        - title_name (str): The title of the film.
+    """
+
+    # Init class
+    scrape_serie = ScrapeSerieAnime(site_constant.FULL_URL)
+    video_source = VideoSourceAnime(site_constant.FULL_URL)
+
+    # Set up video source (only configure scrape_serie now)
+    scrape_serie.setup(None, select_title.id, select_title.slug)
+    scrape_serie.is_series = False
+
+    # Start download
+    download_episode(0, scrape_serie, video_source)