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

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

@@ -0,0 +1,124 @@
+# 01.03.24
+
+import json
+import logging
+
+
+# External libraries
+import httpx
+from bs4 import BeautifulSoup
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Api.Player.Helper.Vixcloud.util import Season, EpisodeManager
+
+
+# Variable
+max_timeout = config_manager.get_int("REQUESTS", "timeout")
+
+
+class ScrapeSerie:
+    def __init__(self, site_name: str):
+        """
+        Initialize the ScrapeSerie class for scraping TV series information.
+        
+        Args:
+            site_name (str): Name of the streaming site to scrape from
+        """
+        self.is_series = False
+        self.headers = {'user-agent': get_headers()}
+        self.base_name = site_name
+        self.domain = config_manager.get_dict('SITE', self.base_name)['domain']
+
+    def setup(self, version: str = None, media_id: int = None, series_name: str = None):
+        """
+        Set up the scraper with specific media details.
+        
+        Args:
+            version (str, optional): Site version for request headers
+            media_id (int, optional): Unique identifier for the media
+            series_name (str, optional): Name of the TV series
+        """
+        self.version = version
+        self.media_id = media_id
+
+        # If series name is provided, initialize series-specific managers
+        if series_name is not None:
+            self.is_series = True
+            self.series_name = series_name
+            self.season_manager = None
+            self.episode_manager: EpisodeManager = EpisodeManager()
+
+    def collect_info_title(self) -> None:
+        """
+        Retrieve season information for a TV series from the streaming site.
+        
+        Raises:
+            Exception: If there's an error fetching season information
+        """
+        try:
+            response = httpx.get(
+                url=f"https://{self.base_name}.{self.domain}/titles/{self.media_id}-{self.series_name}",
+                headers=self.headers,
+                timeout=max_timeout
+            )
+            response.raise_for_status()
+
+            # Extract seasons from JSON response
+            soup = BeautifulSoup(response.text, "html.parser")
+            json_response = json.loads(soup.find("div", {"id": "app"}).get("data-page"))
+            self.version = json_response['version']
+                  
+            """
+            response = httpx.post(
+                url=f'https://{self.base_name}.{self.domain}/api/titles/preview/{self.media_id}', 
+                headers={'User-Agent': get_headers()}
+            )
+            response.raise_for_status()
+            
+
+            # Extract seasons from JSON response
+            json_response = response.json()
+            """
+
+            # Collect info about season
+            self.season_manager = Season(json_response.get("props").get("title"))
+
+        except Exception as e:
+            logging.error(f"Error collecting season info: {e}")
+            raise
+
+    def collect_info_season(self, number_season: int) -> None:
+        """
+        Retrieve episode information for a specific season.
+        
+        Args:
+            number_season (int): Season number to fetch episodes for
+        
+        Raises:
+            Exception: If there's an error fetching episode information
+        """
+        try:
+            response = httpx.get(
+                url=f'https://{self.base_name}.{self.domain}/titles/{self.media_id}-{self.series_name}/stagione-{number_season}', 
+                headers={
+                    'User-Agent': get_headers(),
+                    'x-inertia': 'true', 
+                    'x-inertia-version': self.version,
+                },
+                timeout=max_timeout
+            )
+            response.raise_for_status()
+
+            # Extract episodes from JSON response
+            json_response = response.json().get('props').get('loadedSeason').get('episodes')
+                
+            # Add each episode to the episode manager
+            for dict_episode in json_response:
+                self.episode_manager.add(dict_episode)
+
+        except Exception as e:
+            logging.error(f"Error collecting title season info: {e}")
+            raise

StreamingCommunity/Api/Template/Class/SearchType.py

