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

StreamingCommunity/Api/Site/animeunity/serie.py

@@ -0,0 +1,153 @@
+# 11.03.24
+
+import os
+from typing import Tuple
+
+
+# External library
+from rich.console import Console
+from rich.prompt import Prompt
+
+
+# Internal utilities
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Lib.Downloader import MP4_downloader
+from StreamingCommunity.TelegramHelp.telegram_bot import TelegramSession, get_bot_instance
+
+
+# Logic class
+from .util.ScrapeSerie import ScrapeSerieAnime
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Util import manage_selection, dynamic_format_number
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Api.Player.vixcloud import VideoSourceAnime
+
+
+# Variable
+console = Console()
+msg = Prompt()
+KILL_HANDLER = bool(False)
+
+
+def download_episode(index_select: int, scrape_serie: ScrapeSerieAnime, video_source: VideoSourceAnime) -> Tuple[str,bool]:
+    """
+    Downloads the selected episode.
+
+    Parameters:
+        - index_select (int): Index of the episode to download.
+
+    Return:
+        - str: output path
+        - bool: kill handler status
+    """
+    start_message()
+
+    # Get episode information
+    obj_episode = scrape_serie.selectEpisode(1, index_select)
+    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] ([cyan]E{obj_episode.number}[/cyan]) \n")
+
+    if site_constant.TELEGRAM_BOT:
+        bot = get_bot_instance()
+        bot.send_message(f"Download in corso\nAnime: {scrape_serie.series_name}\nEpisodio: {obj_episode.number}", None)
+        
+        # Get script_id and update it
+        script_id = TelegramSession.get_session()
+        if script_id != "unknown":
+            TelegramSession.updateScriptId(script_id, f"{scrape_serie.series_name} - E{obj_episode.number}")
+
+    # Collect mp4 url
+    video_source.get_embed(obj_episode.id)
+
+    # Create output path
+    mp4_name = f"{scrape_serie.series_name}_EP_{dynamic_format_number(str(obj_episode.number))}.mp4"
+
+    if scrape_serie.is_series:
+        mp4_path = os_manager.get_sanitize_path(os.path.join(site_constant.ANIME_FOLDER, scrape_serie.series_name))
+    else:
+        mp4_path = os_manager.get_sanitize_path(os.path.join(site_constant.MOVIE_FOLDER, scrape_serie.series_name))
+
+    # Create output folder
+    os_manager.create_path(mp4_path)
+
+    # Start downloading
+    path, kill_handler = MP4_downloader(
+        url=str(video_source.src_mp4).strip(),
+        path=os.path.join(mp4_path, mp4_name)
+    )
+
+    return path, kill_handler
+
+
+def download_series(select_title: MediaItem, season_selection: str = None, episode_selection: str = None):
+    """
+    Function to download episodes of a TV series.
+
+    Parameters:
+        - select_title (MediaItem): The selected media item
+        - season_selection (str, optional): Season selection input that bypasses manual input (usually '1' for anime)
+        - episode_selection (str, optional): Episode selection input that bypasses manual input
+    """
+    start_message()
+
+    if site_constant.TELEGRAM_BOT:
+        bot = get_bot_instance()
+
+    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)
+
+    # Get episode information
+    episoded_count = scrape_serie.get_count_episodes()
+    console.print(f"[green]Episodes count:[/green] [red]{episoded_count}[/red]")
+    
+    # Telegram bot integration
+    if episode_selection is None:
+        if site_constant.TELEGRAM_BOT:
+            console.print(f"\n[cyan]Insert media [red]index [yellow]or [red]* [cyan]to download all media [yellow]or [red]1-2 [cyan]or [red]3-* [cyan]for a range of media")
+            bot.send_message(f"Episodi trovati: {episoded_count}", None)
+
+            last_command = bot.ask(
+                "select_title",
+                "Menu di selezione degli episodi: \n\n" 
+                "- Inserisci il numero dell'episodio (ad esempio, 1)\n" 
+                "- Inserisci * per scaricare tutti gli episodi\n" 
+                "- Inserisci un intervallo di episodi (ad esempio, 1-2) per scaricare da un episodio all'altro\n" 
+                "- Inserisci (ad esempio, 3-*) per scaricare dall'episodio specificato fino alla fine della serie",
+                None
+            )
+        else:
+            # Prompt user to select an episode index
+            last_command = msg.ask("\n[cyan]Insert media [red]index [yellow]or [red]* [cyan]to download all media [yellow]or [red]1-2 [cyan]or [red]3-* [cyan]for a range of media")
+    else:
+        last_command = episode_selection
+        console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
+
+    # Manage user selection
+    list_episode_select = manage_selection(last_command, episoded_count)
+
+    # Download selected episodes
+    if len(list_episode_select) == 1 and last_command != "*":
+        path, _ = download_episode(list_episode_select[0]-1, scrape_serie, video_source)
+        return path
+
+    # Download all other episodes selected
+    else:
+        kill_handler = False
+        for i_episode in list_episode_select:
+            if kill_handler:
+                break
+            _, kill_handler = download_episode(i_episode-1, scrape_serie, video_source)
+
+    if site_constant.TELEGRAM_BOT:
+        bot.send_message(f"Finito di scaricare tutte le serie e episodi", None)
+
+        # Get script_id
+        script_id = TelegramSession.get_session()
+        if script_id != "unknown":
+            TelegramSession.deleteScriptId(script_id)

