StreamingCommunity 1.7.6__py3-none-any.whl

StreamingCommunity/Src/Api/Site/altadefinizione/film.py

@@ -0,0 +1,69 @@
+# 26.05.24
+
+import os
+import time
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console, msg
+from StreamingCommunity.Src.Util.os import os_manager
+from StreamingCommunity.Src.Util.message import start_message
+from StreamingCommunity.Src.Util.call_stack import get_call_stack
+from StreamingCommunity.Src.Lib.Downloader import HLS_Downloader
+
+
+# Logic class
+from StreamingCommunity.Src.Api.Template.Util import execute_search
+from StreamingCommunity.Src.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Src.Api.Player.supervideo import VideoSource
+
+
+# Config
+from .costant import ROOT_PATH, SITE_NAME, MOVIE_FOLDER
+
+
+def download_film(select_title: MediaItem):
+    """
+    Downloads a film using the provided film ID, title name, and domain.
+
+    Parameters:
+        - title_name (str): The name of the film title.
+        - url (str): The url of the video
+    """
+
+    # Start message and display film information
+    start_message()
+    console.print(f"[yellow]Download:  [red]{select_title.name} \n")
+
+    # Set domain and media ID for the video source
+    video_source = VideoSource(select_title.url)
+
+    # Define output path
+    title_name = os_manager.get_sanitize_file(select_title.name) + ".mp4"
+    mp4_path = os_manager.get_sanitize_path(
+        os.path.join(ROOT_PATH, SITE_NAME, MOVIE_FOLDER, title_name.replace(".mp4", ""))
+    )
+
+    # Get m3u8 master playlist
+    master_playlist = video_source.get_playlist()
+
+    # Download the film using the m3u8 playlist, and output filename
+    r_proc = HLS_Downloader(
+        m3u8_playlist=master_playlist, 
+        output_filename=os.path.join(mp4_path, title_name)
+    ).start()
+    
+    if r_proc == 404:
+        time.sleep(2)
+
+        # Re call search function
+        if msg.ask("[green]Do you want to continue [white]([red]y[white])[green] or return at home[white]([red]n[white]) ", choices=['y', 'n'], default='y', show_choices=True) == "n":
+            frames = get_call_stack()
+            execute_search(frames[-4])
+
+    if r_proc != None:
+        console.print("[green]Result: ")
+        console.print(r_proc)

StreamingCommunity/Src/Api/Site/altadefinizione/site.py

@@ -0,0 +1,86 @@
+# 26.05.24
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+from StreamingCommunity.Src.Util.headers import get_headers
+from StreamingCommunity.Src.Util.table import TVShowManager
+
+
+# Logic class
+from StreamingCommunity.Src.Api.Template import get_select_title
+from StreamingCommunity.Src.Api.Template.Util import search_domain
+from StreamingCommunity.Src.Api.Template.Class.SearchType import MediaManager
+
+
+# Variable
+from .costant import SITE_NAME, DOMAIN_NOW
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+
+
+def title_search(title_search: str) -> int:
+    """
+    Search for titles based on a search query.
+
+    Parameters:
+        - title_search (str): The title to search for.
+
+    Returns:
+        int: The number of titles found.
+    """
+    client = httpx.Client()
+
+    # Find new domain if prev dont work
+    max_timeout = config_manager.get_int("REQUESTS", "timeout")
+    #domain_to_use, _ = search_domain(SITE_NAME, f"https://{SITE_NAME}")
+    
+    # Send request to search for title
+    try:
+        response = client.get(
+            url=f"https://{SITE_NAME}.{DOMAIN_NOW}/?story={title_search.replace(' ', '+')}&do=search&subaction=search&titleonly=3", 
+            headers={
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
+                'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+                'User-Agent': get_headers()
+            },
+            timeout=max_timeout
+        )
+        response.raise_for_status()
+
+    except Exception as e:
+        console.print(f"Site: {SITE_NAME}, request search error: {e}")
+        raise
+
+    # Create soup and find table
+    soup = BeautifulSoup(response.text, "html.parser")
+    table_content = soup.find('div', id="dle-content")
+
+    # Scrape div film in table on single page
+    for film_div in table_content.find_all('div', class_='col-lg-3'):
+        title = film_div.find('h2', class_='titleFilm').get_text(strip=True)
+        link = film_div.find('h2', class_='titleFilm').find('a')['href']
+        imdb_rating = film_div.find('div', class_='imdb-rate').get_text(strip=True).split(":")[-1]
+
+        film_info = {
+            'name': title,
+            'url': link,
+            'score': imdb_rating
+        }
+
+        media_search_manager.add_media(film_info)
+
+    # Return the number of titles found
+    return media_search_manager.get_length()
+
+
+def run_get_select_title():
+    """
+    Display a selection of titles and prompt the user to choose one.
+    """
+    return get_select_title(table_show_manager, media_search_manager)