@@ -0,0 +1,101 @@
+# 07.07.24
+
+from typing import List, TypedDict
+
+
+class MediaItemData(TypedDict, total=False):
+    id: int                 # GENERAL
+    name: str               # GENERAL     
+    type: str               # GENERAL
+    url: str                # GENERAL
+    size: str               # GENERAL
+    score: str              # GENERAL
+    date: str               # GENERAL
+    desc: str               # GENERAL
+
+    seeder: int             # TOR
+    leecher: int            # TOR
+
+    slug: str               # SC
+    
+
+
+class MediaItemMeta(type):
+    def __new__(cls, name, bases, dct):
+        def init(self, **kwargs):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+        dct['__init__'] = init
+
+        def get_attr(self, item):
+            return self.__dict__.get(item, None)
+
+        dct['__getattr__'] = get_attr
+
+        def set_attr(self, key, value):
+            self.__dict__[key] = value
+
+        dct['__setattr__'] = set_attr
+
+        return super().__new__(cls, name, bases, dct)
+
+
+class MediaItem(metaclass=MediaItemMeta):
+    id: int                 # GENERAL
+    name: str               # GENERAL     
+    type: str               # GENERAL
+    url: str                # GENERAL
+    size: str               # GENERAL
+    score: str              # GENERAL
+    date: str               # GENERAL
+    desc: str               # GENERAL
+
+    seeder: int             # TOR
+    leecher: int            # TOR
+
+    slug: str               # SC
+
+    
+class MediaManager:
+    def __init__(self):
+        self.media_list: List[MediaItem] = []
+
+    def add_media(self, data: dict) -> None:
+        """
+        Add media to the list.
+
+        Args:
+            data (dict): Media data to add.
+        """
+        self.media_list.append(MediaItem(**data))
+
+    def get(self, index: int) -> MediaItem:
+        """
+        Get a media item from the list by index.
+
+        Args:
+            index (int): The index of the media item to retrieve.
+
+        Returns:
+            MediaItem: The media item at the specified index.
+        """
+        return self.media_list[index]
+
+    def get_length(self) -> int:
+        """
+        Get the number of media items in the list.
+
+        Returns:
+            int: Number of media items.
+        """
+        return len(self.media_list)
+
+    def clear(self) -> None:
+        """
+        This method clears the media list.
+        """
+        self.media_list.clear()
+
+    def __str__(self):
+        return f"MediaManager(num_media={len(self.media_list)})"

StreamingCommunity/Api/Template/Util/__init__.py

@@ -0,0 +1,5 @@
+# 23.11.24
+
+from .recall_search import execute_search
+from .get_domain import search_domain
+from .manage_ep import manage_selection, map_episode_title, validate_episode_selection, validate_selection, dynamic_format_number

StreamingCommunity/Api/Template/Util/get_domain.py