StreamingCommunity/Api/Site/animeunity/site.py

@@ -1,6 +1,5 @@
 # 10.12.23
 
-import sys
 import logging
 
 
@@ -140,7 +139,7 @@ def title_search(query: str) -> int:
                 'type': dict_title.get('type'),
                 'status': dict_title.get('status'),
                 'episodes_count': dict_title.get('episodes_count'),
-                'plot': ' '.join((words := str(dict_title.get('plot', '')).split())[:10]) + ('...' if len(words) > 10 else '')
+                'image': dict_title.get('imageurl')
             })
 
             if site_constant.TELEGRAM_BOT:

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

@@ -94,3 +94,18 @@ class ScrapeSerieAnime:
         except Exception as e:
             logging.error(f"Error fetching episode information: {e}")
             return None
+
+
+    # ------------- FOR GUI -------------
+    def getNumberSeason(self) -> int:
+        """
+        Get the total number of seasons available for the anime.
+        Note: AnimeUnity typically doesn't have seasons, so returns 1.
+        """
+        return 1
+        
+    def selectEpisode(self, season_number: int = 1, episode_index: int = 0) -> Episode:
+        """
+        Get information for a specific episode.
+        """
+        return self.get_info_episode(episode_index)

StreamingCommunity/Api/Site/animeworld/__init__.py

@@ -14,6 +14,7 @@ from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
 # Logic class
 from .site import title_search, media_search_manager, table_show_manager
 from .serie import download_series
+from .film import download_film
 
 
 # Variable
@@ -28,44 +29,56 @@ 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}
     """
     if select_title.type == "TV":
-        download_series(select_title)
+        episode_selection = None
+        if selections:
+            episode_selection = selections.get('episode')
+        download_series(select_title, episode_selection)
+
+    else:
+        download_film(select_title)
 
-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_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
-    string_to_search = msg.ask(f"\n[purple]Insert a word to search in [green]{site_constant.SITE_NAME}").strip()
+    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()
 
     # 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
 
     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}")
-
         # If no results are found, ask again
-        string_to_search = msg.ask(f"\n[purple]Insert a word to search in [green]{site_constant.SITE_NAME}").strip()
+        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
         search()

StreamingCommunity/Api/Site/animeworld/film.py

@@ -0,0 +1,63 @@
+# 11.03.24
+
+import os
+
+# External library
+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 MP4_downloader
+
+
+# Logic class
+from .util.ScrapeSerie import ScrapSerie
+from StreamingCommunity.Api.Template.config_loader import site_constant
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Api.Player.sweetpixel import VideoSource
+
+
+# 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.
+    """
+    start_message()
+    
+    scrape_serie = ScrapSerie(select_title.url, site_constant.FULL_URL)
+    episodes = scrape_serie.get_episodes() 
+
+    # Get episode information
+    episode_data = episodes[0]
+    console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] ([cyan]{scrape_serie.get_name()}[/cyan]) \n")
+
+    # Define filename and path for the downloaded video
+    mp4_name = f"{scrape_serie.get_name()}.mp4"
+    mp4_path = os.path.join(site_constant.ANIME_FOLDER, scrape_serie.get_name())
+
+    # Create output folder
+    os_manager.create_path(mp4_path)
+
+    # Get video source for the episode
+    video_source = VideoSource(site_constant.FULL_URL, episode_data, scrape_serie.session_id, scrape_serie.csrf_token)
+    mp4_link = video_source.get_playlist()
+
+    # Start downloading
+    path, kill_handler = MP4_downloader(
+        url=str(mp4_link).strip(),
+        path=os.path.join(mp4_path, mp4_name)
+    )
+
+    return path, kill_handler

