StreamingCommunity 2.5.0__py3-none-any.whl → 2.5.2__py3-none-any.whl

StreamingCommunity/Api/Site/guardaserie/site.py

@@ -0,0 +1,90 @@
+# 09.06.24
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.table import TVShowManager
+
+
+# Logic class
+from StreamingCommunity.Api.Template import get_select_title
+from StreamingCommunity.Api.Template.Util import search_domain
+from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
+
+
+# Variable
+from .costant import SITE_NAME, DOMAIN_NOW
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+disable_searchDomain = config_manager.get_bool("DEFAULT", "disable_searchDomain")
+
+
+def title_search(word_to_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.
+    """
+    media_search_manager.clear()
+    table_show_manager.clear()
+
+    # Find new domain if prev dont work
+    domain_to_use = DOMAIN_NOW
+
+    if not disable_searchDomain:
+        domain_to_use, base_url = search_domain(SITE_NAME, f"https://{SITE_NAME}.{DOMAIN_NOW}")
+
+    # Send request to search for titles
+    try:
+        response = httpx.get(
+            url=f"https://guardaserie.{domain_to_use}/?story={word_to_search}&do=search&subaction=search", 
+            headers={'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}")
+
+    # Create soup and find table
+    soup = BeautifulSoup(response.text, "html.parser")
+    table_content = soup.find('div', class_="mlnew-list")
+
+    for serie_div in table_content.find_all('div', class_='mlnew'):
+        try:
+            
+            title = serie_div.find('div', class_='mlnh-2').find("h2").get_text(strip=True)
+            link = serie_div.find('div', class_='mlnh-2').find('a')['href']
+            imdb_rating = serie_div.find('span', class_='mlnh-imdb').get_text(strip=True)
+
+            serie_info = {
+                'name': title,
+                'url': link,
+                'score': imdb_rating
+            }
+
+            media_search_manager.add_media(serie_info)
+
+        except Exception as e:
+            print(f"Error parsing a film entry: {e}")
+
+    # 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/Api/Site/guardaserie/util/ScrapeSerie.py

@@ -0,0 +1,110 @@
+# 13.06.24
+
+import logging
+from typing import List, Dict
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_headers
+
+
+# Logic class
+from StreamingCommunity.Api.Template .Class.SearchType import MediaItem
+
+
+class GetSerieInfo:
+    def __init__(self, dict_serie: MediaItem) -> None:
+        """
+        Initializes the GetSerieInfo object with default values.
+
+        Parameters:
+            dict_serie (MediaItem): Dictionary containing series information (optional).
+        """
+        self.headers = {'user-agent': get_headers()}
+        self.url = dict_serie.url
+        self.tv_name = None
+        self.list_episodes = None
+
+    def get_seasons_number(self) -> int:
+        """
+        Retrieves the number of seasons of a TV series.
+
+        Returns:
+            int: Number of seasons of the TV series.
+        """
+        try:
+
+            # Make an HTTP request to the series URL
+            response = httpx.get(self.url, headers=self.headers, timeout=15)
+            response.raise_for_status()
+
+            # Parse HTML content of the page
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            # Find the container of seasons
+            table_content = soup.find('div', class_="tt_season")
+
+            # Count the number of seasons
+            seasons_number = len(table_content.find_all("li"))
+
+            # Extract the name of the series
+            self.tv_name = soup.find("h1", class_="front_title").get_text(strip=True)
+
+            return seasons_number
+
+        except Exception as e:
+            logging.error(f"Error parsing HTML page: {e}")
+
+        return -999
+
+    def get_episode_number(self, n_season: int) -> List[Dict[str, str]]:
+        """
+        Retrieves the number of episodes for a specific season.
+
+        Parameters:
+            n_season (int): The season number.
+
+        Returns:
+            List[Dict[str, str]]: List of dictionaries containing episode information.
+        """
+        try:
+
+            # Make an HTTP request to the series URL
+            response = httpx.get(self.url, headers=self.headers, timeout=15)
+            response.raise_for_status()
+
+            # Parse HTML content of the page
+            soup = BeautifulSoup(response.text, "html.parser")
+
+            # Find the container of episodes for the specified season
+            table_content = soup.find('div', class_="tab-pane", id=f"season-{n_season}")
+
+            # Extract episode information
+            episode_content = table_content.find_all("li")
+            list_dict_episode = []
+
+            for episode_div in episode_content:
+                index = episode_div.find("a").get("data-num")
+                link = episode_div.find("a").get("data-link")
+                name = episode_div.find("a").get("data-title")
+
+                obj_episode = {
+                    'number': index,
+                    'name': name,
+                    'url': link
+                }
+                
+                list_dict_episode.append(obj_episode)
+
+            self.list_episodes = list_dict_episode
+            return list_dict_episode
+        
+        except Exception as e:
+            logging.error(f"Error parsing HTML page: {e}")
+
+        return []

StreamingCommunity/Api/Site/ilcorsaronero/__init__.py

@@ -0,0 +1,52 @@
+# 02.07.24
+
+import asyncio
+from urllib.parse import quote_plus
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console, msg
+
+
+# Logic class
+from .site import title_search, run_get_select_title, media_search_manager
+from .title import download_title
+
+
+# Variable
+indice = 9
+_useFor = "film_serie"
+_deprecate = False
+_priority = 2
+_engineDownload = "tor"
+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 [green]{SITE_NAME}").strip()
+    
+    # Search on database
+    len_database = asyncio.run(title_search(quote_plus(string_to_search)))
+
+    # 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()
+
+        # Download title
+        download_title(select_title)
+
+    else:
+        console.print(f"\n[red]Nothing matching was found for[white]: [purple]{string_to_search}")
+
+        # Retry
+        search()

StreamingCommunity/Api/Site/ilcorsaronero/costant.py

@@ -0,0 +1,19 @@
+# 09.06.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 = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'serie_folder_name'))
+MOVIE_FOLDER = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'movie_folder_name'))
+
+if config_manager.get_bool("DEFAULT", "add_siteName"):
+    SERIES_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'serie_folder_name'))
+    MOVIE_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'movie_folder_name'))   

StreamingCommunity/Api/Site/ilcorsaronero/site.py

@@ -0,0 +1,72 @@
+# 02.07.24
+
+
+# Internal utilities
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.table import TVShowManager
+
+
+# Logic class
+from StreamingCommunity.Api.Template import get_select_title
+from StreamingCommunity.Api.Template.Util import search_domain
+from StreamingCommunity.Api.Template.Class.SearchType import MediaManager
+from .util.ilCorsarScraper import IlCorsaroNeroScraper
+
+
+# Variable
+from .costant import SITE_NAME, DOMAIN_NOW
+media_search_manager = MediaManager()
+table_show_manager = TVShowManager()
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+disable_searchDomain = config_manager.get_bool("DEFAULT", "disable_searchDomain")
+
+
+async def title_search(word_to_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.
+    """
+    media_search_manager.clear()
+    table_show_manager.clear()
+
+    # Find new domain if prev dont work
+    domain_to_use = DOMAIN_NOW
+    
+    if not disable_searchDomain:
+        domain_to_use, base_url = search_domain(SITE_NAME, f"https://{SITE_NAME}.{DOMAIN_NOW}")
+
+    # Create scraper and collect result
+    print("\n")
+    scraper = IlCorsaroNeroScraper(f"https://{SITE_NAME}.{domain_to_use}/", 1)
+    results = await scraper.search(word_to_search)
+
+    for i, torrent in enumerate(results):
+        try:
+            
+            media_search_manager.add_media({
+                'name': torrent['name'],
+                'type': torrent['type'],
+                'seed': torrent['seed'],
+                'leech': torrent['leech'],
+                'size': torrent['size'],
+                'date': torrent['date'],
+                'url': torrent['url']
+            })
+
+        except Exception as e:
+            print(f"Error parsing a film entry: {e}")
+
+    # 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/Api/Site/ilcorsaronero/title.py

@@ -0,0 +1,44 @@
+# 02.07.24
+
+import os
+
+
+# Internal utilities
+from StreamingCommunity.Util.console import console
+from StreamingCommunity.Util.os import os_manager
+from StreamingCommunity.Util.message import start_message
+from StreamingCommunity.Lib.Downloader import TOR_downloader
+
+
+# Logic class
+from StreamingCommunity.Api.Template.Class.SearchType import MediaItem
+
+
+# Config
+from .costant import MOVIE_FOLDER
+
+
+def download_title(select_title: MediaItem):
+    """
+    Downloads a media item and saves it as an MP4 file.
+
+    Parameters:
+        - select_title (MediaItem): The media item to be downloaded. This should be an instance of the MediaItem class, containing attributes like `name` and `url`.
+    """
+
+    start_message()
+    console.print(f"[yellow]Download: [red]{select_title.name} \n")
+    print() 
+
+    # Define output path
+    title_name = os_manager.get_sanitize_file(select_title.name)
+    mp4_path = os.path.join(MOVIE_FOLDER, title_name.replace(".mp4", ""))
+
+    # Create output folder
+    os_manager.create_path(mp4_path)                                                                
+
+    # Tor manager
+    manager = TOR_downloader()
+    manager.add_magnet_link(select_title.url)
+    manager.start_download()
+    manager.move_downloaded_files(mp4_path)

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

@@ -0,0 +1,149 @@
+# 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 = {
+            'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+            'accept-language': 'it-IT,it;q=0.9,en-US;q=0.8,en;q=0.7',
+            'cache-control': 'max-age=0',
+            'priority': 'u=0, i',
+            'sec-ch-ua': '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"Windows"',
+            'sec-fetch-dest': 'document',
+            'sec-fetch-mode': 'navigate',
+            'sec-fetch-site': 'same-origin',
+            'sec-fetch-user': '?1',
+            'upgrade-insecure-requests': '1',
+            'user-agent': get_headers()
+        }
+        
+    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 from {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 [green]{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,19 @@
+# 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 = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'serie_folder_name'))
+MOVIE_FOLDER = os.path.join(ROOT_PATH, config_manager.get('DEFAULT', 'movie_folder_name'))
+
+if config_manager.get_bool("DEFAULT", "add_siteName"):
+    SERIES_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'serie_folder_name'))
+    MOVIE_FOLDER = os.path.join(ROOT_PATH, SITE_NAME, config_manager.get('DEFAULT', 'movie_folder_name'))