StreamingCommunity 1.9.8__py3-none-any.whl → 1.9.90__py3-none-any.whl

StreamingCommunity/Api/Site/ilcorsaronero/util/ilCorsarScraper.py

@@ -0,0 +1,141 @@
+# 12.14.24
+
+import logging
+import asyncio
+from typing import List, Dict, Optional
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.console import console
+
+
+# Variable
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+class IlCorsaroNeroScraper:
+    def __init__(self, base_url: str, max_page: int = 1):
+        self.base_url = base_url
+        self.max_page = max_page
+        self.headers = {
+            'User-Agent': get_headers(),
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.5',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1'
+        }
+
+    async def fetch_url(self, url: str) -> Optional[str]:
+        """
+        Fetch the HTML content of a given URL.
+        """
+        try:
+            console.print(f"[cyan]Fetching url[white]: [red]{url}")
+            async with httpx.AsyncClient(headers=self.headers, follow_redirects=True, timeout=max_timeout) as client:
+                response = await client.get(url)
+                
+                # If the request was successful, return the HTML content
+                response.raise_for_status()
+                return response.text
+            
+        except Exception as e:
+            logging.error(f"Error fetching {url}: {e}")
+            return None
+
+    def parse_torrents(self, html: str) -> List[Dict[str, str]]:
+        """
+        Parse the HTML content and extract torrent details.
+        """
+        torrents = []
+        soup = BeautifulSoup(html, "html.parser")
+        table = soup.find("tbody")
+        
+        for row in table.find_all("tr"):
+            try:
+                columns = row.find_all("td")
+
+                torrents.append({
+                    'type': columns[0].get_text(strip=True),
+                    'name': row.find("th").find("a").get_text(strip=True),
+                    'seed': columns[1].get_text(strip=True),
+                    'leech': columns[2].get_text(strip=True),
+                    'size': columns[3].get_text(strip=True),
+                    'date': columns[4].get_text(strip=True),
+                    'url': "https://ilcorsaronero.link" + row.find("th").find("a").get("href")
+                })
+
+            except Exception as e:
+                logging.error(f"Error parsing row: {e}")
+                continue
+
+        return torrents
+    
+    async def fetch_real_url(self, url: str) -> Optional[str]:
+        """
+        Fetch the real torrent URL from the detailed page.
+        """
+        response_html = await self.fetch_url(url)
+        if not response_html:
+            return None
+        
+        soup = BeautifulSoup(response_html, "html.parser")
+        links = soup.find_all("a")
+
+        # Find and return the magnet link
+        for link in links:
+            if "magnet" in str(link):
+                return link.get("href")
+            
+        return None
+
+    async def search(self, query: str) -> List[Dict[str, str]]:
+        """
+        Search for torrents based on the query string.
+        """
+        all_torrents = []
+        
+        # Loop through each page
+        for page in range(self.max_page):
+            url = f'{self.base_url}search?q={query}&page={page}'
+
+            html = await self.fetch_url(url)
+            if not html:
+                console.print(f"[bold red]No HTML content for page {page}[/bold red]")
+                break
+
+            torrents = self.parse_torrents(html)
+            if not torrents:
+                console.print(f"[bold red]No torrents found on page {page}[/bold red]")
+                break
+
+            # Use asyncio.gather to fetch all real URLs concurrently
+            tasks = [self.fetch_real_url(result['url']) for result in torrents]
+            real_urls = await asyncio.gather(*tasks)
+
+            # Attach real URLs to the torrent data
+            for i, result in enumerate(torrents):
+                result['url'] = real_urls[i]
+
+            all_torrents.extend(torrents)
+
+        return all_torrents
+
+async def main():
+    scraper = IlCorsaroNeroScraper("https://ilcorsaronero.link/")
+    results = await scraper.search("cars")
+    
+    if results:
+        for i, torrent in enumerate(results):
+            console.print(f"[bold green]{i} = {torrent}[/bold green] \n")
+    else:
+        console.print("[bold red]No torrents found.[/bold red]")
+
+if __name__ == '__main__':
+    asyncio.run(main())

StreamingCommunity/Api/Site/mostraguarda/__init__.py