StreamingCommunity/Src/Api/Site/animeunity/__init__.py

@@ -0,0 +1,50 @@
+# 21.05.24
+
+from unidecode import unidecode
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console, msg
+
+
+# Logic class
+from .site import title_search, run_get_select_title, media_search_manager
+from .film_serie import download_film, download_series
+
+
+# Variable
+indice = 1
+_useFor = "anime"
+_deprecate = False
+_priority = 2
+_engineDownload = "mp4"
+
+
+def search(string_to_search: str = None, get_onylDatabase: bool = False):
+
+    if string_to_search is None:
+        string_to_search = msg.ask("\n[purple]Insert word to search in all site").strip()
+
+    # Search on database
+    len_database = title_search(unidecode(string_to_search))
+
+    # Return list of elements
+    if get_onylDatabase:
+        return media_search_manager
+
+    if len_database > 0:
+
+        # Select title from list (type: TV \ Movie \ OVA)
+        select_title = run_get_select_title()
+
+        if select_title.type == 'Movie' or select_title.type == 'OVA':
+            download_film(select_title)
+
+        else:
+            download_series(select_title)
+            
+    else:
+        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
+
+        # Retry
+        search()

StreamingCommunity/Src/Api/Site/animeunity/anime.py

@@ -0,0 +1,126 @@
+# 11.03.24
+
+import os
+import sys
+import logging
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console, msg
+from StreamingCommunity.Src.Util.os import os_manager
+from StreamingCommunity.Src.Util.message import start_message
+from StreamingCommunity.Src.Lib.Downloader import MP4_downloader
+
+
+# Logic class
+from StreamingCommunity.Src.Api.Template.Util import manage_selection
+from StreamingCommunity.Src.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Src.Api.Player.vixcloud import AnimeVideoSource as VideoSource
+
+
+# Variable
+from .costant import ROOT_PATH, SITE_NAME, SERIES_FOLDER, MOVIE_FOLDER
+video_source = VideoSource(site_name=SITE_NAME)
+
+
+def download_episode(index_select: int):
+    """
+    Downloads the selected episode.
+
+    Parameters:
+        - index_select (int): Index of the episode to download.
+    """
+
+    # Get information about the selected episode
+    obj_episode = video_source.get_info_episode(index_select)
+
+    if obj_episode is not None:
+
+        start_message()
+        console.print(f"[yellow]Download:  [red]EP_{obj_episode.number} \n")
+
+        # Get the js script from the episode
+        js_script = video_source.get_embed(obj_episode.id)
+
+        # Parse parameter in embed text
+        video_source.parse_script(js_script)
+
+        # Create output path
+        title_name = f"{obj_episode.number}.mp4"
+
+        if video_source.is_series:
+            mp4_path = os_manager.get_sanitize_path(
+                os.path.join(ROOT_PATH, SITE_NAME, SERIES_FOLDER, video_source.series_name)
+            )
+        else:
+            mp4_path = os_manager.get_sanitize_path(
+                os.path.join(ROOT_PATH, SITE_NAME, MOVIE_FOLDER, video_source.series_name)
+            )
+
+        # Create output folder
+        os_manager.create_path(mp4_path)                                                            
+
+        # Start downloading
+        r_proc = MP4_downloader(
+            url = str(video_source.src_mp4).strip(),
+            path = os.path.join(mp4_path, title_name)
+        )
+
+        if r_proc != None:
+            console.print("[green]Result: ")
+            console.print(r_proc)
+
+    else:
+        logging.error(f"Skip index: {index_select} cant find info with api.")
+
+
+def download_series(select_title: MediaItem):
+    """
+    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.
+    """
+
+    # Set up video source
+    video_source.setup(select_title.id, select_title.slug)
+
+    # Get the count of episodes for the TV series
+    episoded_count = video_source.get_count_episodes()
+    console.log(f"[cyan]Episodes find: [red]{episoded_count}")
+
+    # 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")
+
+    # Manage user selection
+    list_episode_select = manage_selection(last_command, episoded_count)
+
+    # Download selected episodes
+    if len(list_episode_select) == 1 and last_command != "*":
+        download_episode(list_episode_select[0]-1)
+
+    # Download all other episodes selecter
+    else:
+        for i_episode in list_episode_select:
+            download_episode(i_episode-1)
+
+
+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.
+    """
+
+    # Set up video source
+    video_source.setup(select_title.id, select_title.slug)
+    video_source.is_series = False
+
+    # Start download
+    download_episode(0)

StreamingCommunity/Src/Api/Site/animeunity/costant.py

@@ -0,0 +1,15 @@
+# 26.05.24
+
+import os
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+
+
+SITE_NAME = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
+ROOT_PATH = config_manager.get('DEFAULT', 'root_path')
+DOMAIN_NOW = config_manager.get_dict('SITE', SITE_NAME)['domain']
+
+SERIES_FOLDER= "Serie"
+MOVIE_FOLDER = "Movie"

StreamingCommunity/Src/Api/Site/animeunity/film_serie.py

@@ -0,0 +1,131 @@
+# 11.03.24
+
+import os
+import sys
+import logging
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console, msg
+from StreamingCommunity.Src.Util.os import os_manager
+from StreamingCommunity.Src.Util.message import start_message
+from StreamingCommunity.Src.Lib.Downloader import MP4_downloader
+
+
+# Logic class
+from .util.ScrapeSerie import ScrapeSerieAnime
+from StreamingCommunity.Src.Api.Template.Util import manage_selection
+from StreamingCommunity.Src.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Src.Api.Player.vixcloud import VideoSourceAnime
+
+
+# Variable
+from .costant import ROOT_PATH, SITE_NAME, SERIES_FOLDER, MOVIE_FOLDER
+scrape_serie = ScrapeSerieAnime(SITE_NAME)
+video_source = VideoSourceAnime(SITE_NAME)
+
+
+def download_episode(index_select: int):
+    """
+    Downloads the selected episode.
+
+    Parameters:
+        - index_select (int): Index of the episode to download.
+    """
+
+    # Get information about the selected episode
+    obj_episode = scrape_serie.get_info_episode(index_select)
+
+    if obj_episode is not None:
+
+        start_message()
+        console.print(f"[yellow]Download:  [red]EP_{obj_episode.number} \n")
+
+        # Collect mp4 url
+        video_source.get_embed(obj_episode.id)
+
+        # Get the js script from the episode
+        #js_script = video_source.get_embed(obj_episode.id)
+
+        # Parse parameter in embed text
+        #video_source.parse_script(js_script)
+
+        # Create output path
+        title_name = f"{obj_episode.number}.mp4"
+
+        if scrape_serie.is_series:
+            mp4_path = os_manager.get_sanitize_path(
+                os.path.join(ROOT_PATH, SITE_NAME, SERIES_FOLDER, scrape_serie.series_name)
+            )
+        else:
+            mp4_path = os_manager.get_sanitize_path(
+                os.path.join(ROOT_PATH, SITE_NAME, MOVIE_FOLDER, scrape_serie.series_name)
+            )
+
+        # Create output folder
+        os_manager.create_path(mp4_path)                                                            
+
+        # Start downloading
+        r_proc = MP4_downloader(
+            url = str(video_source.src_mp4).strip(),
+            path = os.path.join(mp4_path, title_name)
+        )
+
+        if r_proc != None:
+            console.print("[green]Result: ")
+            console.print(r_proc)
+
+    else:
+        logging.error(f"Skip index: {index_select} cant find info with api.")
+
+
+def download_series(select_title: MediaItem):
+    """
+    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.
+    """
+
+    # Set up video source
+    scrape_serie.setup(None, select_title.id, select_title.slug)
+
+    # Get the count of episodes for the TV series
+    episoded_count = scrape_serie.get_count_episodes()
+    console.print(f"[cyan]Episodes find: [red]{episoded_count}")
+
+    # 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")
+
+    # Manage user selection
+    list_episode_select = manage_selection(last_command, episoded_count)
+
+    # Download selected episodes
+    if len(list_episode_select) == 1 and last_command != "*":
+        download_episode(list_episode_select[0]-1)
+
+    # Download all other episodes selecter
+    else:
+        for i_episode in list_episode_select:
+            download_episode(i_episode-1)
+
+
+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.
+    """
+
+    # Set up video source
+    scrape_serie.setup(None, select_title.id, select_title.slug)
+    scrape_serie.is_series = False
+
+    # Start download
+    download_episode(0)