@@ -0,0 +1,202 @@
+# 18.06.24
+
+import ssl
+import time
+from urllib.parse import urlparse, unquote
+
+
+# External libraries
+import httpx
+from googlesearch import search
+
+
+# Internal utilities
+from StreamingCommunity.Util.headers import get_headers
+from StreamingCommunity.Util.console import console, msg
+from StreamingCommunity.Util._jsonConfig import config_manager
+
+base_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',
+    'dnt': '1',
+    'priority': 'u=0, i',
+    'referer': '',
+    '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': ''
+}
+
+
+def get_tld(url_str):
+    """Extract the TLD (Top-Level Domain) from the URL."""
+    try:
+        url_str = unquote(url_str)
+        parsed = urlparse(url_str)
+        domain = parsed.netloc.lower()
+
+        if domain.startswith('www.'):
+            domain = domain[4:]
+        parts = domain.split('.')
+
+        return parts[-1] if len(parts) >= 2 else None
+    
+    except Exception:
+        return None
+
+def get_base_domain(url_str):
+    """Extract base domain without protocol, www and path."""
+    try:
+        parsed = urlparse(url_str)
+        domain = parsed.netloc.lower()
+        if domain.startswith('www.'):
+            domain = domain[4:]
+
+        # Check if domain has multiple parts separated by dots
+        parts = domain.split('.')
+        if len(parts) > 2:  # Handle subdomains
+            return '.'.join(parts[:-1])  # Return everything except TLD
+        
+        return parts[0]  # Return base domain
+    
+    except Exception:
+        return None
+    
+def get_base_url(url_str):
+    """Extract base URL including protocol and domain, removing path and query parameters."""
+    try:
+        parsed = urlparse(url_str)
+        return f"{parsed.scheme}://{parsed.netloc}"
+    
+    except Exception:
+        return None
+
+def validate_url(url, base_url, max_timeout, max_retries=2, sleep=1):
+    """Validate if URL is accessible and matches expected base domain."""
+    console.print(f"\n[cyan]Starting validation for URL[white]: [yellow]{url}")
+    
+    # Verify URL structure matches base_url structure
+    base_domain = get_base_domain(base_url)
+    url_domain = get_base_domain(url)
+
+    base_headers['referer'] = url
+    base_headers['user-agent'] = get_headers()
+    
+    if base_domain != url_domain:
+        console.print(f"[red]Domain structure mismatch: {url_domain} != {base_domain}")
+        return False, None
+    
+    # Count dots to ensure we don't have extra subdomains
+    base_dots = base_url.count('.')
+    url_dots = url.count('.')
+    if url_dots > base_dots + 1:  # Allow for one extra dot for TLD change
+        console.print(f"[red]Too many subdomains in URL")
+        return False, None
+
+    client = httpx.Client(
+        verify=False,
+        headers=base_headers,
+        timeout=max_timeout
+    )
+
+    for retry in range(max_retries):
+        try:
+            time.sleep(sleep)
+            
+            # Initial check without redirects
+            response = client.get(url, follow_redirects=False)
+            if response.status_code == 403:
+                console.print(f"[red]Check failed (403) - Attempt {retry + 1}/{max_retries}")
+                continue
+                
+            if response.status_code >= 400:
+                console.print(f"[red]Check failed: HTTP {response.status_code}")
+                return False, None
+                
+            # Follow redirects and verify final domain
+            final_response = client.get(url, follow_redirects=True)
+            final_domain = get_base_domain(str(final_response.url))
+            console.print(f"[cyan]Redirect url: [red]{final_response.url}")
+            
+            if final_domain != base_domain:
+                console.print(f"[red]Final domain mismatch: {final_domain} != {base_domain}")
+                return False, None
+                
+            new_tld = get_tld(str(final_response.url))
+            if new_tld != get_tld(url):
+                return True, new_tld
+                
+            return True, None
+            
+        except (httpx.RequestError, ssl.SSLError) as e:
+            console.print(f"[red]Connection error: {str(e)}")
+            time.sleep(sleep)
+            continue
+            
+    return False, None
+
+def search_domain(site_name: str, base_url: str, get_first: bool = False):
+    """Search for valid domain matching site name and base URL."""
+    max_timeout = config_manager.get_int("REQUESTS", "timeout")
+    domain = str(config_manager.get_dict("SITE", site_name)['domain'])
+    
+    # Test initial URL
+    try:
+        is_correct, redirect_tld = validate_url(base_url, base_url, max_timeout)
+
+        if is_correct:
+            tld = redirect_tld or get_tld(base_url)
+            config_manager.config['SITE'][site_name]['domain'] = tld
+            config_manager.write_config()
+            console.print(f"[green]Successfully validated initial URL")
+            return tld, base_url
+        
+    except Exception as e:
+        console.print(f"[red]Error testing initial URL: {str(e)}")
+
+    # Google search phase
+    base_domain = get_base_domain(base_url)
+    console.print(f"\n[cyan]Searching for alternate domains for[white]: [yellow]{base_domain}")
+    
+    try:
+        search_results = list(search(base_domain, num_results=20, lang="it"))
+
+        base_urls = set()
+        for url in search_results:
+            element_url = get_base_url(url)
+            if element_url:
+                base_urls.add(element_url)
+        
+        # Filter URLs based on domain matching and subdomain count
+        filtered_results = [
+            url for url in base_urls 
+            if get_base_domain(url) == base_domain 
+            and url.count('.') <= base_url.count('.') + 1
+        ]
+
+        for idx, result_url in enumerate(filtered_results, 1):
+            console.print(f"\n[cyan]Checking result {idx}/{len(filtered_results)}[white]: [yellow]{result_url}")
+            
+            is_valid, new_tld = validate_url(result_url, base_url, max_timeout)
+            if is_valid:
+                final_tld = new_tld or get_tld(result_url)
+
+                if get_first or msg.ask(
+                    f"\n[cyan]Update site[white] [red]'{site_name}'[cyan] with domain[white] [red]'{final_tld}'",
+                    choices=["y", "n"],
+                    default="y"
+                ).lower() == "y":
+                    
+                    config_manager.config['SITE'][site_name]['domain'] = final_tld
+                    config_manager.write_config()
+                    return final_tld, f"{base_url}.{final_tld}"
+                    
+    except Exception as e:
+        console.print(f"[red]Error during search: {str(e)}")
+
+    console.print("[bold red]No valid URLs found matching the base URL.")
+    return domain, f"{base_url}.{domain}"