@@ -0,0 +1,49 @@
+# 26.05.24
+
+from urllib.parse import quote_plus
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console, msg
+
+
+# Logic class
+from StreamingCommunity.Lib.TMBD import tmdb, Json_film
+from .film import download_film
+
+
+# Variable
+indice = 9
+_useFor = "film"
+_deprecate = False
+_priority = 2
+_engineDownload = "hls"
+from .costant import SITE_NAME
+
+
+def search(string_to_search: str = None, get_onylDatabase: bool = False):
+    """
+    Main function of the application for film and series.
+    """
+
+    if string_to_search is None:
+        string_to_search = msg.ask(f"\n[purple]Insert word to search in [red]{SITE_NAME}").strip()
+
+    # Not available for the moment
+    if get_onylDatabase:
+        return 0
+
+    # Search on database
+    movie_id = tmdb.search_movie(quote_plus(string_to_search))
+
+    if movie_id is not None:
+        movie_details: Json_film = tmdb.get_movie_details(tmdb_id=movie_id)
+
+        # Download only film
+        download_film(movie_details)
+
+    else:
+        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
+
+        # Retry
+        search()

StreamingCommunity/Api/Site/mostraguarda/costant.py

@@ -0,0 +1,15 @@
+# 26.05.24
+
+import os
+
+
+# Internal utilities
+from StreamingCommunity.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 = config_manager.get('DEFAULT', 'serie_folder_name')
+MOVIE_FOLDER = config_manager.get('DEFAULT', 'movie_folder_name')

StreamingCommunity/Api/Site/mostraguarda/film.py

@@ -0,0 +1,99 @@
+# 17.09.24
+
+import os
+import sys
+import time
+import logging
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console, msg
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Util.call_stack import get_call_stack
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Lib.Downloader import HLS_Downloader
+
+
+# Logic class
+from StreamingCommunity.Api.Template.Util import execute_search
+
+
+# Player
+from StreamingCommunity.Api.Player.supervideo import VideoSource
+
+
+# TMBD
+from StreamingCommunity.Lib.TMBD import Json_film
+
+
+# Config
+from .costant import ROOT_PATH, SITE_NAME, DOMAIN_NOW, MOVIE_FOLDER
+
+
+def download_film(movie_details: Json_film) -> str:
+    """
+    Downloads a film using the provided tmbd id.
+
+    Parameters:
+        - movie_details (Json_film): Class with info about film title.
+    
+    Return:
+        - str: output path
+    """
+
+    # Start message and display film information
+    start_message()
+    console.print(f"[yellow]Download:  [red]{movie_details.title} \n")
+
+    # Make request to main site
+    try:
+        url = f"https://{SITE_NAME}.{DOMAIN_NOW}/set-movie-a/{movie_details.imdb_id}"
+        response = httpx.get(url, headers={'User-Agent': get_headers()})
+        response.raise_for_status()
+
+    except:
+        logging.error(f"Not found in the server. Dict: {movie_details}")
+        raise
+
+    # Extract supervideo url
+    soup = BeautifulSoup(response.text, "html.parser")
+    player_links = soup.find("ul", class_ = "_player-mirrors").find_all("li")
+    supervideo_url = "https:" + player_links[0].get("data-link")
+
+    
+    # Set domain and media ID for the video source
+    video_source = VideoSource()
+    video_source.setup(supervideo_url)
+    
+    # Define output path
+    title_name = os_manager.get_sanitize_file(movie_details.title) + ".mp4"
+    mp4_path = os.path.join(ROOT_PATH, 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)
+
+    return os.path.join(mp4_path, title_name)

StreamingCommunity/Api/Site/streamingcommunity/__init__.py

@@ -0,0 +1,56 @@
+# 21.05.24
+
+from urllib.parse import quote_plus
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console, msg
+
+
+# Logic class
+from .site import get_version_and_domain, title_search, run_get_select_title, media_search_manager
+from .film import download_film
+from .series import download_series
+
+
+# Variable
+indice = 0
+_useFor = "film_serie"
+_deprecate = False
+_priority = 1
+_engineDownload = "hls"
+from .costant import SITE_NAME
+
+
+def search(string_to_search: str = None, get_onylDatabase: bool = False):
+    """
+    Main function of the application for film and series.
+    """
+
+    if string_to_search is None:
+        string_to_search = msg.ask(f"\n[purple]Insert word to search in [red]{SITE_NAME}").strip()
+
+    # Get site domain and version and get result of the search
+    site_version, domain = get_version_and_domain()
+    len_database = title_search(quote_plus(string_to_search), domain)
+
+    # Return list of elements
+    if get_onylDatabase:
+        return media_search_manager
+    
+    if len_database > 0:
+
+        # Select title from list
+        select_title = run_get_select_title()
+        
+        if select_title.type == 'tv':
+            download_series(select_title, site_version)
+        
+        else:
+            download_film(select_title)
+    
+    else:
+        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
+
+        # Retry
+        search()