StreamingCommunity/Api/Site/animeworld/serie.py

@@ -19,12 +19,12 @@ from StreamingCommunity.Lib.Downloader import MP4_downloader
 # Logic class
 from .util.ScrapeSerie import ScrapSerie
 from StreamingCommunity.Api.Template.config_loader import site_constant
-from StreamingCommunity.Api.Template.Util import manage_selection, dynamic_format_number, map_episode_title
+from StreamingCommunity.Api.Template.Util import manage_selection, dynamic_format_number
 from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
 
 
 # Player
-from StreamingCommunity.Api.Player.sweetpixel import AnimeWorldPlayer
+from StreamingCommunity.Api.Player.sweetpixel import VideoSource
 
 
 # Variable
@@ -33,8 +33,7 @@ msg = Prompt()
 KILL_HANDLER = bool(False)
 
 
-
-def download_episode(index_select: int, scrape_serie: ScrapSerie, episodes) -> Tuple[str,bool]:
+def download_episode(index_select: int, scrape_serie: ScrapSerie) -> Tuple[str,bool]:
     """
     Downloads the selected episode.
 
@@ -47,7 +46,8 @@ def download_episode(index_select: int, scrape_serie: ScrapSerie, episodes) -> T
     """
     start_message()
 
-    # Get information about the selected episode
+    # Get episode information
+    episode_data = scrape_serie.selectEpisode(1, index_select)
     console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] ([cyan]E{index_select+1}[/cyan]) \n")
 
     # Define filename and path for the downloaded video
@@ -57,9 +57,9 @@ def download_episode(index_select: int, scrape_serie: ScrapSerie, episodes) -> T
     # Create output folder
     os_manager.create_path(mp4_path)
 