StreamingCommunity/Src/Api/Site/animeunity/site.py

@@ -0,0 +1,165 @@
+# 10.12.23
+
+import logging
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Src.Util.console import console
+from StreamingCommunity.Src.Util._jsonConfig import config_manager
+from StreamingCommunity.Src.Util.table import TVShowManager
+
+
+# Logic class
+from StreamingCommunity.Src.Api.Template import get_select_title
+from StreamingCommunity.Src.Api.Template.Util import search_domain
+from StreamingCommunity.Src.Api.Template.Class.SearchType import MediaManager
+
+
+# Variable
+from .costant import SITE_NAME
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+
+
+
+def get_token(site_name: str, domain: str) -> dict:
+    """
+    Function to retrieve session tokens from a specified website.
+
+    Parameters:
+        - site_name (str): The name of the site.
+        - domain (str): The domain of the site.
+
+    Returns:
+        - dict: A dictionary containing session tokens. The keys are 'XSRF_TOKEN', 'animeunity_session', and 'csrf_token'.
+    """
+
+    # Send a GET request to the specified URL composed of the site name and domain
+    response = httpx.get(f"https://www.{site_name}.{domain}")
+    response.raise_for_status()
+
+    # Initialize variables to store CSRF token
+    find_csrf_token = None
+    
+    # Parse the HTML response using BeautifulSoup
+    soup = BeautifulSoup(response.text, "html.parser")
+    
+    # Loop through all meta tags in the HTML response
+    for html_meta in soup.find_all("meta"):
+
+        # Check if the meta tag has a 'name' attribute equal to "csrf-token"
+        if html_meta.get('name') == "csrf-token":
+
+            # If found, retrieve the content of the meta tag, which is the 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
+    }
+
+
+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.
+    
+    Returns:
+        - str: The title found in the record. If no title is found, returns None.
+    """
+
+    if record['title'] is not None:
+        return record['title']
+    
+    elif record['title_eng'] is not None:
+        return record['title_eng']
+    
+    else:
+        return record['title_it']
+
+
+def title_search(title: str) -> int:
+    """
+    Function to perform an anime search using a provided title.
+
+    Parameters:
+        - title_search (str): The title to search for.
+
+    Returns:
+        - int: A number containing the length of media search manager.
+    """
+
+    # Get token and session value from configuration
+    max_timeout = config_manager.get_int("REQUESTS", "timeout")
+    domain_to_use, _ = search_domain(SITE_NAME, f"https://www.{SITE_NAME}")
+    
+    data = get_token(SITE_NAME, domain_to_use)
+
+    # Prepare cookies to be used in the request
+    cookies = {
+        'animeunity_session': data.get('animeunity_session')
+    }
+
+    # Prepare headers for the request
+    headers = {
+        'accept': 'application/json, text/plain, */*',
+        'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+        'content-type': 'application/json;charset=UTF-8',
+        'x-csrf-token': data.get('csrf_token')
+    }
+
+    # Prepare JSON data to be sent in the request
+    json_data = {
+        'title': title  # Use the provided title for the search
+    }
+
+    # Send a POST request to the API endpoint for live search
+    try:
+        response = httpx.post(
+            url=f'https://www.{SITE_NAME}.{domain_to_use}/livesearch', 
+            cookies=cookies, 
+            headers=headers, 
+            json=json_data,
+            timeout=max_timeout
+        )
+        response.raise_for_status()
+
+    except Exception as e:
+        console.print(f"Site: {SITE_NAME}, request search error: {e}")
+
+    # Process each record returned in the response
+    for dict_title in response.json()['records']:
+
+        # Rename keys for consistency
+        dict_title['name'] = get_real_title(dict_title)
+
+        # Add the record to media search manager if the name is not None
+        media_search_manager.add_media({
+            'id': dict_title.get('id'),
+            'slug': dict_title.get('slug'),
+            'name': dict_title.get('name'),
+            'type': dict_title.get('type'),
+            'score': dict_title.get('score'),
+            'episodes_count': dict_title.get('episodes_count')
+        })
+
+    # Return the length of media search manager
+    return media_search_manager.get_length()
+
+
+def run_get_select_title():
+    """
+    Display a selection of titles and prompt the user to choose one.
+    """
+    return get_select_title(table_show_manager, media_search_manager)