StreamingCommunity/Api/Site/streamingcommunity/costant.py

@@ -0,0 +1,15 @@
+# 26.05.24
+
+import os
+
+
+# Internal utilities
+from StreamingCommunity.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('SITE', SITE_NAME)
+
+SERIES_FOLDER = config_manager.get('DEFAULT', 'serie_folder_name')
+MOVIE_FOLDER = config_manager.get('DEFAULT', 'movie_folder_name')

StreamingCommunity/Api/Site/streamingcommunity/film.py

@@ -0,0 +1,75 @@
+# 3.12.23
+
+import os
+import time
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console, msg
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Util.call_stack import get_call_stack
+from StreamingCommunity.Lib.Downloader import HLS_Downloader
+
+
+# Logic class
+from StreamingCommunity.Api.Template.Util import execute_search
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Api.Player.vixcloud import VideoSource
+
+
+# Variable
+from .costant import ROOT_PATH, SITE_NAME, MOVIE_FOLDER
+        
+
+def download_film(select_title: MediaItem) -> str:
+    """
+    Downloads a film using the provided film ID, title name, and domain.
+
+    Parameters:
+        - domain (str): The domain of the site
+        - version (str): Version of site.
+
+    Return:
+        - str: output path
+    """
+
+    # Start message and display film information
+    start_message()
+    console.print(f"[yellow]Download:  [red]{select_title.slug} \n")
+
+    # Init class
+    video_source = VideoSource(SITE_NAME, False)
+    video_source.setup(select_title.id)
+
+    # Retrieve scws and if available master playlist
+    video_source.get_iframe(select_title.id)
+    video_source.get_content()
+    master_playlist = video_source.get_playlist()
+
+    # Define the filename and path for the downloaded film
+    title_name = os_manager.get_sanitize_file(select_title.slug) + ".mp4"
+    mp4_path = os.path.join(ROOT_PATH, MOVIE_FOLDER, select_title.slug)
+
+    # 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)
+
+    return os.path.join(mp4_path, title_name)

StreamingCommunity/Api/Site/streamingcommunity/series.py