-    # Collect mp4 link
-    video_source = AnimeWorldPlayer(site_constant.FULL_URL, episodes[index_select], scrape_serie.session_id, scrape_serie.csrf_token)
-    mp4_link = video_source.get_download_link()
+    # Get video source for the episode
+    video_source = VideoSource(site_constant.FULL_URL, episode_data, scrape_serie.session_id, scrape_serie.csrf_token)
+    mp4_link = video_source.get_playlist()
 
     # Start downloading
     path, kill_handler = MP4_downloader(
@@ -70,38 +70,41 @@ def download_episode(index_select: int, scrape_serie: ScrapSerie, episodes) -> T
     return path, kill_handler
 
 
-def download_series(select_title: MediaItem):
+def download_series(select_title: MediaItem, episode_selection: str = None):
     """
     Function to download episodes of a TV series.
 
     Parameters:
-        - tv_id (int): The ID of the TV series.
-        - tv_name (str): The name of the TV series.
+        - select_title (MediaItem): The selected media item
+        - episode_selection (str, optional): Episode selection input that bypasses manual input
     """
     start_message()
 
+    # Create scrap instance
     scrape_serie = ScrapSerie(select_title.url, site_constant.FULL_URL)
+    episodes = scrape_serie.get_episodes() 
 
-    # Get the count of episodes for the TV series
-    episodes = scrape_serie.get_episodes()
-    episoded_count = len(episodes)
-    console.print(f"[cyan]Episodes find: [red]{episoded_count}")
+    # Get episode count
+    console.print(f"[green]Episodes found:[/green] [red]{len(episodes)}[/red]")
 
-    # Prompt user to select an episode index
-    last_command = msg.ask("\n[cyan]Insert media [red]index [yellow]or [red]* [cyan]to download all media [yellow]or [red]1-2 [cyan]or [red]3-* [cyan]for a range of media")
+    # Display episodes list and get user selection
+    if episode_selection is None:
+        last_command = msg.ask("\n[cyan]Insert media [red]index [yellow]or [red]* [cyan]to download all media [yellow]or [red]1-2 [cyan]or [red]3-* [cyan]for a range of media")
+    else:
+        last_command = episode_selection
+        console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
 
-    # Manage user selection
-    list_episode_select = manage_selection(last_command, episoded_count)
+    list_episode_select = manage_selection(last_command, len(episodes))
 
     # Download selected episodes
     if len(list_episode_select) == 1 and last_command != "*":
-        path, _ = download_episode(list_episode_select[0]-1, scrape_serie, episodes)
+        path, _ = download_episode(list_episode_select[0]-1, scrape_serie)
         return path
 
-    # Download all other episodes selecter
+    # Download all selected episodes
     else:
         kill_handler = False
         for i_episode in list_episode_select:
             if kill_handler:
                 break
-            _, kill_handler = download_episode(i_episode-1, scrape_serie, episodes)
+            _, kill_handler = download_episode(i_episode-1, scrape_serie)

StreamingCommunity/Api/Site/animeworld/site.py

@@ -101,7 +101,8 @@ def title_search(query: str) -> int:
                     'name': title,
                     'type': anime_type,
                     'DUB': is_dubbed,
-                    'url': url
+                    'url': url,
+                    'image': element.find('img').get('src')
                 })
 
         except Exception as e:

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

@@ -1,5 +1,6 @@
 # 21.03.25
 
+import logging
 
 # External libraries
 import httpx
@@ -14,7 +15,7 @@ from StreamingCommunity.Util.os import os_manager
 
 # Player
 from ..site import get_session_and_csrf
-from StreamingCommunity.Api.Player.sweetpixel import AnimeWorldPlayer
+from StreamingCommunity.Api.Player.sweetpixel import VideoSource
 
 
 # Variable
@@ -40,7 +41,6 @@ class ScrapSerie:
         except:
             raise Exception(f"Failed to retrieve anime page.")
 
-
     def get_name(self):
         """Extract and return the name of the anime series."""
         soup = BeautifulSoup(self.response.content, "html.parser")
@@ -68,12 +68,39 @@ class ScrapSerie:
         return episodes
 
     def get_episode(self, index):
-        """Fetch a specific episode based on the index, and return an AnimeWorldPlayer instance."""
+        """Fetch a specific episode based on the index, and return an VideoSource instance."""
         episodes = self.get_episodes()
         
         if 0 <= index < len(episodes):
             episode_data = episodes[index]
-            return AnimeWorldPlayer(episode_data, self.session_id, self.csrf_token)
+            return VideoSource(episode_data, self.session_id, self.csrf_token)
         
         else:
-            raise IndexError("Episode index out of range")
+            raise IndexError("Episode index out of range")
+    
+    
+    # ------------- FOR GUI -------------
+    def getNumberSeason(self) -> int:
+        """
+        Get the total number of seasons available for the anime.
+        Note: AnimeWorld typically doesn't have seasons, so returns 1.
+        """
+        return 1
+    
+    def getEpisodeSeasons(self, season_number: int = 1) -> list:
+        """
+        Get all episodes for a specific season.
+        Note: For AnimeWorld, this returns all episodes as they're typically in one season.
+        """
+        return self.get_episodes()
+        
+    def selectEpisode(self, season_number: int = 1, episode_index: int = 0) -> dict:
+        """
+        Get information for a specific episode.
+        """
+        episodes = self.get_episodes()
+        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/cb01new/__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/ddlstreamitaly/__init__.py