StreamingCommunity/Api/Template/Util/manage_ep.py

@@ -0,0 +1,179 @@
+# 19.06.24
+
+import logging
+from typing import List
+
+
+# Internal utilities
+from StreamingCommunity.Util._jsonConfig import config_manager
+from StreamingCommunity.Util.os import os_manager
+
+
+# Config
+MAP_EPISODE = config_manager.get('DEFAULT', 'map_episode_name')
+
+
+def dynamic_format_number(n: int) -> str:
+    """
+    Formats a number by adding a leading zero if it is less than 9.
+    The width of the resulting string is dynamic, calculated as the number of digits in the number plus one 
+    for numbers less than 9, otherwise the width remains the same.
+    
+    Parameters:
+        - n (int): The number to format.
+    
+    Returns:
+        - str: The formatted number as a string with a leading zero if the number is less than 9.
+    """
+    if n < 10:
+        width = len(str(n)) + 1
+    else:
+        width = len(str(n))
+
+    return str(n).zfill(width)
+
+
+def manage_selection(cmd_insert: str, max_count: int) -> List[int]:
+    """
+    Manage user selection for seasons or episodes to download.
+
+    Parameters:
+        - cmd_insert (str): User input for selection.
+        - max_count (int): Maximum count available.
+
+    Returns:
+        list_selection (List[int]): List of selected items.
+    """
+    list_selection = []
+    logging.info(f"Command insert: {cmd_insert}, end index: {max_count + 1}")
+
+    # For a single number (e.g., '5')
+    if cmd_insert.isnumeric():
+        list_selection.append(int(cmd_insert))
+
+    # For a range (e.g., '5-12')
+    elif "-" in cmd_insert:
+        start, end = map(str.strip, cmd_insert.split('-'))
+        start = int(start)
+        end = int(end) if end.isnumeric() else max_count
+
+        list_selection = list(range(start, end + 1))
+        
+    # For all items ('*')
+    elif cmd_insert == "*":
+        list_selection = list(range(1, max_count + 1))
+
+    else:
+        raise ValueError("Invalid input format")
+
+    logging.info(f"List return: {list_selection}")
+    return list_selection
+
+
+def map_episode_title(tv_name: str, number_season: int, episode_number: int, episode_name: str) -> str:
+    """
+    Maps the episode title to a specific format.
+
+    Parameters:
+        tv_name (str): The name of the TV show.
+        number_season (int): The season number.
+        episode_number (int): The episode number.
+        episode_name (str): The original name of the episode.
+
+    Returns:
+        str: The mapped episode title.
+    """
+    map_episode_temp = MAP_EPISODE
+    
+    if tv_name != None:
+        map_episode_temp = map_episode_temp.replace("%(tv_name)", os_manager.get_sanitize_file(tv_name))
+
+    if number_season != None:
+        map_episode_temp = map_episode_temp.replace("%(season)", number_season)
+    else:
+        map_episode_temp = map_episode_temp.replace("%(season)", dynamic_format_number(0))
+
+    if episode_number != None:
+        map_episode_temp = map_episode_temp.replace("%(episode)", dynamic_format_number(episode_number))
+    else:
+        map_episode_temp = map_episode_temp.replace("%(episode)", dynamic_format_number(0))
+
+    if episode_name != None:
+        map_episode_temp = map_episode_temp.replace("%(episode_name)", os_manager.get_sanitize_file(episode_name))
+
+    logging.info(f"Map episode string return: {map_episode_temp}")
+    return map_episode_temp
+
+
+# --> for season
+def validate_selection(list_season_select: List[int], seasons_count: int) -> List[int]:
+    """
+    Validates and adjusts the selected seasons based on the available seasons.
+
+    Parameters:
+        - list_season_select (List[int]): List of seasons selected by the user.
+        - seasons_count (int): Total number of available seasons.
+
+    Returns:
+        - List[int]: Adjusted list of valid season numbers.
+    """
+    while True:
+        try:
+            
+            # Remove any seasons greater than the available seasons
+            valid_seasons = [season for season in list_season_select if 1 <= season <= seasons_count]
+
+            # If the list is empty, the input was completely invalid
+            if not valid_seasons:
+                logging.error(f"Invalid selection: The selected seasons are outside the available range (1-{seasons_count}). Please try again.")
+
+                # Re-prompt for valid input
+                input_seasons = input(f"Enter valid season numbers (1-{seasons_count}): ")
+                list_season_select = list(map(int, input_seasons.split(',')))
+                continue  # Re-prompt the user if the selection is invalid
+            
+            return valid_seasons  # Return the valid seasons if the input is correct
+        
+        except ValueError:
+            logging.error("Error: Please enter valid integers separated by commas.")
+
+            # Prompt the user for valid input again
+            input_seasons = input(f"Enter valid season numbers (1-{seasons_count}): ")
+            list_season_select = list(map(int, input_seasons.split(',')))
+
+
+# --> for episode
+def validate_episode_selection(list_episode_select: List[int], episodes_count: int) -> List[int]:
+    """
+    Validates and adjusts the selected episodes based on the available episodes.
+
+    Parameters:
+        - list_episode_select (List[int]): List of episodes selected by the user.
+        - episodes_count (int): Total number of available episodes in the season.
+
+    Returns:
+        - List[int]: Adjusted list of valid episode numbers.
+    """
+    while True:
+        try:
+
+            # Remove any episodes greater than the available episodes
+            valid_episodes = [episode for episode in list_episode_select if 1 <= episode <= episodes_count]
+
+            # If the list is empty, the input was completely invalid
+            if not valid_episodes:
+                logging.error(f"Invalid selection: The selected episodes are outside the available range (1-{episodes_count}). Please try again.")
+
+                # Re-prompt for valid input
+                input_episodes = input(f"Enter valid episode numbers (1-{episodes_count}): ")
+                list_episode_select = list(map(int, input_episodes.split(',')))
+                continue  # Re-prompt the user if the selection is invalid
+            
+            return valid_episodes
+        
+        except ValueError:
+            logging.error("Error: Please enter valid integers separated by commas.")
+            
+            # Prompt the user for valid input again
+            input_episodes = input(f"Enter valid episode numbers (1-{episodes_count}): ")
+            list_episode_select = list(map(int, input_episodes.split(',')))

