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

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)

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
 
 
@@ -52,10 +51,8 @@ def get_token() -> dict:
     
     for html_meta in soup.find_all("meta"):
         if html_meta.get('name') == "csrf-token":
-
             find_csrf_token = html_meta.get('content')
 
-    logging.info(f"Extract: ('animeunity_session': {response.cookies['animeunity_session']}, 'csrf_token': {find_csrf_token})")
     return {
         'animeunity_session': response.cookies['animeunity_session'],
         'csrf_token': find_csrf_token
@@ -65,9 +62,6 @@ def get_token() -> dict:
 def get_real_title(record):
     """
     Get the real title from a record.
-
-    This function takes a record, which is assumed to be a dictionary representing a row of JSON data.
-    It looks for a title in the record, prioritizing English over Italian titles if available.
     
     Parameters:
         - record (dict): A dictionary representing a row of JSON data.
@@ -85,7 +79,7 @@ def get_real_title(record):
 
 def title_search(query: str) -> int:
     """
-    Function to perform an anime search using a provided query.
+    Function to perform an anime search using both APIs and combine results.
 
     Parameters:
         - query (str): The query to search for.
@@ -98,63 +92,96 @@ def title_search(query: str) -> int:
     
     media_search_manager.clear()
     table_show_manager.clear()
+    seen_titles = set()
+    choices = [] if site_constant.TELEGRAM_BOT else None
 
     # Create parameter for request
     data = get_token()
-    cookies = {'animeunity_session': data.get('animeunity_session')}
+    cookies = {
+        'animeunity_session': data.get('animeunity_session')
+    }
     headers = {
         'user-agent': get_userAgent(),
         'x-csrf-token': data.get('csrf_token')
     }
-    json_data =  {'title': query}
 
-    # Send a POST request to the API endpoint for live search
+    # First API call - livesearch
+    try:
+        response1 = httpx.post(
+            f'{site_constant.FULL_URL}/livesearch',
+            cookies=cookies,
+            headers=headers,
+            json={'title': query},
+            timeout=max_timeout
+        )
+        
+        response1.raise_for_status()
+        process_results(response1.json()['records'], seen_titles, media_search_manager, choices)
+
+    except Exception as e:
+        console.print(f"Site: {site_constant.SITE_NAME}, livesearch error: {e}")
+
+    # Second API call - archivio
     try:
-        response = httpx.post(
-            f'{site_constant.FULL_URL}/livesearch', 
-            cookies=cookies, 
-            headers=headers, 
+        json_data = {
+            'title': query,
+            'type': False,
+            'year': False,
+            'order': 'Lista A-Z',
+            'status': False,
+            'genres': False,
+            'offset': 0,
+            'dubbed': False,
+            'season': False
+        }
+
+        response2 = httpx.post(
+            f'{site_constant.FULL_URL}/archivio/get-animes',
+            cookies=cookies,
+            headers=headers,
             json=json_data,
             timeout=max_timeout
         )
-        response.raise_for_status()
+
+        response2.raise_for_status()
+        process_results(response2.json()['records'], seen_titles, media_search_manager, choices)
 
     except Exception as e:
-        console.print(f"Site: {site_constant.SITE_NAME}, request search error: {e}")
-        return 0
+        console.print(f"Site: {site_constant.SITE_NAME}, archivio search error: {e}")
 
-    # Inizializza la lista delle scelte
-    if site_constant.TELEGRAM_BOT:
-        choices = []
+    if site_constant.TELEGRAM_BOT and choices and len(choices) > 0:
+        bot.send_message(f"Lista dei risultati:", choices)
+    
+    result_count = media_search_manager.get_length()
+    if result_count == 0:
+        console.print(f"Nothing matching was found for: {query}")
+    
+    return result_count
 
-    for dict_title in response.json()['records']:
+def process_results(records: list, seen_titles: set, media_manager: MediaManager, choices: list = None) -> None:
+    """Helper function to process search results and add unique entries."""
+    for dict_title in records:
         try:
-
-            # Rename keys for consistency
+            title_id = dict_title.get('id')
+            if title_id in seen_titles:
+                continue
+                
+            seen_titles.add(title_id)
             dict_title['name'] = get_real_title(dict_title)
 
-            media_search_manager.add_media({
-                'id': dict_title.get('id'),
+            media_manager.add_media({
+                'id': title_id,
                 'slug': dict_title.get('slug'),
                 'name': dict_title.get('name'),
                 '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:
-                
-                # Crea una stringa formattata per ogni scelta con numero
+            if choices is not None:
                 choice_text = f"{len(choices)} - {dict_title.get('name')} ({dict_title.get('type')}) - Episodi: {dict_title.get('episodes_count')}"
                 choices.append(choice_text)
 
         except Exception as e:
-            print(f"Error parsing a film entry: {e}")
-
-    if site_constant.TELEGRAM_BOT:
-        if choices:
-            bot.send_message(f"Lista dei risultati:", choices)
-
-    # Return the length of media search manager
-    return media_search_manager.get_length()
+            print(f"Error parsing a title entry: {e}")

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

@@ -29,6 +29,7 @@ class ScrapeSerieAnime:
         self.is_series = False
         self.headers = {'user-agent': get_userAgent()}
         self.url = url
+        self.episodes_cache = None
 
     def setup(self, version: str = None, media_id: int = None, series_name: str = None):
         self.version = version
@@ -62,35 +63,53 @@ class ScrapeSerieAnime:
             logging.error(f"Error fetching episode count: {e}")
             return None
     
-    def get_info_episode(self, index_ep: int) -> Episode:
+    def _fetch_all_episodes(self):
         """
-        Fetch detailed information for a specific episode.
-        
-        Args:
-            index_ep (int): Zero-based index of the target episode
-        
-        Returns:
-            Episode: Detailed episode information
+        Fetch all episodes data at once and cache it
         """
         try:
-
-            params = {
-                "start_range": index_ep, 
-                "end_range": index_ep + 1
-            }
+            count = self.get_count_episodes()
+            if not count:
+                return
 
             response = httpx.get(
-                url=f"{self.url}/info_api/{self.media_id}/{index_ep}", 
-                headers=self.headers, 
-                params=params, 
+                url=f"{self.url}/info_api/{self.media_id}/1",
+                params={
+                    "start_range": 1,
+                    "end_range": count
+                },
+                headers=self.headers,
                 timeout=max_timeout
             )
             response.raise_for_status()
+            
+            self.episodes_cache = response.json()["episodes"]
+        except Exception as e:
+            logging.error(f"Error fetching all episodes: {e}")
+            self.episodes_cache = None
 
-            # Return information about the episode
-            json_data = response.json()["episodes"][-1]
-            return Episode(json_data)
+    def get_info_episode(self, index_ep: int) -> Episode:
+        """
+        Get episode info from cache
+        """
+        if self.episodes_cache is None:
+            self._fetch_all_episodes()
+            
+        if self.episodes_cache and 0 <= index_ep < len(self.episodes_cache):
+            return Episode(self.episodes_cache[index_ep])
+        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
         
-        except Exception as e:
-            logging.error(f"Error fetching episode information: {e}")
-            return None
+    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,13 +14,13 @@ 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
 indice = 8
 _useFor = "anime"
-_deprecate = False
-_priority = 2
+_priority = 0
 _engineDownload = "mp4"
 
 msg = Prompt()
@@ -28,44 +28,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