@@ -42,7 +42,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/ddlstreamitaly/series.py

@@ -35,22 +35,22 @@ from StreamingCommunity.Api.Player.ddl import VideoSource
 console = Console()
 
 
-def download_video(index_episode_selected: int, scape_info_serie: GetSerieInfo, video_source: VideoSource) -> Tuple[str,bool]:
+def download_video(index_episode_selected: int, scape_info_serie: GetSerieInfo) -> Tuple[str,bool]:
     """
-    Download a single episode video.
+    Downloads a specific episode.
 
     Parameters:
-        - tv_name (str): Name of the TV series.
-        - index_episode_selected (int): Index of the selected episode.
+        - 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()
 
-    # Get info about episode
-    obj_episode = scape_info_serie.list_episodes[index_episode_selected - 1]
+    # Get episode information
+    obj_episode = scape_info_serie.selectEpisode(1, index_episode_selected-1)
     console.print(f"[bold yellow]Download:[/bold yellow] [red]{site_constant.SITE_NAME}[/red] → [bold magenta]{obj_episode.get('name')}[/bold magenta] ([cyan]E{index_episode_selected}[/cyan]) \n")
     
     # Define filename and path for the downloaded video
@@ -63,7 +63,7 @@ def download_video(index_episode_selected: int, scape_info_serie: GetSerieInfo,
     os_manager.create_path(mp4_path)
 
     # Setup video source
-    video_source.setup(obj_episode.get('url'))
+    video_source = VideoSource(site_constant.COOKIE, obj_episode.get('url'))
 
     # Get m3u8 master playlist
     master_playlist = video_source.get_playlist()
@@ -82,38 +82,37 @@ def download_video(index_episode_selected: int, scape_info_serie: GetSerieInfo,
         console.print("[green]Result: ")
         console.print(r_proc)
 
-    return os.path.join(mp4_path, title_name)
+    return os.path.join(mp4_path, title_name), False
 
 
-def download_thread(dict_serie: MediaItem):
+def download_thread(dict_serie: MediaItem, episode_selection: str = None):
     """
     Download all episode of a thread
+    
+    Parameters:
+        dict_serie (MediaItem): The selected media item
+        episode_selection (str, optional): Episode selection input that bypasses manual input
     """
-    start_message()
-
-    # Init class
-    scape_info_serie = GetSerieInfo(dict_serie, site_constant.COOKIE)
-    video_source = VideoSource(site_constant.COOKIE)
-
-    # Collect information about thread
-    list_dict_episode = scape_info_serie.get_episode_number()
-    episodes_count = len(list_dict_episode)
-
+    scrape_serie = GetSerieInfo(dict_serie, site_constant.COOKIE)
+    
+    # Get episode list 
+    episodes = scrape_serie.getEpisodeSeasons()
+    episodes_count = len(episodes)
+    
     # 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(scrape_serie.list_episodes)
+    else:
+        last_command = episode_selection
+        console.print(f"\n[cyan]Using provided episode selection: [yellow]{episode_selection}")
+    
+    # Validate 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
     kill_handler = bool(False)
     for i_episode in list_episode_select:
         if kill_handler:
             break
-
-        kill_handler = download_video(i_episode, scape_info_serie, video_source)[1]
+        kill_handler = download_video(i_episode, scrape_serie)[1]

StreamingCommunity/Api/Site/ddlstreamitaly/site.py

@@ -1,6 +1,5 @@
 # 09.06.24
 
-import sys
 import logging
 
 
@@ -67,7 +66,8 @@ def title_search(query: str) -> int:
                 title_info = {
                     'name': name,
                     'url': link,
-                    'type': title_type
+                    'type': title_type,
+                    'image': title_div.find("div", class_="ipsColumn").find("img").get("src")
                 }
 
                 media_search_manager.add_media(title_info)