@@ -0,0 +1,206 @@
+# 3.12.23
+
+import os
+import sys
+import time
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console, msg
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Util.call_stack import get_call_stack
+from StreamingCommunity.Util.table import TVShowManager
+from StreamingCommunity.Lib.Downloader import HLS_Downloader
+
+
+# Logic class
+from .util.ScrapeSerie import ScrapeSerie
+from StreamingCommunity.Api.Template.Util import manage_selection, map_episode_title, validate_selection, validate_episode_selection, execute_search
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Player
+from StreamingCommunity.Api.Player.vixcloud import VideoSource
+
+
+# Variable
+from .costant import ROOT_PATH, SITE_NAME, SERIES_FOLDER
+table_show_manager = TVShowManager()
+
+
+
+def download_video(index_season_selected: int, index_episode_selected: int, scrape_serie: ScrapeSerie, video_source: VideoSource) -> str:
+    """
+    Download a single episode video.
+
+    Parameters:
+        - index_season_selected (int): Index of the selected season.
+        - index_episode_selected (int): Index of the selected episode.
+
+    Return:
+        - str: output path
+    """
+    start_message()
+
+    # Get info about episode
+    obj_episode = scrape_serie.episode_manager.get(index_episode_selected - 1)
+    console.print(f"[yellow]Download: [red]{index_season_selected}:{index_episode_selected} {obj_episode.name}")
+    print()
+
+    # Define filename and path for the downloaded video
+    mp4_name = f"{map_episode_title(scrape_serie.series_name, index_season_selected, index_episode_selected, obj_episode.name)}.mp4"
+    mp4_path = os.path.join(ROOT_PATH, SERIES_FOLDER, scrape_serie.series_name, f"S{index_season_selected}")
+
+    # Retrieve scws and if available master playlist
+    video_source.get_iframe(obj_episode.id)
+    video_source.get_content()
+    master_playlist = video_source.get_playlist()
+    
+    # Download the episode
+    r_proc = HLS_Downloader(
+        m3u8_playlist=master_playlist,
+        output_filename=os.path.join(mp4_path, mp4_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)
+
+    return os.path.join(mp4_path, mp4_name)
+
+def download_episode(index_season_selected: int, scrape_serie: ScrapeSerie, video_source: VideoSource, download_all: bool = False) -> None:
+    """
+    Download episodes of a selected season.
+
+    Parameters:
+        - index_season_selected (int): Index of the selected season.
+        - download_all (bool): Download all episodes in the season.
+    """
+
+    # Clean memory of all episodes and get the number of the season
+    scrape_serie.episode_manager.clear()
+
+    # Start message and collect information about episodes
+    start_message()
+    scrape_serie.collect_info_season(index_season_selected)
+    episodes_count = scrape_serie.episode_manager.length()
+
+    if download_all:
+
+        # Download all episodes without asking
+        for i_episode in range(1, episodes_count + 1):
+            download_video(index_season_selected, i_episode, scrape_serie, video_source)
+        console.print(f"\n[red]End downloaded [yellow]season: [red]{index_season_selected}.")
+
+    else:
+
+        # Display episodes list and manage user selection
+        last_command = display_episodes_list(scrape_serie)
+        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
+
+        # Download selected episodes
+        for i_episode in list_episode_select:
+            download_video(index_season_selected, i_episode, scrape_serie, video_source)
+
+def download_series(select_season: MediaItem, version: str) -> None:
+    """
+    Download episodes of a TV series based on user selection.
+
+    Parameters:
+        - select_season (MediaItem): Selected media item (TV series).
+        - domain (str): Domain from which to download.
+        - version (str): Version of the site.
+    """
+
+    # Start message and set up video source
+    start_message()
+
+    # Init class
+    scrape_serie = ScrapeSerie(SITE_NAME)
+    video_source = VideoSource(SITE_NAME, True)
+
+    # Setup video source
+    scrape_serie.setup(version, select_season.id, select_season.slug)
+    video_source.setup(select_season.id)
+
+    # Collect information about seasons
+    scrape_serie.collect_info_title()
+    seasons_count = scrape_serie.season_manager.seasons_count
+
+    # Prompt user for season selection and download episodes
+    console.print(f"\n[green]Seasons found: [red]{seasons_count}")
+    index_season_selected = msg.ask(
+        "\n[cyan]Insert season number [yellow](e.g., 1), [red]* [cyan]to download all seasons, "
+        "[yellow](e.g., 1-2) [cyan]for a range of seasons, or [yellow](e.g., 3-*) [cyan]to download from a specific season to the end"
+    )
+    
+    # Manage and validate the selection
+    list_season_select = manage_selection(index_season_selected, seasons_count)
+
+    try:
+        list_season_select = validate_selection(list_season_select, seasons_count)
+    except ValueError as e:
+        console.print(f"[red]{str(e)}")
+        return
+
+    # 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, video_source, download_all=True)
+        else:
+
+            # Otherwise, let the user select specific episodes for the single season
+            download_episode(i_season, scrape_serie, video_source, download_all=False)
+
+
+def display_episodes_list(scrape_serie) -> str:
+    """
+    Display episodes list and handle user input.
+
+    Returns:
+        last_command (str): Last command entered by the user.
+    """
+
+    # Set up table for displaying episodes
+    table_show_manager.set_slice_end(10)
+
+    # Add columns to the table
+    column_info = {
+        "Index": {'color': 'red'},
+        "Name": {'color': 'magenta'},
+        "Duration": {'color': 'green'}
+    }
+    table_show_manager.add_column(column_info)
+
+    # Populate the table with episodes information
+    for i, media in enumerate(scrape_serie.episode_manager.episodes):
+        table_show_manager.add_tv_show({
+            'Index': str(media.number),
+            'Name': media.name,
+            'Duration': str(media.duration)
+        })
+
+    # Run the table and handle user input
+    last_command = table_show_manager.run()
+
+    if last_command == "q":
+        console.print("\n[red]Quit [white]...")
+        sys.exit(0)
+
+    return last_command