StreamingCommunity/Api/Template/Util/recall_search.py

@@ -0,0 +1,37 @@
+# 19.10.24
+
+import os
+import sys
+
+def execute_search(info):
+    """
+    Dynamically imports and executes a specified function from a module defined in the info dictionary.
+
+    Parameters:
+        info (dict): A dictionary containing the function name, folder, and module information.
+    """
+
+    # Define the project path using the folder from the info dictionary
+    project_path = os.path.dirname(info['folder'])  # Get the base path for the project
+
+    # Add the project path to sys.path
+    if project_path not in sys.path:
+        sys.path.append(project_path)
+
+    # Attempt to import the specified function from the module
+    try:
+        # Construct the import statement dynamically
+        module_path = f"StreamingCommunity.Api.Site{info['folder_base']}"
+        exec(f"from {module_path} import {info['function']}")
+
+        # Call the specified function
+        eval(info['function'])()  # Calls the search function
+
+    except ModuleNotFoundError as e:
+        print(f"ModuleNotFoundError: {e}")
+
+    except ImportError as e:
+        print(f"ImportError: {e}")
+
+    except Exception as e:
+        print(f"An error occurred: {e}")

StreamingCommunity/Api/Template/__init__.py

@@ -0,0 +1,3 @@
+# 19.06.24
+
+from .site import get_select_title